Merge branch 'master' into dispmanx

611 files changed, 61437 insertions, 5668 deletions

diff --git a/engines/access/access.cpp b/engines/access/access.cpp
index 7f59ae7ad6..56fa6c7533 100644
--- a/engines/access/access.cpp
+++ b/engines/access/access.cpp
@@ -52,11 +52,10 @@ AccessEngine::AccessEngine(OSystem *syst, const AccessGameDescription *gameDesc)
 	_destIn = nullptr;
 	_current = nullptr;
 	_mouseMode = 0;
+	_playerDataCount = 0;
 	_currentMan = 0;
 	_currentManOld = -1;
 	_converseMode = 0;
-	_startAboutBox = 0;
-	_startTravelBox = 0;
 	_numAnimTimers = 0;
 	_startup = 0;
 	_currentCharFlag = false;
@@ -94,11 +93,36 @@ AccessEngine::AccessEngine(OSystem *syst, const AccessGameDescription *gameDesc)
 	_cheatFl = false;
 	_restartFl = false;
 	_printEnd = 0;
+	for (int i = 0; i < 100; i++)
+		_objectsTable[i] = nullptr;
+	_clearSummaryFlag = false;
+
+	for (int i = 0; i < 60; i++)
+		_travel[i] = 0;
+	_startTravelItem = _startTravelBox = 0;
+	for (int i = 0; i < 33; i++)
+		_ask[i] = 0;
+	_startAboutItem = _startAboutBox = 0;
+	_byte26CB5 = 0;
+	_bcnt = 0;
+	_boxDataStart = 0;
+	_boxDataEnd = false;
+	_boxSelectY = 0;
+	_boxSelectYOld = -1;
+	_numLines = 0;
+	_tempList = nullptr;
+	_pictureTaken = 0;
+
+	_vidEnd = false;
 }
 
 AccessEngine::~AccessEngine() {
 	delete _animation;
 	delete _bubbleBox;
+	delete _helpBox;
+	delete _travelBox;
+	delete _invBox;
+	delete _aboutBox;
 	delete _char;
 	delete _debugger;
 	delete _events;
@@ -144,7 +168,18 @@ void AccessEngine::initialize() {
 
 	// Create sub-objects of the engine
 	_animation = new AnimationManager(this);
-	_bubbleBox = new BubbleBox(this);
+	_bubbleBox = new BubbleBox(this, TYPE_2, 64, 32, 130, 122, 0, 0, 0, 0, "");
+	if (getGameID() == GType_MartianMemorandum) {
+		_helpBox = new BubbleBox(this, TYPE_1, 64, 24, 146, 122, 1, 32, 2, 76, "HELP");
+		_travelBox = new BubbleBox(this, TYPE_1, 64, 32, 194, 122, 1, 24, 2, 74, "TRAVEL");
+		_invBox = new BubbleBox(this, TYPE_1, 64, 32, 146, 122, 1, 32, 2, 76, "INVENTORY");
+		_aboutBox = new BubbleBox(this, TYPE_1, 64, 32, 194, 122, 1, 32, 2, 76, "ASK ABOUT");
+	} else {
+		_helpBox = nullptr;
+		_travelBox = nullptr;
+		_invBox = nullptr;
+		_aboutBox = nullptr;
+	}
 	_char = new CharManager(this);
 	_debugger = Debugger::init(this);
 	_events = new EventsManager(this);
@@ -413,10 +448,6 @@ void AccessEngine::playVideo(int videoNum, const Common::Point &pt) {
 	}
 }
 
-void AccessEngine::doLoadSave() {
-	error("TODO: doLoadSave");
-}
-
 void AccessEngine::freeChar() {
 	_scripts->freeScriptData();
 	_animation->clearTimers();
@@ -569,6 +600,36 @@ void AccessEngine::writeSavegameHeader(Common::OutSaveFile *out, AccessSavegameH
 	out->writeUint32LE(_events->getFrameCounter());
 }
 
+void AccessEngine::SPRINTCHR(char c, int fontNum) {
+	warning("TODO: SPRINTCHR");
+	_fonts._font1.drawChar(_screen, c, _screen->_printOrg);
+}
+
+void AccessEngine::PRINTCHR(Common::String msg, int fontNum) {
+	_events->hideCursor();
+	warning("TODO: PRINTCHR - Handle fontNum");
+
+	for (int i = 0; msg[i]; i++) {
+		if (!(_fonts._charSet._hi & 8)) {
+			_fonts._font1.drawChar(_screen, msg[i], _screen->_printOrg);
+			continue;
+		} else if (_fonts._charSet._hi & 2) {
+			Common::Point oldPos = _screen->_printOrg;
+			int oldFontLo = _fonts._charFor._lo;
+
+			_fonts._charFor._lo = 0;
+			_screen->_printOrg.x++;
+			_screen->_printOrg.y++;
+			SPRINTCHR(msg[i], fontNum);
+
+			_screen->_printOrg = oldPos;
+			_fonts._charFor._lo = oldFontLo;
+		}
+		SPRINTCHR(msg[i], fontNum);
+	}
+	_events->showCursor();
+}
+
 bool AccessEngine::shouldQuitOrRestart() {
 	return shouldQuit() || _restartFl;
 }
diff --git a/engines/access/access.h b/engines/access/access.h
index be007e0cb8..37b9fec5a5 100644
--- a/engines/access/access.h
+++ b/engines/access/access.h
@@ -137,6 +137,10 @@ protected:
 public:
 	AnimationManager *_animation;
 	BubbleBox *_bubbleBox;
+	BubbleBox *_helpBox;
+	BubbleBox *_travelBox;
+	BubbleBox *_invBox;
+	BubbleBox *_aboutBox;
 	CharManager *_char;
 	Debugger *_debugger;
 	EventsManager *_events;
@@ -173,10 +177,9 @@ public:
 	ImageEntryList _images;
 	int _mouseMode;
 
+	int _playerDataCount;
 	int _currentManOld;
 	int _converseMode;
-	int _startAboutBox;
-	int _startTravelBox;
 	bool _currentCharFlag;
 	bool _boxSelect;
 	int _scale;
@@ -204,6 +207,26 @@ public:
 	uint32 _newDate;
 	int _flags[256];
 
+	// Fields used by MM
+	// TODO: Refactor
+	int _travel[60];
+	int _ask[40];
+	int _startTravelItem;
+	int _startTravelBox;
+	int _startAboutItem;
+	int _startAboutBox;
+	int _boxDataStart;
+	bool _boxDataEnd;
+	int _boxSelectY;
+	int _boxSelectYOld;
+	int _numLines;
+	byte _byte26CB5;
+	int _bcnt;
+	byte *_tempList;
+	int _pictureTaken;
+	//
+
+	bool _vidEnd;
 	bool _clearSummaryFlag;
 	bool _cheatFl;
 	bool _restartFl;
@@ -250,8 +273,6 @@ public:
 
 	void copyBF2Vid();
 
-	void doLoadSave();
-
 	void freeChar();
 
 	/**
@@ -289,6 +310,9 @@ public:
 	 * Write out a savegame header
 	 */
 	void writeSavegameHeader(Common::OutSaveFile *out, AccessSavegameHeader &header);
+
+	void SPRINTCHR(char c, int fontNum);
+	void PRINTCHR(Common::String msg, int fontNum);
 };
 
 } // End of namespace Access
diff --git a/engines/access/amazon/amazon_game.cpp b/engines/access/amazon/amazon_game.cpp
index 4c9df7b8ff..7a55873d97 100644
--- a/engines/access/amazon/amazon_game.cpp
+++ b/engines/access/amazon/amazon_game.cpp
@@ -195,8 +195,8 @@ void AmazonEngine::initVariables() {
 		_timers.push_back(te);
 	}
 
-	_player->_playerX = _player->_rawPlayer.x = TRAVEL_POS[_player->_roomNumber][0];
-	_player->_playerY = _player->_rawPlayer.y = TRAVEL_POS[_player->_roomNumber][1];
+	_player->_playerX = _player->_rawPlayer.x = _travelPos[_player->_roomNumber][0];
+	_player->_playerY = _player->_rawPlayer.y = _travelPos[_player->_roomNumber][1];
 	_room->_selectCommand = -1;
 	_events->setNormalCursor(CURSOR_CROSSHAIRS);
 	_mouseMode = 0;
@@ -260,13 +260,24 @@ void AmazonEngine::doEstablish(int screenId, int estabIndex) {
 	_screen->setIconPalette();
 	_screen->forceFadeIn();
 
-	_fonts._charSet._lo = 1;
-	_fonts._charSet._hi = 10;
-	_fonts._charFor._lo = 29;
-	_fonts._charFor._hi = 32;
+	if (getGameID() == GType_MartianMemorandum) {
+		_fonts._charSet._lo = 1;
+		_fonts._charSet._hi = 10;
+		_fonts._charFor._lo = 0xF7;
+		_fonts._charFor._hi = 0xFF;
+
+		_screen->_maxChars = 50;
+		_screen->_printOrg = _screen->_printStart = Common::Point(24, 18);
+	} else {
+		_fonts._charSet._lo = 1;
+		_fonts._charSet._hi = 10;
+		_fonts._charFor._lo = 29;
+		_fonts._charFor._hi = 32;
+
+		_screen->_maxChars = 37;
+		_screen->_printOrg = _screen->_printStart = Common::Point(48, 35);
+	}
 
-	_screen->_maxChars = 37;
-	_screen->_printOrg = _screen->_printStart = Common::Point(48, 35);
 	loadEstablish(estabIndex);
 	uint16 msgOffset;
 	if (!isCD())
diff --git a/engines/access/amazon/amazon_logic.cpp b/engines/access/amazon/amazon_logic.cpp
index 6dffb85e5e..de53da51cd 100644
--- a/engines/access/amazon/amazon_logic.cpp
+++ b/engines/access/amazon/amazon_logic.cpp
@@ -326,16 +326,8 @@ void Opening::doTitle() {
 		_vm->_buffer2.copyFrom(*_vm->_screen);
 		_vm->_buffer1.copyFrom(*_vm->_screen);
 		screen.forceFadeIn();
-		_vm->_sound->playSound(1);
 
-		// WORKAROUND: This delay has been added to replace original game delay that
-		// came from loading resources, since nowadays it would be too fast to be visible
-		// nowadays to be visible.
-		_vm->_events->_vbCount = 70;
-		while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0)
-			_vm->_events->pollEventsAndWait();
-		if (_vm->shouldQuit())
-			return;
+		_vm->_sound->playSound(1, true);
 
 		Resource *spriteData = _vm->_files->loadFile(0, 2);
 		_vm->_objectsTable[0] = new SpriteResource(_vm, spriteData);
@@ -343,7 +335,6 @@ void Opening::doTitle() {
 
 		_vm->_files->_setPaletteFlag = false;
 		_vm->_files->loadScreen(0, 4);
-		_vm->_sound->playSound(1);
 
 		_vm->_buffer2.copyFrom(*_vm->_screen);
 		_vm->_buffer1.copyFrom(*_vm->_screen);
@@ -356,7 +347,6 @@ void Opening::doTitle() {
 			_vm->_buffer2.plotImage(_vm->_objectsTable[0], id, Common::Point(xp, 71));
 			_vm->_buffer2.copyTo(_vm->_screen);
 
-			_vm->_sound->playSound(1);
 			_vm->_events->_vbCount = 70;
 			while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0 && !_skipStart) {
 				_vm->_events->pollEventsAndWait();
@@ -368,6 +358,7 @@ void Opening::doTitle() {
 			return;
 
 		_vm->_sound->stopSound();
+		_vm->_sound->checkSoundQueue(); // HACK: Clear sound 1 from the queue
 		_vm->_sound->playSound(0);
 		screen.forceFadeOut();
 		_vm->_events->_vbCount = 100;
@@ -386,7 +377,7 @@ void Opening::doTitle() {
 		_vm->_buffer1.blitFrom(*_vm->_screen);
 		screen.forceFadeIn();
 		_vm->_midi->newMusic(1, 0);
-		_vm->_events->_vbCount = 700;
+		_vm->_events->_vbCount = 950;
 		while (!_vm->shouldQuit() && (_vm->_events->_vbCount > 0) && !_vm->_events->isKeyMousePressed()) {
 			_vm->_events->pollEventsAndWait();
 		}
@@ -1605,7 +1596,7 @@ void River::moveCanoe() {
 		moveCanoe2();
 	} else {
 		if (events._leftButton && pt.y >= 140) {
-			if (pt.x < RMOUSE[8][0]) {
+			if (pt.x < _vm->_room->_rMouse[8][0]) {
 				// Disk icon wasn't clicked
 				_vm->_scripts->printString(BAR_MESSAGE);
 			} else {
diff --git a/engines/access/amazon/amazon_player.cpp b/engines/access/amazon/amazon_player.cpp
index b1ed501fce..903da6c532 100644
--- a/engines/access/amazon/amazon_player.cpp
+++ b/engines/access/amazon/amazon_player.cpp
@@ -48,7 +48,7 @@ void AmazonPlayer::load() {
 		_downDelta = -2;
 		_scrollConst = 2;
 
-		for (int i = 0; i < PLAYER_DATA_COUNT; ++i) {
+		for (int i = 0; i < _vm->_playerDataCount; ++i) {
 			_walkOffRight[i] = OVEROFFR[i];
 			_walkOffLeft[i] = OVEROFFL[i];
 			_walkOffUp[i] = OVEROFFU[i];
@@ -78,6 +78,22 @@ void AmazonPlayer::load() {
 		_diagDownWalkMin = 0;
 		_diagDownWalkMax = 5;
 		_game->_guard->setPosition(Common::Point(56, 190));
+	} else {
+		for (int i = 0; i < _vm->_playerDataCount; ++i) {
+			_walkOffRight[i] = SIDEOFFR[i];
+			_walkOffLeft[i] = SIDEOFFL[i];
+			_walkOffUp[i] = SIDEOFFU[i];
+			_walkOffDown[i] = SIDEOFFD[i];
+
+			_walkOffUR[i].x = DIAGOFFURX[i];
+			_walkOffUR[i].y = DIAGOFFURY[i];
+			_walkOffDR[i].x = DIAGOFFDRX[i];
+			_walkOffDR[i].y = DIAGOFFDRY[i];
+			_walkOffUL[i].x = DIAGOFFULX[i];
+			_walkOffUL[i].y = DIAGOFFULY[i];
+			_walkOffDL[i].x = DIAGOFFDLX[i];
+			_walkOffDL[i].y = DIAGOFFDLY[i];
+		}
 	}
 }
 
diff --git a/engines/access/amazon/amazon_resources.cpp b/engines/access/amazon/amazon_resources.cpp
index 2010c7d842..430aa64f30 100644
--- a/engines/access/amazon/amazon_resources.cpp
+++ b/engines/access/amazon/amazon_resources.cpp
@@ -72,6 +72,19 @@ const char *const FILENAMES_DEMO[] = {
 	"CHAPTER.AP", "MUSIC.AP", "SOUND.AP", "INV.AP"
 };
 
+const int SIDEOFFR[] = { 5, 5, 5, 5, 5, 5, 5, 5, 0 };
+const int SIDEOFFL[] = { 5, 5, 5, 5, 5, 5, 5, 5, 0 };
+const int SIDEOFFU[] = { 2, 2, 2, 2, 2, 2, 2, 2, 0 };
+const int SIDEOFFD[] = { 2, 2, 2, 2, 2, 2, 2, 2, 0 };
+const int DIAGOFFURX[] = { 4, 5, 2, 2, 3, 4, 2, 2, 0 };
+const int DIAGOFFURY[] = { 2, 3, 2, 2, 2, 3, 1, 1, 0 };
+const int DIAGOFFDRX[] = { 4, 5, 4, 3, 5, 4, 5, 1, 0 };
+const int DIAGOFFDRY[] = { 3, 2, 1, 2, 2, 1, 2, 1, 0 };
+const int DIAGOFFULX[] = { 4, 5, 4, 3, 3, 2, 2, 2, 0 };
+const int DIAGOFFULY[] = { 3, 3, 1, 2, 2, 1, 1, 1, 0 };
+const int DIAGOFFDLX[] = { 4, 5, 3, 3, 5, 4, 6, 1, 0 };
+const int DIAGOFFDLY[] = { 2, 2, 1, 2, 3, 1, 2, 1, 0 };
+
 const byte MOUSE0[] = {
 	// hotspot x and y, uint16 LE
 	0, 0, 0, 0,
@@ -313,7 +326,7 @@ const byte *const CURSORS[10] = {
 	MOUSE0, MOUSE1, MOUSE2, MOUSE3, CURSEYE, CURSHAND, CURSGET, CURSCLIMB, CURSTALK, CURSHELP
 };
 
-const int TRAVEL_POS[][2] = {
+const int _travelPos[][2] = {
 	{ -1, 0 },
 	{ 228, 117 },
 	{ 28, 98 },
@@ -2406,6 +2419,11 @@ const int CAST_END_OBJ1[4][4] = {
 	{ 3, 103, 1300, 10 }
 };
 
-} // End of namespace Amazon
+const int RMOUSE[10][2] = {
+	{ 0, 35 }, { 0, 0 }, { 36, 70 }, { 71, 106 }, { 107, 141 },
+	{ 142, 177 }, { 178, 212 }, { 213, 248 }, { 249, 283 }, { 284, 318 }
+};
 
+
+} // End of namespace Amazon
 } // End of namespace Access
diff --git a/engines/access/amazon/amazon_resources.h b/engines/access/amazon/amazon_resources.h
index a952860bc2..10dea02abc 100644
--- a/engines/access/amazon/amazon_resources.h
+++ b/engines/access/amazon/amazon_resources.h
@@ -45,9 +45,22 @@ struct RiverStruct {
 extern const char *const FILENAMES[];
 extern const char *const FILENAMES_DEMO[];
 
+extern const int SIDEOFFR[];
+extern const int SIDEOFFL[];
+extern const int SIDEOFFU[];
+extern const int SIDEOFFD[];
+extern const int DIAGOFFURX[];
+extern const int DIAGOFFURY[];
+extern const int DIAGOFFDRX[];
+extern const int DIAGOFFDRY[];
+extern const int DIAGOFFULX[];
+extern const int DIAGOFFULY[];
+extern const int DIAGOFFDLX[];
+extern const int DIAGOFFDLY[];
+
 extern const byte *const CURSORS[10];
 
-extern const int TRAVEL_POS[][2];
+extern const int _travelPos[][2];
 
 extern const int OVEROFFR[];
 extern const int OVEROFFL[];
@@ -138,11 +151,11 @@ extern const int HELP1COORDS[2][4];
 extern const int RIVER1OBJ[23][4];
 
 extern const int CAST_END_OBJ[26][4];
-
 extern const int CAST_END_OBJ1[4][4];
 
-} // End of namespace Amazon
+extern const int RMOUSE[10][2];
 
+} // End of namespace Amazon
 } // End of namespace Access
 
 #endif /* ACCESS_AMAZON_RESOURCES_H */
diff --git a/engines/access/amazon/amazon_scripts.cpp b/engines/access/amazon/amazon_scripts.cpp
index 92acb3686d..d8f4663401 100644
--- a/engines/access/amazon/amazon_scripts.cpp
+++ b/engines/access/amazon/amazon_scripts.cpp
@@ -33,6 +33,8 @@ namespace Amazon {
 
 AmazonScripts::AmazonScripts(AccessEngine *vm) : Scripts(vm) {
 	_game = (AmazonEngine *)_vm;
+
+	setOpcodes_v2();
 }
 
 void AmazonScripts::cLoop() {
@@ -378,20 +380,20 @@ void AmazonScripts::executeSpecial(int commandIndex, int param1, int param2) {
 typedef void(AmazonScripts::*AmazonScriptMethodPtr)();
 
 void AmazonScripts::executeCommand(int commandIndex) {
-	static const AmazonScriptMethodPtr COMMAND_LIST[] = {
-		&AmazonScripts::cmdHelp, &AmazonScripts::cmdCycleBack,
+	static const AmazonScriptMethodPtr AMAZON_COMMAND_LIST[] = {
+		&AmazonScripts::cmdHelp_v2, &AmazonScripts::cmdCycleBack,
 		&AmazonScripts::cmdChapter, &AmazonScripts::cmdSetHelp,
 		&AmazonScripts::cmdCenterPanel, &AmazonScripts::cmdMainPanel,
 		&AmazonScripts::CMDRETFLASH
 	};
 
 	if (commandIndex >= 73)
-		(this->*COMMAND_LIST[commandIndex - 73])();
+		(this->*AMAZON_COMMAND_LIST[commandIndex - 73])();
 	else
 		Scripts::executeCommand(commandIndex);
 }
 
-void AmazonScripts::cmdHelp() {
+void AmazonScripts::cmdHelp_v2() {
 	Common::String helpMessage = readString();
 
 	if (_game->_helpLevel == 0) {
diff --git a/engines/access/amazon/amazon_scripts.h b/engines/access/amazon/amazon_scripts.h
index e10eefb4f5..6d992667f5 100644
--- a/engines/access/amazon/amazon_scripts.h
+++ b/engines/access/amazon/amazon_scripts.h
@@ -49,7 +49,7 @@ protected:
 	void setInactive();
 	void boatWalls(int param1, int param2);
 
-	void cmdHelp();
+	void cmdHelp_v2();
 	void cmdCycleBack();
 	void cmdChapter();
 	void cmdSetHelp();
diff --git a/engines/access/asurface.cpp b/engines/access/asurface.cpp
index 5f4372d5af..526690807a 100644
--- a/engines/access/asurface.cpp
+++ b/engines/access/asurface.cpp
@@ -54,6 +54,12 @@ SpriteResource::~SpriteResource() {
 SpriteFrame::SpriteFrame(AccessEngine *vm, Common::SeekableReadStream *stream, int frameSize) {
 	int xSize = stream->readUint16LE();
 	int ySize = stream->readUint16LE();
+
+	if (vm->getGameID() == GType_MartianMemorandum) {
+		int size = stream->readUint16LE();
+		if (size != frameSize)
+			warning("Unexpected file difference: framesize %d - size %d %d - unknown %d", frameSize, xSize, ySize, size);
+	}
 	create(xSize, ySize);
 
 	// Empty surface
@@ -312,6 +318,21 @@ void ASurface::drawRect() {
 	Graphics::Surface::fillRect(Common::Rect(_orgX1, _orgY1, _orgX2, _orgY2), _lColor);
 }
 
+void ASurface::drawLine(int x1, int y1, int x2, int y2, int col) {
+	Graphics::Surface::drawLine(x1, y1, x2, y2, col);
+}
+
+void ASurface::drawLine() {
+	Graphics::Surface::drawLine(_orgX1, _orgY1, _orgX2, _orgY1, _lColor);
+}
+
+void ASurface::drawBox() {
+	Graphics::Surface::drawLine(_orgX1, _orgY1, _orgX2, _orgY1, _lColor);
+	Graphics::Surface::drawLine(_orgX1, _orgY2, _orgX2, _orgY2, _lColor);
+	Graphics::Surface::drawLine(_orgX2, _orgY1, _orgX2, _orgY1, _lColor);
+	Graphics::Surface::drawLine(_orgX2, _orgY2, _orgX2, _orgY2, _lColor);
+}
+
 void ASurface::flipHorizontal(ASurface &dest) {
 	dest.create(this->w, this->h);
 	for (int y = 0; y < h; ++y) {
diff --git a/engines/access/asurface.h b/engines/access/asurface.h
index 4fb47b9c09..022e2534c1 100644
--- a/engines/access/asurface.h
+++ b/engines/access/asurface.h
@@ -95,6 +95,12 @@ public:
 
 	virtual void drawRect();
 
+	virtual void drawLine(int x1, int y1, int x2, int y2, int col);
+
+	virtual void drawLine();
+
+	virtual void drawBox();
+	
 	virtual void transBlitFrom(ASurface *src, const Common::Point &destPos);
 
 	virtual void transBlitFrom(ASurface *src, const Common::Rect &bounds);
diff --git a/engines/access/bubble_box.cpp b/engines/access/bubble_box.cpp
index 28c211991c..df8adc1bc6 100644
--- a/engines/access/bubble_box.cpp
+++ b/engines/access/bubble_box.cpp
@@ -26,13 +26,26 @@
 
 namespace Access {
 
-BubbleBox::BubbleBox(AccessEngine *vm) : Manager(vm) {
-	_startItem = 0;
-	_startBox = 0;
-	_charCol = _rowOff = 0;
-	_type = TYPE_2;
-	_bounds = Common::Rect(64, 32, 64 + 130, 32 + 122);
-	_bubbleDisplStr = "";
+BubbleBox::BubbleBox(AccessEngine *vm, Access::BoxType type, int x, int y, int w, int h, int val1, int val2, int val3, int val4, Common::String title) : Manager(vm) {
+	_type = type;
+	_bounds = Common::Rect(x, y, x + w, y + h);
+	_bubbleDisplStr = title;
+	_btnId1 = val1;
+	_btnX1 = val2;
+	_btnId2 = val3;
+	_btnX2 = val4;
+	_btnId3 = _btnX3 = 0; // Unused in MM and Amazon?
+	_boxStartX = _boxStartY = 0;
+	_bIconStartX = _bIconStartY = 0;
+	_boxEndX = _boxEndY = 0;
+	_boxPStartX = _boxPStartY = 0;
+	// Unused in AGoE
+	for (int i = 0; i < 60; i++) {
+		_tempList[i] = "";
+		_tempListIdx[i] = 0;
+	}
+	_btnUpPos = Common::Rect(0, 0, 0, 0);
+	_btnDownPos = Common::Rect(0, 0, 0, 0);
 }
 
 void BubbleBox::load(Common::SeekableReadStream *stream) {
@@ -61,7 +74,7 @@ void BubbleBox::clearBubbles() {
 }
 
 void BubbleBox::placeBubble(const Common::String &msg) {
-	_vm->_screen->_maxChars = 27;
+	_vm->_screen->_maxChars = (_vm->getGameID() == GType_MartianMemorandum) ? 30 : 27;
 	placeBubble1(msg);
 }
 
@@ -69,8 +82,8 @@ void BubbleBox::placeBubble1(const Common::String &msg) {
 	_bubbles.clear();
 	_vm->_fonts._charSet._lo = 1;
 	_vm->_fonts._charSet._hi = 8;
-	_vm->_fonts._charFor._lo = 29;
-	_vm->_fonts._charFor._hi = 32;
+	_vm->_fonts._charFor._lo = (_vm->getGameID() == GType_MartianMemorandum) ? 247 : 29;
+	_vm->_fonts._charFor._hi = (_vm->getGameID() == GType_MartianMemorandum) ? 255 : 32;
 
 	calcBubble(msg);
 
@@ -86,7 +99,7 @@ void BubbleBox::calcBubble(const Common::String &msg) {
 	Common::Point printStart = _vm->_screen->_printStart;
 
 	// Figure out maximum width allowed
-	if (_type == TYPE_4) {
+	if (_type == kBoxTypeFileDialog) {
 		_vm->_fonts._printMaxX = 110;
 	} else {
 		_vm->_fonts._printMaxX = _vm->_fonts._font2.stringWidth(_bubbleDisplStr);
@@ -108,7 +121,7 @@ void BubbleBox::calcBubble(const Common::String &msg) {
 		_vm->_screen->_printOrg.x = _vm->_screen->_printStart.x;
 	} while (!lastLine);
 
-	if (_type == TYPE_4)
+	if (_type == kBoxTypeFileDialog)
 		++_vm->_screen->_printOrg.y += 6;
 
 	// Determine the width for the area
@@ -119,12 +132,12 @@ void BubbleBox::calcBubble(const Common::String &msg) {
 
 	// Determine the height for area
 	int y = _vm->_screen->_printOrg.y + 6;
-	if (_type == TYPE_4)
+	if (_type == kBoxTypeFileDialog)
 		y += 6;
 	int height = y - bounds.top;
 	bounds.setHeight(height);
 
-	height -= (_type == TYPE_4) ? 30 : 24;
+	height -= (_type == kBoxTypeFileDialog) ? 30 : 24;
 	if (height >= 0)
 		bounds.setHeight(bounds.height() + 13 - (height % 13));
 
@@ -137,6 +150,35 @@ void BubbleBox::calcBubble(const Common::String &msg) {
 }
 
 void BubbleBox::printBubble(const Common::String &msg) {
+	if (_vm->getGameID() == GType_MartianMemorandum)
+		printBubble_v1(msg);
+	else
+		printBubble_v2(msg);
+}
+
+void BubbleBox::printBubble_v1(const Common::String &msg) {
+	drawBubble(_bubbles.size() - 1);
+	
+	// Loop through drawing the lines
+	Common::String s = msg;
+	Common::String line;
+	int width = 0;
+	bool lastLine;
+	do {
+		// Get next line
+		Font &font2 = _vm->_fonts._font2;
+		lastLine = font2.getLine(s, _vm->_screen->_maxChars * 6, line, width);
+		// Draw the text
+		printString(line);
+
+		// Move print position
+		_vm->_screen->_printOrg.y += 6;
+		_vm->_screen->_printOrg.x = _vm->_screen->_printStart.x;
+	} while (!lastLine);
+
+}
+
+void BubbleBox::printBubble_v2(const Common::String &msg) {
 	drawBubble(_bubbles.size() - 1);
 
 	// Loop through drawing the lines
@@ -156,7 +198,7 @@ void BubbleBox::printBubble(const Common::String &msg) {
 		font2._fontColors[3] = 29;
 
 		int xp = _vm->_screen->_printOrg.x;
-		if (_type == TYPE_4)
+		if (_type == kBoxTypeFileDialog)
 			xp = (_bounds.width() - width) / 2 + _bounds.left - 4;
 
 		// Draw the text
@@ -170,7 +212,11 @@ void BubbleBox::printBubble(const Common::String &msg) {
 
 void BubbleBox::drawBubble(int index) {
 	_bounds = _bubbles[index];
-	doBox(0, 0);
+	if (_vm->getGameID() == GType_MartianMemorandum) {
+		int btnSelected = 0;
+		doBox_v1(0, 0, btnSelected);
+	} else
+		doBox(0, 0);
 }
 
 void BubbleBox::doBox(int item, int box) {
@@ -194,7 +240,7 @@ void BubbleBox::doBox(int item, int box) {
 	fonts._charSet._lo = 1;
 	fonts._charSet._hi = 0;
 
-	if (_type == TYPE_4) {
+	if (_type == kBoxTypeFileDialog) {
 		fonts._charFor._lo = 0xFF;
 		error("TODO: filename listing");
 		return;
@@ -212,7 +258,7 @@ void BubbleBox::doBox(int item, int box) {
 	_vm->_screen->_orgY2 = _bounds.bottom;
 	_vm->_screen->_lColor = 1;
 
-	int h = _bounds.height() - (_type == TYPE_4 ? 30 : 24);
+	int h = _bounds.height() - (_type == kBoxTypeFileDialog ? 30 : 24);
 	int ySize = (h < 0) ? 0 : (h + 12) / 13;
 	int w = _bounds.width() - 24;
 	int xSize = (w < 0) ? 0 : (w + 19) / 20;
@@ -229,21 +275,21 @@ void BubbleBox::doBox(int item, int box) {
 	screen.plotImage(icons, 21, Common::Point(xp, screen._orgY1));
 
 	// Draw images to form the bottom border
-	yp = screen._orgY2 - (_type == TYPE_4 ? 18 : 12);
-	screen.plotImage(icons, (_type == TYPE_4) ? 72 : 22,
+	yp = screen._orgY2 - (_type == kBoxTypeFileDialog ? 18 : 12);
+	screen.plotImage(icons, (_type == kBoxTypeFileDialog) ? 72 : 22,
 		Common::Point(screen._orgX1, yp));
 	xp = screen._orgX1 + 12;
-	yp += (_type == TYPE_4) ? 4 : 8;
+	yp += (_type == kBoxTypeFileDialog) ? 4 : 8;
 
 	for (int x = 0; x < xSize; ++x, xp += 20) {
-		screen.plotImage(icons, (_type == TYPE_4 ? 62 : 34) + x,
+		screen.plotImage(icons, (_type == kBoxTypeFileDialog ? 62 : 34) + x,
 			Common::Point(xp, yp));
 	}
 
-	yp = screen._orgY2 - (_type == TYPE_4 ? 18 : 12);
-	screen.plotImage(icons, (_type == TYPE_4) ? 73 : 23, Common::Point(xp, yp));
+	yp = screen._orgY2 - (_type == kBoxTypeFileDialog ? 18 : 12);
+	screen.plotImage(icons, (_type == kBoxTypeFileDialog) ? 73 : 23, Common::Point(xp, yp));
 
-	if (_type == TYPE_4) {
+	if (_type == kBoxTypeFileDialog) {
 		// Further stuff for filename dialog
 		error("TODO: Box type 4");
 	}
@@ -278,4 +324,440 @@ void BubbleBox::doBox(int item, int box) {
 	delete icons;
 }
 
+void BubbleBox::setCursorPos(int posX, int posY) {
+	_vm->_screen->_printStart = _vm->_screen->_printOrg = Common::Point((posX << 3) + _rowOff, posY << 3);
+	warning("Missing call to setCursorPos");
+}
+
+void BubbleBox::printString(Common::String msg) {
+	warning("TODO: Proper implementation of printString");
+	_vm->_fonts._font1.drawString(_vm->_screen, msg, _vm->_screen->_printOrg);
+}
+
+void BubbleBox::displayBoxData() {
+	_vm->_boxDataEnd = false;
+	_rowOff = 2;
+	_vm->_fonts._charFor._lo = 0xF7;
+	_vm->_fonts._charFor._hi = 0xFF;
+
+	if (_tempList[0].size() == 0)
+		return;
+
+	int idx = 0;
+	if ((_type == TYPE_1) || (_type == TYPE_3)) {
+		_vm->_bcnt = 0;
+
+		if (_tempList[idx].size() == 0) {
+			_vm->_boxDataEnd = true;
+			return;
+		}
+
+		_vm->_events->hideCursor();
+
+		_vm->_screen->_orgX1 = _boxStartX;
+		_vm->_screen->_orgX2 = _boxEndX;
+		_vm->_screen->_orgY1 = _boxStartY;
+		_vm->_screen->_orgY2 = _boxEndY;
+		_vm->_screen->_lColor = 0xFA;
+		_vm->_screen->drawRect();
+		_vm->_events->showCursor();
+	}
+	
+	_vm->_events->hideCursor();
+	int oldPStartY = _boxPStartY;
+	++_boxPStartY;
+
+	idx += _vm->_boxDataStart;
+
+	while (true) {
+		setCursorPos(_boxPStartX, _boxPStartY);
+		printString(_tempList[idx]);
+
+		++idx;
+		++_boxPStartY;
+		++_vm->_bcnt;
+		if (_tempList[idx].size() == 0) {
+			_boxPStartY = oldPStartY;
+			_vm->_events->showCursor();
+			_vm->_boxDataEnd = true;
+			return;
+		}
+
+		if (_vm->_bcnt == _vm->_numLines) {
+			_boxPStartY = oldPStartY;
+			_vm->_events->showCursor();
+			return;
+		}
+	}
+}
+
+void BubbleBox::drawSelectBox() {
+	if (_tempList[0].size() == 0)
+		return;
+
+	if (((_type != TYPE_1) && (_type != TYPE_3)) || !_vm->_bcnt)
+		return;
+
+	if (_vm->_boxSelectYOld != -1) {
+		_vm->_events->hideCursor();
+		_vm->_screen->_lColor = 0xFA;
+
+		int val = _vm->_boxSelectYOld + _boxPStartY + 1;
+		_vm->_screen->_orgY1 = (val << 3) + 2;
+		_vm->_screen->_orgY2 = _vm->_screen->_orgY1 + 7;
+		_vm->_screen->_orgX1 = _boxStartX;
+		_vm->_screen->_orgX2 = _boxEndX;
+		_vm->_screen->drawBox();
+		_vm->_events->showCursor();
+	}
+
+	_vm->_events->hideCursor();
+	_vm->_boxSelectYOld = _vm->_boxSelectY;
+	int val = _boxPStartY + _vm->_boxSelectY + 1;
+	_vm->_screen->_orgY1 = (val << 3) + 2;
+	_vm->_screen->_orgY2 = _vm->_screen->_orgY1 + 7;
+	_vm->_screen->_orgX1 = _boxStartX;
+	_vm->_screen->_orgX2 = _boxEndX;
+	_vm->_screen->_lColor = 0xFE;
+	_vm->_screen->drawBox();
+	_vm->_events->showCursor();
+
+	if (_type == TYPE_3)
+		warning("TODO: List filenames");
+}
+
+int BubbleBox::doBox_v1(int item, int box, int &btnSelected) {
+	static const int ICONW[] = { 0, 11, 28, 19, 19, 15 };
+
+	FontManager &fonts = _vm->_fonts;
+	int retval_ = -1;
+
+	_startItem = item;
+	_startBox = box;
+
+	// Save state information
+	_vm->_screen->saveScreen();
+	_vm->_screen->setDisplayScan();
+
+	fonts._charFor._hi = 0xff;
+	fonts._charSet._lo = 1;
+	fonts._charSet._hi = 0;
+
+	_vm->_destIn = _vm->_screen;	// TODO: Redundant
+
+	if (_type != TYPE_2) {
+		Common::Rect r = _bounds;
+		r.left -= 2;
+		_vm->_screen->saveBlock(r);
+	}
+
+	// Set the up boundaries and color to use for the box background
+	_vm->_screen->_orgX1 = _bounds.left - 2;
+	_vm->_screen->_orgY1 = _bounds.top;
+	_vm->_screen->_orgX2 = _bounds.right - 2;
+	_vm->_screen->_orgY2 = _bounds.bottom;
+	_vm->_screen->_lColor = 0xFB;
+
+	// Draw a background for the entire area
+	_vm->_screen->drawRect();
+
+	// Draw the inner box;
+	++_vm->_screen->_orgX1;
+	++_vm->_screen->_orgY1;
+	--_vm->_screen->_orgX2;
+	--_vm->_screen->_orgY2;
+	_vm->_screen->_lColor = 0xF9;
+	
+	// Draw the inner border
+	_vm->_screen->drawBox();
+
+	// Get icons data
+	Resource *iconData = _vm->_files->loadFile("ICONS.LZ");
+	SpriteResource *icons = new SpriteResource(_vm, iconData);
+	delete iconData;
+
+	// Draw upper border
+	_vm->_bcnt = (_vm->_screen->_orgX2 - _vm->_screen->_orgX1) >> 4;
+	int oldX = _vm->_screen->_orgX1;
+	for ( ;_vm->_bcnt > 0; --_vm->_bcnt) {
+		_vm->_screen->plotImage(icons, 16, Common::Point(_vm->_screen->_orgX1, _vm->_screen->_orgY1));
+		_vm->_screen->_orgX1 += 16;
+	}
+
+	_vm->_screen->_orgX1 = oldX;
+	int oldY = _vm->_screen->_orgY2;
+	_vm->_screen->_orgY2 = _vm->_screen->_orgY1 + 8;
+	_vm->_screen->_lColor = 0xF9;
+
+	_boxStartY = _vm->_screen->_orgY2 + 1;
+	_vm->_screen->_orgY2 = oldY;
+
+	int tmpX = 0;
+	int tmpY = 0;
+	if (_type != TYPE_2) {
+		oldY = _vm->_screen->_orgY1;
+		--_vm->_screen->_orgY2;
+		_vm->_screen->_orgY1 = _vm->_screen->_orgY2 - 8;
+		if (_type == TYPE_3)
+			_vm->_screen->_orgY1 -= 8;
+		_vm->_screen->drawRect();
+		tmpX = _bIconStartX = _vm->_screen->_orgX1;
+
+		_boxStartX = tmpX + 1;
+		tmpY = _boxEndY = _vm->_screen->_orgY1;
+
+		if (_type == TYPE_3)
+			_bIconStartY = tmpY + 9;
+		else
+			_bIconStartY = tmpY + 1;
+
+		if (_type == TYPE_3) {
+			_fileStart = Common::Point((tmpX + 2) >> 3, (tmpY + 2) >> 3);
+			int rowOff = tmpY - (_fileStart.y << 3) + 1;
+			if (rowOff == 8) {
+				rowOff = 0;
+				++_fileStart.y;
+			}
+			_fileOff.y = _rowOff = rowOff;
+			setCursorPos(_fileStart.x, _fileStart.y);
+			_vm->_fonts._charFor._lo = 0xF7;
+			_vm->_fonts._charFor._hi = 0;
+			printString("FILE:           ");
+			_vm->_fonts._charFor._hi = 0xFF;
+		}
+		_vm->_screen->_orgY1 = oldY;
+	}
+
+	if ((_type != TYPE_0) && (_type != TYPE_2)) {
+		_vm->_screen->_orgY1 += 8;
+		if (_type == TYPE_3)
+			_vm->_screen->_orgY2 -= 8;
+
+		_vm->_screen->_orgY2 -= 8;
+		_btnUpPos.right = _btnDownPos.right = _vm->_screen->_orgX2;
+		_btnUpPos.left = _btnDownPos.left = _vm->_screen->_orgX1 = _vm->_screen->_orgX2 - 8;
+		_boxEndX = _vm->_screen->_orgX1 - 1;
+		_vm->_screen->drawBox();
+
+		_vm->_screen->_orgY1 += 6;
+		_vm->_screen->_orgY2 -= 6;
+		_vm->_screen->drawBox();
+
+		_btnUpPos.bottom = _vm->_screen->_orgY1 + 1;
+		_btnUpPos.top = _btnUpPos.bottom - 5;
+		_btnDownPos.top = _vm->_screen->_orgY2 + 1;
+		_btnDownPos.bottom = _btnDownPos.top + 6;
+
+		_vm->_screen->_orgX1 += 4;
+		_vm->_screen->_orgX2 = _vm->_screen->_orgX1;
+		_vm->_screen->_orgY1 -= 4;
+		_vm->_screen->_orgY2 += 2;
+		_vm->_screen->drawLine();
+
+		++_vm->_screen->_orgY1;
+		--_vm->_screen->_orgX1;
+		++_vm->_screen->_orgX2;
+		_vm->_screen->drawLine();
+
+		++_vm->_screen->_orgY1;
+		--_vm->_screen->_orgX1;
+		++_vm->_screen->_orgX2;
+		_vm->_screen->drawLine();
+
+		_vm->_screen->_orgY1 = _vm->_screen->_orgY2;
+		_vm->_screen->drawLine();
+
+		++_vm->_screen->_orgX1;
+		--_vm->_screen->_orgX2;
+		++_vm->_screen->_orgY1;
+		_vm->_screen->drawLine();
+
+		++_vm->_screen->_orgX1;
+		--_vm->_screen->_orgX2;
+		++_vm->_screen->_orgY1;
+		_vm->_screen->drawLine();
+	}
+
+	int len = _bubbleDisplStr.size();
+	int newX = _bounds.top >> 3;
+	newX = (len - newX) / 2;
+
+	_boxPStartX = _bounds.left >> 3;
+	newX += _boxPStartX;
+
+	int newY = _bounds.top >> 3;
+	int bp = _bounds.top - (newY << 3) + 1;
+	if (bp == 8) {
+		++newY;
+		bp = 0;
+	}
+
+	_rowOff = bp;
+	retval_ = _boxPStartY = newY;
+
+	setCursorPos(newX, newY);
+
+	_vm->_fonts._charFor._lo = 0xFF;
+	_vm->_fonts._font1.drawString(_vm->_screen, _bubbleDisplStr, _vm->_screen->_printOrg);
+
+	if (_type == TYPE_2) {
+		_vm->_events->showCursor();
+		warning("TODO: pop values");
+		_vm->_screen->restoreScreen();
+		return retval_;
+	}
+
+	_vm->_destIn = _vm->_screen;
+
+	// Draw buttons
+	int ICON1T = 0;
+	int ICON1X = 0;
+	int ICON1Y = 0;
+	int ICON2T = 0;
+	int ICON2X = 0;
+	int ICON3T = 0;
+	int ICON3X = 0;
+	if (_btnId1) {
+		ICON1T = _btnId1;
+		ICON1X = _bIconStartX + _btnX1;
+		ICON1Y = _bIconStartY;
+		_vm->_screen->plotImage(icons, ICON1T + 10, Common::Point(ICON1X, ICON1Y));
+
+		if (_btnId2) {
+			ICON2T = _btnId2;
+			ICON2X = _bIconStartX + _btnX2;
+			_vm->_screen->plotImage(icons, ICON2T + 10, Common::Point(ICON2X, _bIconStartY));
+
+			if (_btnId3) {
+				ICON3T = _btnId3;
+				ICON3X = _bIconStartX + _btnX3;
+				_vm->_screen->plotImage(icons, ICON3T + 10, Common::Point(ICON3X, _bIconStartY));
+			}
+		}
+	}
+	
+	_vm->_screen->restoreScreen();
+	_vm->_boxDataStart = _startItem;
+	_vm->_boxSelectYOld = -1;
+	_vm->_boxSelectY = _startBox;
+
+	_vm->_numLines = (_bounds.bottom >> 3) - 2;
+	if (_type == TYPE_3)
+		--_vm->_numLines;
+
+	_vm->_events->showCursor();
+	displayBoxData();
+	drawSelectBox();
+
+	while (!_vm->shouldQuit()) {
+		_vm->_events->pollEvents();
+		if (!_vm->_events->_leftButton)
+			continue;
+
+		if (((_type == TYPE_1) || (_type != TYPE_3)) && (_vm->_timers[2]._flag == 0)) {
+			++_vm->_timers[2]._flag;
+			if (_btnUpPos.contains(_vm->_events->_mousePos)) {
+				if (_vm->_bcnt) {
+					if (_vm->_boxSelectY != 0) {
+						--_vm->_boxSelectY;
+						drawSelectBox();
+					} else if (_vm->_boxDataStart != 0) {
+						--_vm->_boxDataStart;
+						displayBoxData();
+						drawSelectBox();
+					}
+				}
+				continue;
+			} else if (_btnDownPos.contains(_vm->_events->_mousePos)) {
+				if (_vm->_bcnt) {
+					if (_vm->_bcnt == _vm->_numLines) {
+						if (_vm->_bcnt != _vm->_boxSelectY + 1) {
+							++_vm->_boxSelectY;
+							drawSelectBox();
+						} else if (!_vm->_boxDataEnd) {
+							++_vm->_boxDataStart;
+							displayBoxData();
+							drawSelectBox();
+						}
+					} else if (_vm->_bcnt != _vm->_boxSelectY + 1) {
+						++_vm->_boxSelectY;
+						drawSelectBox();
+					}
+				}
+				continue;
+			}
+		}
+
+		if ((_vm->_events->_mousePos.x >= _boxStartX) && (_vm->_events->_mousePos.x <= _boxEndX)
+		&&  (_vm->_events->_mousePos.y >= _boxStartY) && (_vm->_events->_mousePos.y <= _boxEndY)) {
+			int val = (_vm->_events->_mousePos.x >> 3) - _boxPStartY;
+			if (val > _vm->_bcnt)
+				continue;
+			--val;
+			if (_type == TYPE_3)
+				_vm->_boxSelect = val;
+			else {
+				btnSelected = 1;
+				if (_vm->_boxSelectY == val)
+					break;
+				_vm->_boxSelectY = val;
+				_vm->_events->debounceLeft();
+				drawSelectBox();
+				continue;
+			}
+		}
+
+		if ((_vm->_events->_mousePos.y >= ICON1Y) && (_vm->_events->_mousePos.y <= ICON1Y + 8)
+		&&  (_vm->_events->_mousePos.x >= ICON1X)) {
+			btnSelected = 1;
+			if (_vm->_events->_mousePos.x < ICON1X + ICONW[ICON1T])
+				break;
+
+			if ((_vm->_events->_mousePos.x >= ICON2X) && (_vm->_events->_mousePos.x < ICON2X + ICONW[ICON2T])) {
+				btnSelected = 2;
+				break;
+			}
+
+			if ((_vm->_events->_mousePos.x >= ICON3X) && (_vm->_events->_mousePos.x < ICON3X + ICONW[ICON3T])) {
+				btnSelected = 3;
+				break;
+			}
+
+			if (_type != TYPE_3)
+				continue;
+			
+			if ((_vm->_events->_mousePos.x < tmpX) || (_vm->_events->_mousePos.x > tmpX + 144))
+				continue;
+
+			if ((_vm->_events->_mousePos.y < tmpY) || (_vm->_events->_mousePos.y > tmpY + 8))
+				continue;
+
+			warning("TODO: sub175B5 - List of files");
+		}
+	}
+
+	_vm->_events->hideCursor();
+	_vm->_screen->restoreBlock();
+	_vm->_events->showCursor();
+	_vm->_events->debounceLeft();
+	if (_vm->_bcnt == 0)
+		retval_ = -1;
+	else
+		retval_ = _vm->_boxDataStart + _vm->_boxSelectY;
+	return retval_;
+}
+
+void BubbleBox::getList(const char *const data[], int *flags) {
+	int srcIdx = 0;
+	int destIdx = 0;
+	while (data[srcIdx]) {
+		if (flags[srcIdx]) {
+			_tempList[destIdx] = Common::String(data[srcIdx]);
+			_tempListIdx[destIdx] = srcIdx;
+			++destIdx;
+		}
+		srcIdx++;
+	}
+	_tempList[destIdx] = "";
+}
 } // End of namespace Access
diff --git a/engines/access/bubble_box.h b/engines/access/bubble_box.h
index 0b3f139520..9a45721108 100644
--- a/engines/access/bubble_box.h
+++ b/engines/access/bubble_box.h
@@ -36,23 +36,46 @@ namespace Access {
 
 class AccessEngine;
 
-enum BoxType { TYPE_2 = 2, TYPE_4 = 4 };
+enum BoxType { TYPE_0 = 0, TYPE_1 = 1, TYPE_2 = 2, TYPE_3 = 3, kBoxTypeFileDialog = 4 };
 
 class BubbleBox : public Manager {
 private:
 	int _startItem, _startBox;
 	int _charCol, _rowOff;
 	Common::Point _fileStart;
+	Common::Point _fileOff;
+	int _boxStartX, _boxStartY;
+	int _boxEndX, _boxEndY;
+	int _bIconStartX, _bIconStartY;
+	int _boxPStartX, _boxPStartY;
+
+	void displayBoxData();
+	void drawSelectBox();
+	/**
+	 * Prints a text bubble and it's contents
+	 */
+	void printBubble_v1(const Common::String &msg);
+	void printBubble_v2(const Common::String &msg);
+
 public:
 	BoxType _type;
 	Common::Rect _bounds;
 	Common::StringArray _nameIndex;
 	Common::String _bubbleTitle;
 	Common::String _bubbleDisplStr;
-
+	Common::String _tempList[60];
+	int _tempListIdx[60];
+	int _btnId1;
+	int _btnX1;
+	int _btnId2;
+	int _btnX2;
+	int _btnId3;
+	int _btnX3;
+	Common::Rect _btnUpPos;
+	Common::Rect _btnDownPos;
 	Common::Array<Common::Rect> _bubbles;
 public:
-	BubbleBox(AccessEngine *vm);
+	BubbleBox(AccessEngine *vm, Access::BoxType type, int x, int y, int w, int h, int val1, int val2, int val3, int val4, Common::String title);
 
 	void load(Common::SeekableReadStream *stream);
 
@@ -78,6 +101,11 @@ public:
 	void drawBubble(int index);
 
 	void doBox(int item, int box);
+
+	int doBox_v1(int item, int box, int &btnSelected);
+	void getList(const char *const data[], int *flags);
+	void setCursorPos(int posX, int posY);
+	void printString(Common::String msg);
 };
 
 } // End of namespace Access
diff --git a/engines/access/char.cpp b/engines/access/char.cpp
index b359bcf13a..aca7262952 100644
--- a/engines/access/char.cpp
+++ b/engines/access/char.cpp
@@ -27,15 +27,25 @@
 
 namespace Access {
 
-CharEntry::CharEntry(const byte *data) {
+CharEntry::CharEntry(const byte *data, AccessEngine *vm) {
 	Common::MemoryReadStream s(data, 999);
 
 	_charFlag = s.readByte();
-	_estabIndex = s.readSint16LE();
-	_screenFile.load(s);
+	if (vm->getGameID() == GType_MartianMemorandum) {
+		_screenFile.load(s);
+		_estabIndex = s.readSint16LE();
+	} else {
+		_estabIndex = s.readSint16LE();
+		_screenFile.load(s);
+	}
+
 	_paletteFile.load(s);
 	_startColor = s.readUint16LE();
-	_numColors = s.readUint16LE();
+	if (vm->getGameID() == GType_MartianMemorandum) {
+		int lastColor = s.readUint16LE();
+		_numColors = lastColor - _startColor;
+	} else 
+		_numColors = s.readUint16LE();
 
 	// Load cells
 	for (byte cell = s.readByte(); cell != 0xff; cell = s.readByte()) {
@@ -73,12 +83,18 @@ CharManager::CharManager(AccessEngine *vm) : Manager(vm) {
 		// Setup character list
 		if (_vm->isDemo()) {
 			for (int i = 0; i < 27; ++i)
-				_charTable.push_back(CharEntry(Amazon::CHARTBL_DEMO[i]));
+				_charTable.push_back(CharEntry(Amazon::CHARTBL_DEMO[i], vm));
 		} else {
 			for (int i = 0; i < 37; ++i)
-				_charTable.push_back(CharEntry(Amazon::CHARTBL[i]));
+				_charTable.push_back(CharEntry(Amazon::CHARTBL[i], vm));
 		}
 		break;
+
+	case GType_MartianMemorandum:
+		for (int i = 0; i < 27; ++i)
+			_charTable.push_back(CharEntry(Martian::CHARTBL_MM[i], vm));
+		break;
+
 	default:
 		error("Unknown game");
 	}
@@ -152,8 +168,14 @@ void CharManager::charMenu() {
 	screen.saveScreen();
 	screen.setDisplayScan();
 
-	screen.plotImage(spr, 17, Common::Point(0, 176));
-	screen.plotImage(spr, 18, Common::Point(155, 176));
+	if (_vm->getGameID() == GType_MartianMemorandum) {
+		screen.plotImage(spr, 17, Common::Point(0, 184));
+		screen.plotImage(spr, 18, Common::Point(193, 184));
+	} else if (_vm->getGameID() == GType_Amazon) {
+		screen.plotImage(spr, 17, Common::Point(0, 176));
+		screen.plotImage(spr, 18, Common::Point(155, 176));
+	} else
+		error("Game not supported");
 
 	screen.restoreScreen();
 	delete spr;
diff --git a/engines/access/char.h b/engines/access/char.h
index 6fb4934978..f2828e9779 100644
--- a/engines/access/char.h
+++ b/engines/access/char.h
@@ -41,7 +41,7 @@ public:
 	FileIdent _scriptFile;
 	Common::Array<ExtraCell> _extraCells;
 public:
-	CharEntry(const byte *data);
+	CharEntry(const byte *data, AccessEngine *vm);
 
 	CharEntry();
 };
diff --git a/engines/access/decompress.cpp b/engines/access/decompress.cpp
index c5656afa51..3de376c193 100644
--- a/engines/access/decompress.cpp
+++ b/engines/access/decompress.cpp
@@ -46,7 +46,7 @@ void LzwDecompressor::decompress(byte *source, byte *dest) {
 	maxCodeValue = 512;
 
 	copyLength = 0;
-	_bitPos = 0;
+	_sourceBitsLeft = 8;
 
 	while (1) {
 
@@ -97,17 +97,39 @@ uint16 LzwDecompressor::getCode() {
 	const byte bitMasks[9] = {
 		0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0x0FF
 	};
-	uint16 bits, loCode, hiCode;
-	loCode = (READ_LE_UINT16(_source) >> _bitPos) & 0xFF;
-	_source++;
-	bits = _codeLength - 8;
-	hiCode = (READ_LE_UINT16(_source) >> _bitPos) & bitMasks[bits];
-	_bitPos += bits;
-	if (_bitPos > 8) {
-		_source++;
-		_bitPos -= 8;
+
+	byte   resultBitsLeft = _codeLength;
+	byte   resultBitsPos = 0;
+	uint16 result = 0;
+	byte   currentByte = *_source;
+	byte   currentBits = 0;
+
+	// Get bits of current byte
+	while (resultBitsLeft) {
+		if (resultBitsLeft < _sourceBitsLeft) {
+			// we need less than we have left
+			currentBits = (currentByte >> (8 - _sourceBitsLeft)) & bitMasks[resultBitsLeft];
+			result |= (currentBits << resultBitsPos);
+			_sourceBitsLeft -= resultBitsLeft;
+			resultBitsLeft = 0;
+
+		} else {
+			// we need as much as we have left or more
+			resultBitsLeft -= _sourceBitsLeft;
+			currentBits = currentByte >> (8 - _sourceBitsLeft);
+			result |= (currentBits << resultBitsPos);
+			resultBitsPos += _sourceBitsLeft;
+
+			// Go to next byte
+			_source++;
+
+			_sourceBitsLeft = 8;
+			if (resultBitsLeft) {
+				currentByte = *_source;
+			}
+		}
 	}
-	return (hiCode << 8) | loCode;
+	return result;
 }
 
 uint32 decompressDBE(byte *source, byte **dest) {
diff --git a/engines/access/decompress.h b/engines/access/decompress.h
index eea450086b..bea9a1d3f8 100644
--- a/engines/access/decompress.h
+++ b/engines/access/decompress.h
@@ -32,7 +32,8 @@ public:
 	void decompress(byte *source, byte *dest);
 private:
 	byte *_source;
-	byte _codeLength, _bitPos;
+	byte _sourceBitsLeft;
+	byte _codeLength;
 	uint16 getCode();
 };
 
diff --git a/engines/access/detection_tables.h b/engines/access/detection_tables.h
index 88a64470c5..124f5fcf0d 100644
--- a/engines/access/detection_tables.h
+++ b/engines/access/detection_tables.h
@@ -75,7 +75,22 @@ static const AccessGameDescription gameDescriptions[] = {
 		{
 			"martian",
 			nullptr,
-			AD_ENTRY1s("r00.ap", "af98db5ee7f9ef86c6b1f43187a3691b", 31),
+			AD_ENTRY1s("r01.ap", "c081daca9b0cfd710157cf946e343df6", 39352),
+			Common::EN_ANY,
+			Common::kPlatformDOS,
+			ADGF_NO_FLAGS,
+			GUIO1(GUIO_NONE)
+		},
+		GType_MartianMemorandum,
+		0
+	},
+
+	{
+		// Martian Memorandum
+		{
+			"martian",
+			"Demo",
+			AD_ENTRY1s("r01.rm", "c2facf9c43047211289044ee39a2322a", 2313),
 			Common::EN_ANY,
 			Common::kPlatformDOS,
 			ADGF_NO_FLAGS,
diff --git a/engines/access/files.cpp b/engines/access/files.cpp
index 42a7914638..4d734a67a9 100644
--- a/engines/access/files.cpp
+++ b/engines/access/files.cpp
@@ -40,6 +40,10 @@ void FileIdent::load(Common::SeekableReadStream &s) {
 
 /*------------------------------------------------------------------------*/
 
+CellIdent::	CellIdent() {
+	_cell = 0;
+}
+
 CellIdent::CellIdent(int cell, int fileNum, int subfile) {
 	_cell = cell;
 	_fileNum = fileNum;
diff --git a/engines/access/files.h b/engines/access/files.h
index 8b1aef0363..714ea44c75 100644
--- a/engines/access/files.h
+++ b/engines/access/files.h
@@ -46,7 +46,7 @@ struct FileIdent {
 struct CellIdent : FileIdent {
 	byte _cell;
 
-	CellIdent() {}
+	CellIdent();
 	CellIdent(int cell, int fileNum, int subfile);
 };
 
diff --git a/engines/access/inventory.cpp b/engines/access/inventory.cpp
index df499ba705..3823b17283 100644
--- a/engines/access/inventory.cpp
+++ b/engines/access/inventory.cpp
@@ -31,10 +31,17 @@ namespace Access {
 void InventoryEntry::load(const Common::String &name, const int *data) {
 	_value = ITEM_NOT_FOUND;
 	_name = name;
-	_otherItem1 = *data++;
-	_newItem1 = *data++;
-	_otherItem2 = *data++;
-	_newItem2 = *data;
+	if (data) {
+		_otherItem1 = *data++;
+		_newItem1 = *data++;
+		_otherItem2 = *data++;
+		_newItem2 = *data;
+	} else {
+		_otherItem1 = -1;
+		_newItem1 = -1;
+		_otherItem2 = -1;
+		_newItem2 = -1;
+	}
 }
 
 int InventoryEntry::checkItem(int itemId) {
@@ -67,20 +74,20 @@ InventoryManager::InventoryManager(AccessEngine *vm) : Manager(vm) {
 		names = Amazon::INVENTORY_NAMES;
 		combineP = &Amazon::COMBO_TABLE[0][0];
 		_inv.resize(85);
+		for (uint i = 0; i < _inv.size(); ++i, combineP += 4)
+			_inv[i].load(names[i], combineP);
 		break;
 	case GType_MartianMemorandum:
 		names = Martian::INVENTORY_NAMES;
-		combineP = &Martian::COMBO_TABLE[0][0];
-		_inv.resize(54);
+		combineP = nullptr;
+		_inv.resize(55);
+		for (uint i = 0; i < _inv.size(); ++i)
+			_inv[i].load(names[i], nullptr);
 		break;
 	default:
 		error("Unknown game");
 	}
 
-	for (uint i = 0; i < _inv.size(); ++i, combineP += 4) {
-		_inv[i].load(names[i], combineP);
-	}
-
 	for (uint i = 0; i < 26; ++i) {
 		const int *r = INVCOORDS[i];
 		_invCoords.push_back(Common::Rect(r[0], r[2], r[1], r[3]));
@@ -209,6 +216,31 @@ int InventoryManager::newDisplayInv() {
 	return result;
 }
 
+int InventoryManager::displayInv() {
+	int *inv = (int *) malloc (Martian::INVENTORY_SIZE * sizeof(int));
+
+	for (int i = 0; i < Martian::INVENTORY_SIZE; i++)
+		inv[i] = _inv[i]._value;
+	_vm->_events->forceSetCursor(CURSOR_CROSSHAIRS);
+	_vm->_invBox->getList(Martian::INVENTORY_NAMES, inv);
+
+	int btnSelected = 0;
+	int boxX = _vm->_invBox->doBox_v1(_startInvItem, _startInvBox, btnSelected);
+	_startInvItem = _vm->_boxDataStart;
+	_startInvBox = _vm->_boxSelectY;
+
+	if (boxX == -1)
+		btnSelected = 2;
+
+	if (btnSelected != 2)
+		_vm->_useItem = _vm->_invBox->_tempListIdx[boxX];
+	else
+		_vm->_useItem = -1;
+
+	free(inv);
+	return 0;
+}
+
 void InventoryManager::savedFields() {
 	Screen &screen = *_vm->_screen;
 	Room &room = *_vm->_room;
diff --git a/engines/access/inventory.h b/engines/access/inventory.h
index 6a9390eda9..1d88bf4555 100644
--- a/engines/access/inventory.h
+++ b/engines/access/inventory.h
@@ -128,6 +128,7 @@ public:
 	void refreshInventory();
 
 	int newDisplayInv();
+	int displayInv();
 
 	/**
 	* Synchronize savegame data
diff --git a/engines/access/martian/martian_game.cpp b/engines/access/martian/martian_game.cpp
index 4e4a5135a6..3fdba8d260 100644
--- a/engines/access/martian/martian_game.cpp
+++ b/engines/access/martian/martian_game.cpp
@@ -35,108 +35,256 @@ MartianEngine::MartianEngine(OSystem *syst, const AccessGameDescription *gameDes
 }
 
 MartianEngine::~MartianEngine() {
+	_introObjects = _spec7Objects = nullptr;
 }
 
-void MartianEngine::playGame() {
-	// Do introduction
-	doIntroduction();
-	if (shouldQuit())
-		return;
+void MartianEngine::initObjects() {
+	_room = new MartianRoom(this);
+	_scripts = new MartianScripts(this);
+}
 
-	// Setup the game
-	setupGame();
+void MartianEngine::configSelect() {
+	// No implementation required in MM
+}
 
-	_screen->clearScreen();
-	_screen->setPanel(0);
-	_screen->forceFadeOut();
+void MartianEngine::initVariables() {
+	warning("TODO: initVariables");
+
+	// Set player room and position
+	_player->_roomNumber = 7;
+
+	_inventory->_startInvItem = 0;
+	_inventory->_startInvBox = 0;
+	Common::fill(&_objectsTable[0], &_objectsTable[100], (SpriteResource *)nullptr);
+	_player->_playerOff = false;
+
+	// Setup timers
+	const int TIMER_DEFAULTS[] = { 4, 10, 8, 1, 1, 1, 1, 2 };
+	for (int i = 0; i < 32; ++i) {
+		TimerEntry te;
+		te._initTm = te._timer = (i < 8) ? TIMER_DEFAULTS[i] : 1;
+		te._flag = 1;
+
+		_timers.push_back(te);
+	}
+
+	_player->_playerX = _player->_rawPlayer.x = _travelPos[_player->_roomNumber][0];
+	_player->_playerY = _player->_rawPlayer.y = _travelPos[_player->_roomNumber][1];
+	_room->_selectCommand = -1;
+	_events->setNormalCursor(CURSOR_CROSSHAIRS);
+	_mouseMode = 0;
+	_numAnimTimers = 0;
+
+	for (int i = 0; i < 60; i++)
+		_travel[i] = 0;
+	_travel[7] = 1;
+
+	for (int i = 0; i < 40; i++)
+		_ask[i] = 0;
+	_ask[33] = 1;
+}
+
+void MartianEngine::setNoteParams() {
+	_events->hideCursor();
+
+	_screen->_orgX1 = 58;
+	_screen->_orgY1 = 124;
+	_screen->_orgX2 = 297;
+	_screen->_orgY2 = 199;
+	_screen->_lColor = 51;
+	_screen->drawRect();
 
 	_events->showCursor();
+}
 
-	// Setup and execute the room
-	_room = new MartianRoom(this);
-	_scripts = new MartianScripts(this);
-	_room->doRoom();
+void MartianEngine::displayNote(const Common::String &msg) {
+	_fonts._charSet._lo = 1;
+	_fonts._charSet._hi = 8;
+	_fonts._charFor._lo = 0;
+	_fonts._charFor._hi = 255;
+
+	_screen->_maxChars = 40;
+	_screen->_printOrg = _screen->_printStart = Common::Point(59, 124);
+	
+	setNoteParams();
+
+	Common::String lines = msg;
+	Common::String line;
+	int width = 0;
+	bool lastLine = false;
+	do {
+		lastLine = _fonts._font1.getLine(lines, _screen->_maxChars * 6, line, width);
+		_bubbleBox->printString(line);
+		_screen->_printOrg = Common::Point(_screen->_printStart.x, _screen->_printOrg.y + 6);
+
+		if (_screen->_printOrg.y == 196) {
+			_events->waitKeyMouse();
+			setNoteParams();
+			_screen->_printOrg = _screen->_printStart;
+		}
+	} while (!lastLine);
+	_events->waitKeyMouse();
 }
 
-void MartianEngine::doIntroduction() {
-	_screen->setInitialPalettte();
-	_events->setCursor(CURSOR_ARROW);
+void MartianEngine::doSpecial5(int param1) {
+	warning("TODO: Push midi song");
+	_midi->stopSong();
+	_midi->_byte1F781 = false;
+	_midi->loadMusic(47, 4);
+	_midi->midiPlay();
+	_screen->setDisplayScan();
+	_events->clearEvents();
+	_screen->forceFadeOut();
+	_events->hideCursor();
+	_files->loadScreen("DATA.SC");
 	_events->showCursor();
-	_screen->setPanel(0);
+	_screen->setIconPalette();
+	_screen->forceFadeIn();
+
+	Resource *cellsRes = _files->loadFile("CELLS00.LZ");
+	_objectsTable[0] = new SpriteResource(this, cellsRes);
+	delete cellsRes;
+
+	_timers[20]._timer = _timers[20]._initTm = 30;
+	Resource *notesRes = _files->loadFile("NOTES.DAT");
+	notesRes->_stream->skip(param1 * 2);
+	int pos = notesRes->_stream->readUint16LE();
+	notesRes->_stream->seek(pos);
+	Common::String msg = "";
+	byte c;
+	while ((c = (char)notesRes->_stream->readByte()) != '\0')
+		msg += c;
+
+	displayNote(msg);
+	
+	_midi->stopSong();
+	_midi->freeMusic();
+
+	warning("TODO: Pop Midi");
+	// _midi->_byte1F781 = true;
+}
+
+void MartianEngine::playGame() {
+	// Initialize Martian Memorandum game-specific objects
+	initObjects();
 
-	// TODO: Worry about implementing full intro sequence later
-	return;
+	// Setup the game
+	setupGame();
+	configSelect();
 
-	doTitle();
-	if (shouldQuit())
-		return;
+	if (_loadSaveSlot == -1) {
+		// Do introduction
+		doCredits();
+		if (shouldQuit())
+			return;
 
-	if (!_skipStart) {
-		_screen->setPanel(3);
-		doOpening();
+		// Display Notes screen
+		doSpecial5(4);
 		if (shouldQuit())
 			return;
+		_screen->forceFadeOut();
+	}
 
-		if (!_skipStart) {
-			//doTent();
-			if (shouldQuit())
-				return;
+	do {
+		_restartFl = false;
+		_screen->clearScreen();
+		_screen->setPanel(0);
+		_screen->forceFadeOut();
+		_events->showCursor();
+
+		initVariables();
+
+		// If there's a pending savegame to load, load it
+		if (_loadSaveSlot != -1) {
+			loadGameState(_loadSaveSlot);
+			_loadSaveSlot = -1;
 		}
-	}
 
-	doTitle();
+		// Execute the room
+		_room->doRoom();
+	} while (_restartFl);
 }
 
-void MartianEngine::doTitle() {
-	/*
-	_screen->setDisplayScan();
-	_destIn = &_buffer2;
-
-	_screen->forceFadeOut();
+bool MartianEngine::showCredits() {
 	_events->hideCursor();
+	_screen->clearScreen();
+	_destIn = _screen;
 
-	_sound->queueSound(0, 98, 30);
-
-	_files->_setPaletteFlag = false;
-	_files->loadScreen(0, 3);
-	
-	_buffer2.blitFrom(*_screen);
-	_buffer1.blitFrom(*_screen);
-	_screen->forceFadeIn();
-	_sound->playSound(1);
+	int posX = _creditsStream->readSint16LE();
+	int posY = 0;
 
-	Resource *spriteData = _files->loadFile(0, 2);
-	_objectsTable[0] = new SpriteResource(this, spriteData);
-	delete spriteData;
+	while(posX != -1) {
+		posY = _creditsStream->readSint16LE();
+		int frameNum = _creditsStream->readSint16LE();
+		_screen->plotImage(_introObjects, frameNum, Common::Point(posX, posY));
 
-	_sound->playSound(1);
+		posX = _creditsStream->readSint16LE();
+	}
 
-	_files->_setPaletteFlag = false;
-	_files->loadScreen(0, 4);
-	_sound->playSound(1);
+	posY = _creditsStream->readSint16LE();
+	if (posY == -1) {
+		_events->showCursor();
+		_screen->forceFadeOut();
+		return true;
+	}
 
-	_buffer2.blitFrom(*_screen);
-	_buffer1.blitFrom(*_screen);
-	_sound->playSound(1);
+	_screen->forceFadeIn();
+	_timers[3]._timer = _timers[3]._initTm = posY;
 
-	const int COUNTDOWN[6] = { 2, 0x80, 1, 0x7d, 0, 0x87 };
-	for (_pCount = 0; _pCount < 3; ++_pCount) {
-		_buffer2.blitFrom(_buffer1);
-		int id = READ_LE_UINT16(COUNTDOWN + _pCount * 4);
-		int xp = READ_LE_UINT16(COUNTDOWN + _pCount * 4 + 2);
-		_screen->plotImage(_objectsTable[0], id, Common::Point(xp, 71));
+	while (!shouldQuit() && !_events->isKeyMousePressed() && _timers[3]._timer) {
+		_events->pollEventsAndWait();
 	}
-	// TODO: More to do
 
-	delete _objectsTable[0];
-	*/
+	_events->showCursor();
+	_screen->forceFadeOut();
+
+	if (_events->_rightButton)
+		return true;
+	else
+		return false;
 }
 
-void MartianEngine::doOpening() {
-	warning("TODO doOpening");
+void MartianEngine::doCredits() {
+	_midi->_byte1F781 = false;
+	_midi->loadMusic(47, 3);
+	_midi->midiPlay();
+	_screen->setDisplayScan();
+	_events->hideCursor();
+	_screen->forceFadeOut();
+	Resource *data = _files->loadFile(41, 1);
+	_introObjects = new SpriteResource(this, data);
+	delete data;
+
+	_files->loadScreen(41, 0);
+	_buffer2.copyFrom(*_screen);
+	_buffer1.copyFrom(*_screen);
+	_events->showCursor();
+	_creditsStream = new Common::MemoryReadStream(CREDIT_DATA, 180);
+
+	if (!showCredits()) {
+		_screen->copyFrom(_buffer2);
+		_screen->forceFadeIn();
+
+		_events->_vbCount = 550;
+		while (!shouldQuit() && !_events->isKeyMousePressed() && _events->_vbCount > 0)
+			_events->pollEventsAndWait();
+
+		_screen->forceFadeOut();
+		while (!shouldQuit() && !_events->isKeyMousePressed()&& !showCredits())
+			_events->pollEventsAndWait();
+
+		warning("TODO: Free word_21E2B");
+		_midi->freeMusic();
+	}
 }
 
 void MartianEngine::setupGame() {
+	// Load death list
+	_deaths.resize(20);
+	for (int i = 0; i < 20; ++i) {
+		_deaths[i]._screenId = Martian::DEATH_SCREENS[i];
+		_deaths[i]._msg = Martian::DEATHMESSAGE[i];
+	}
 
 	// Setup timers
 	const int TIMER_DEFAULTS[] = { 4, 10, 8, 1, 1, 1, 1, 2 };
@@ -155,12 +303,60 @@ void MartianEngine::setupGame() {
 
 	// Set player room and position
 	_player->_roomNumber = 7;
-	_player->_playerX = _player->_rawPlayer.x = TRAVEL_POS[_player->_roomNumber][0];
-	_player->_playerY = _player->_rawPlayer.y = TRAVEL_POS[_player->_roomNumber][1];
+	_player->_playerX = _player->_rawPlayer.x = _travelPos[_player->_roomNumber][0];
+	_player->_playerY = _player->_rawPlayer.y = _travelPos[_player->_roomNumber][1];
+}
+
+void MartianEngine::showDeathText(Common::String msg) {
+	Common::String line = "";
+	int width = 0;
+	bool lastLine;
+	do {
+		lastLine = _fonts._font2.getLine(msg, _screen->_maxChars * 6, line, width);
+		// Draw the text
+		_bubbleBox->printString(line);
+
+		_screen->_printOrg.y += 6;
+		_screen->_printOrg.x = _screen->_printStart.x;
+
+		if (_screen->_printOrg.y == 180) {
+			_events->waitKeyMouse();
+			_screen->copyBuffer(&_buffer2);
+			_screen->_printOrg.y = _screen->_printStart.y;
+		}
+	} while (!lastLine);
+	_events->waitKeyMouse();
 }
 
-void MartianEngine::drawHelp() {
-	error("TODO: drawHelp");
+void MartianEngine::dead(int deathId) {
+	// Load and display death screen
+	_events->hideCursor();
+	_screen->forceFadeOut();
+	_files->loadScreen(48, _deaths[deathId]._screenId);
+	_screen->setIconPalette();
+	_buffer2.copyBuffer(_screen);
+	_screen->forceFadeIn();
+	_events->showCursor();
+
+	// Setup fonts
+	_fonts._charSet._hi = 10;
+	_fonts._charSet._lo = 1;
+	_fonts._charFor._lo = 247;
+	_fonts._charFor._hi = 255;
+	_screen->_maxChars = 50;
+	_screen->_printOrg = Common::Point(24, 18);
+	_screen->_printStart = Common::Point(24, 18);
+	
+	// Display death message
+	showDeathText(_deaths[deathId]._msg);
+	
+	_screen->forceFadeOut();
+	_room->clearRoom();
+	freeChar();
+
+	// The original was jumping to the restart label in main
+	_restartFl = true;
+	_events->pollEvents();
 }
 
 } // End of namespace Martian
diff --git a/engines/access/martian/martian_game.h b/engines/access/martian/martian_game.h
index a83b67a288..9ef6c05c29 100644
--- a/engines/access/martian/martian_game.h
+++ b/engines/access/martian/martian_game.h
@@ -32,40 +32,41 @@ namespace Martian {
 class MartianEngine : public AccessEngine {
 private:
 	bool _skipStart;
-
+	SpriteResource *_introObjects;
+	Common::MemoryReadStream *_creditsStream;
 	/**
 	 * Do the game introduction
 	 */
-	void doIntroduction();
+	void doCredits();
 
-	/**
-	 * Do title sequence
-	 */
-	void doTitle();
-
-	/**
-	 * Do opening sequence
-	 */
-	void doOpening();
+	bool showCredits();
 
 	/**
 	 * Setup variables for the game
 	 */
 	void setupGame();
 
+	void initObjects();
+	void configSelect();
+	void initVariables();
 protected:
 	/**
 	 * Play the game
 	 */
 	virtual void playGame();
 
-	virtual void dead(int deathId) {}
+	virtual void dead(int deathId);
+
+	void setNoteParams();
+	void displayNote(const Common::String &msg);
 public:
-	MartianEngine(OSystem *syst, const AccessGameDescription *gameDesc);
+	SpriteResource *_spec7Objects;
 
+	MartianEngine(OSystem *syst, const AccessGameDescription *gameDesc);
 	virtual ~MartianEngine();
 
-	void drawHelp();
+	void doSpecial5(int param1);
+	void showDeathText(Common::String msg);
 	virtual void establish(int esatabIndex, int sub) {};
 };
 
diff --git a/engines/access/martian/martian_player.cpp b/engines/access/martian/martian_player.cpp
new file mode 100644
index 0000000000..598664a600
--- /dev/null
+++ b/engines/access/martian/martian_player.cpp
@@ -0,0 +1,67 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/scummsys.h"
+#include "access/access.h"
+#include "access/room.h"
+#include "access/martian/martian_game.h"
+#include "access/martian/martian_player.h"
+#include "access/martian/martian_resources.h"
+
+namespace Access {
+
+namespace Martian {
+
+MartianPlayer::MartianPlayer(AccessEngine *vm) : Player(vm) {
+	_game = (MartianEngine *)vm;
+}
+
+void MartianPlayer::load() {
+	Player::load();
+
+	// Overwrite game-specific values
+	_playerOffset.x = _vm->_screen->_scaleTable1[20];
+	_playerOffset.y = _vm->_screen->_scaleTable1[52];
+	_leftDelta = -9;
+	_rightDelta = 33;
+	_upDelta = 5;
+	_downDelta = -5;
+	_scrollConst = 5;
+
+	for (int i = 0; i < _vm->_playerDataCount; ++i) {
+		_walkOffRight[i] = SIDEOFFR[i];
+		_walkOffLeft[i] = SIDEOFFL[i];
+		_walkOffUp[i] = SIDEOFFU[i];
+		_walkOffDown[i] = SIDEOFFD[i];
+	}
+
+	_sideWalkMin = 0;
+	_sideWalkMax = 7;
+	_upWalkMin = 8;
+	_upWalkMax = 14;
+	_downWalkMin = 15;
+	_downWalkMax = 23;
+}
+
+} // End of namespace Martian
+
+} // End of namespace Access
diff --git a/engines/access/martian/martian_player.h b/engines/access/martian/martian_player.h
new file mode 100644
index 0000000000..007a32e9b2
--- /dev/null
+++ b/engines/access/martian/martian_player.h
@@ -0,0 +1,47 @@
+/* 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 ACCESS_MARTIAN_PLAYER_H
+#define ACCESS_MARTIAN_PLAYER_H
+
+#include "common/scummsys.h"
+#include "access/player.h"
+
+namespace Access {
+
+namespace Martian {
+
+class MartianEngine;
+
+class MartianPlayer : public Player {
+private:
+	MartianEngine *_game;
+public:
+	MartianPlayer(AccessEngine *vm);
+	virtual void load();
+};
+
+} // End of namespace Martian
+
+} // End of namespace Access
+
+#endif /* ACCESS_MARTIAN_PLAYER_H */
diff --git a/engines/access/martian/martian_resources.cpp b/engines/access/martian/martian_resources.cpp
index d2b5dfd5d0..474ec2f71c 100644
--- a/engines/access/martian/martian_resources.cpp
+++ b/engines/access/martian/martian_resources.cpp
@@ -41,51 +41,100 @@ const char *const FILENAMES[] = {
 };
 
 const byte MOUSE0[] = {
-	0, 0, 0, 0, 0, 2, 0xF7, 5, 0, 3, 0xF7, 0xF7, 5, 0, 3,
-	0xF7, 0xF7, 5, 0, 4, 0xF7, 0xF7, 0xF7, 5, 0, 4, 0xF7,
-	0xF7, 0xF7, 5, 0, 5, 0xF7, 0xF7, 0xF7, 0xF7, 5, 0, 5,
-	0xF7, 0xF7, 0xF7, 0xF7, 5, 0, 6, 0xF7, 0xF7, 0xF7, 0xF7,
-	0xF7, 5, 0, 6, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 5, 0, 7,
-	0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 5, 0, 6, 0xF7, 0xF7,
-	0xF7, 0xF7, 0xF7, 5, 0, 5, 0xF7, 0xF7, 0xF7, 0xF7, 5,
-	2, 3, 0xF7, 0xF7, 5, 3, 3, 0xF7, 0xF7, 5, 3, 3, 0xF7,
-	0xF7, 5, 4, 2, 0xF7, 5
+	// hotspot x and y, uint16 LE
+	0, 0, 0, 0,
+	// byte 1: number of skipped pixels
+	// byte 2: number of plotted pixels
+	// then, pixels
+	0, 2, 0xF7, 5,
+	0, 3, 0xF7, 0xF7, 5,
+	0, 3, 0xF7, 0xF7, 5,
+	0, 4, 0xF7, 0xF7, 0xF7, 5,
+	0, 4, 0xF7, 0xF7, 0xF7, 5,
+	0, 5, 0xF7, 0xF7, 0xF7, 0xF7, 5,
+	0, 5, 0xF7, 0xF7, 0xF7, 0xF7, 5,
+	0, 6, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 5,
+	0, 6, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 5,
+	0, 7, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 5,
+	0, 6, 0xF7, 0xF7, 0xF7, 0xF7, 0xF7, 5,
+	0, 5, 0xF7, 0xF7, 0xF7, 0xF7, 5,
+	2, 3, 0xF7, 0xF7, 5,
+	3, 3, 0xF7, 0xF7, 5,
+	3, 3, 0xF7, 0xF7, 5,
+	4, 2, 0xF7, 5
 };
 const byte MOUSE1[] = {
-	7, 0, 7, 0, 6, 1, 0xF7, 4, 5, 0xFF, 0xFF, 0, 0xFF, 0xFF,
-	3, 7, 0xFF, 0, 0, 0, 0, 0, 0xFF, 2, 9, 0xFF, 0, 0, 0,
-	0xF7, 0, 0, 0, 0xFF, 1, 11, 0xFF, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0xFF, 1, 11, 0xFF, 0, 0, 0, 0, 0xF7, 0, 0,
-	0, 0, 0xFF, 0, 13, 0xF7, 0, 0, 0xF7, 0, 0xF7, 0, 0xF7,
-	0, 0xF7, 0, 0, 0xF7, 1, 11, 0xFF, 0, 0, 0, 0, 0xF7,
-	0, 0, 0, 0, 0xFF, 1, 11, 0xFF, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0xFF, 2, 9, 0xFF, 0, 0, 0, 0xF7, 0, 0, 0, 0xFF,
-	3, 7, 0xFF, 0, 0, 0, 0, 0, 0xFF, 4, 5, 0xFF, 0xFF, 0,
-	0xFF, 0xFF, 6, 1, 0xF7, 0, 0, 0, 0, 0, 0
+	// hotspot x and y, uint16 LE
+	7, 0, 7, 0,
+	// byte 1: number of skipped pixels
+	// byte 2: number of plotted pixels
+	// then, pixels
+	6, 1, 0xF7,
+	4, 5, 0xFF, 0xFF, 0, 0xFF, 0xFF,
+	3, 7, 0xFF, 0, 0, 0, 0, 0, 0xFF,
+	2, 9, 0xFF, 0, 0, 0, 0xF7, 0, 0, 0, 0xFF,
+	1, 11, 0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF,
+	1, 11, 0xFF, 0, 0, 0, 0, 0xF7, 0, 0, 0, 0, 0xFF,
+	0, 13, 0xF7, 0, 0, 0xF7, 0, 0xF7, 0, 0xF7, 0, 0xF7, 0, 0, 0xF7,
+	1, 11, 0xFF, 0, 0, 0, 0, 0xF7, 0, 0, 0, 0, 0xFF,
+	1, 11, 0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF,
+	2, 9, 0xFF, 0, 0, 0, 0xF7, 0, 0, 0, 0xFF,
+	3, 7, 0xFF, 0, 0, 0, 0, 0, 0xFF,
+	4, 5, 0xFF, 0xFF, 0, 0xFF, 0xFF,
+	6, 1, 0xF7,
+	0, 0,
+	0, 0,
+	0, 0
 };
 const byte MOUSE2[] = {
-	8, 0, 8, 0, 0, 0, 0, 0, 7, 2, 4, 5, 7, 2, 4, 5, 7, 2,
-	4, 5, 7, 2, 4, 5, 7, 2, 4, 5, 2, 12, 4, 4, 4, 4, 4,
-	0, 4, 4, 4, 4, 4, 5, 7, 2, 4, 5, 7, 2, 4, 5, 7, 2, 4,
-	5, 7, 2, 4, 5, 7, 2, 4, 5, 0, 0, 0, 0, 0, 0
+	// hotspot x and y, uint16 LE
+	8, 0, 8, 0,
+	// byte 1: number of skipped pixels
+	// byte 2: number of plotted pixels
+	// then, pixels
+	0, 0,
+	0, 0,
+	7, 2, 4, 5,
+	7, 2, 4, 5,
+	7, 2, 4, 5,
+	7, 2, 4, 5,
+	7, 2, 4, 5,
+	2, 12, 4, 4, 4, 4, 4, 0, 4, 4, 4, 4, 4, 5,
+	7, 2, 4, 5,
+	7, 2, 4, 5,
+	7, 2, 4, 5,
+	7, 2, 4, 5,
+	7, 2, 4, 5,
+	0, 0,
+	0, 0,
+	0, 0
 };
 const byte MOUSE3[] = {
-	0, 0, 0, 0, 0, 11, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-	0, 12, 6, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 5, 0, 12,
-	6, 7, 7, 7, 7, 7, 7, 7, 7, 6, 5, 5, 0, 12, 6, 6, 6,
-	6, 6, 6, 6, 6, 6, 6, 6, 5, 0, 12, 6, 6, 6, 6, 6, 5,
-	6, 6, 6, 6, 6, 5, 0, 12, 6, 6, 6, 6, 5, 0, 0, 6, 6,
-	6, 6, 5, 0, 12, 6, 6, 6, 6, 6, 0, 6, 6, 6, 6, 6, 5,
-	0, 12, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 0, 12,
-	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 0, 12, 6, 6, 6,
-	6, 6, 5, 6, 6, 6, 6, 6, 5, 0, 12, 6, 6, 6, 6, 6, 5,
-	6, 6, 6, 6, 6, 5, 0, 12, 6, 6, 6, 6, 6, 6, 6, 6, 6,
-	6, 6, 5, 1, 11, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0,
-	0, 0, 0, 0, 0
+	// hotspot x and y, uint16 LE
+	0, 0, 0, 0,
+	// byte 1: number of skipped pixels
+	// byte 2: number of plotted pixels
+	// then, pixels
+	0, 11, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	0, 12, 6, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 5,
+	0, 12, 6, 7, 7, 7, 7, 7, 7, 7, 7, 6, 5, 5,
+	0, 12, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5,
+	0, 12, 6, 6, 6, 6, 6, 5, 6, 6, 6, 6, 6, 5,
+	0, 12, 6, 6, 6, 6, 5, 0, 0, 6, 6, 6, 6, 5,
+	0, 12, 6, 6, 6, 6, 6, 0, 6, 6, 6, 6, 6, 5,
+	0, 12, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5,
+	0, 12, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5,
+	0, 12, 6, 6, 6, 6, 6, 5, 6, 6, 6, 6, 6, 5,
+	0, 12, 6, 6, 6, 6, 6, 5, 6, 6, 6, 6, 6, 5,
+	0, 12, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5,
+	1, 11, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+	0, 0,
+	0, 0,
+	0, 0
 };
 const byte *const CURSORS[4] = { MOUSE0, MOUSE1, MOUSE2, MOUSE3 };
 
-const int TRAVEL_POS[][2] = {
+const int _travelPos[][2] = {
 	{ -1, 0 },
 	{ 228, 117 },
 	{ 28, 98 },
@@ -139,17 +188,19 @@ const int TRAVEL_POS[][2] = {
 	{ -1, 21 }
 };
 
+const int INVENTORY_SIZE = 55;
 const char *const INVENTORY_NAMES[] = {
-	"CAMERA", "LENS", "PHOTOS", "MAIL", "GUN", "CASH", "COMLINK", "AMMO",
-	"LOCKPICK KIT", "EARRING", "RECIEPTS", "PAPER", "LADDER", "BOOTS",
-	"DOCUMENTS", "KNIFE", "DAGGER", "KEYS", "ROCK", "LOG", "SHOVEL",
-	"STONE", "REMOTE CONTROL", "FOOD AND WATER", "DOOR CARD KEY",
+	"CAMERA", "LENS", "PHOTOS", "MAIL", "GUN",
+	"CASH", "COMLINK", "AMMO", "LOCKPICK KIT", "EARRING",
+	"RECIEPTS", "PAPER", "LADDER", "BOOTS", "DOCUMENTS",
+	"KNIFE", "DAGGER", "KEYS", "ROCK", "LOG",
+	"SHOVEL", "STONE", "REMOTE CONTROL", "FOOD AND WATER", "DOOR CARD KEY",
 	"FLASHLIGHT", "INTERLOCK KEY", "TOOLS", "REBREATHER", "JET PACK",
-	"ROD", "HCL2", "SAFE CARD KEY", "TUNING FORK", "STONE", "ROSE",
-	"KEY", "NOTE", "ALLEN WRENCH", "HOVER BOARD", "BLUE PRINTS",
-	"LETTER", "MEMORANDUM", "MARKERS", "FILM", "ANDRETTI FILM",
-	"GLASSES", "AMULET", "FACIAL KIT", "CAT FOOD", "MONKEY WRENCH",
-	"BIG DICK CARD", "BRA", "BOLT"
+	"ROD", "HCL2", "SAFE CARD KEY", "TUNING FORK", "STONE",
+	"ROSE", "KEY", "NOTE", "ALLEN WRENCH", "HOVER BOARD",
+	"BLUE PRINTS", "LETTER", "MEMORANDUM", "MARKERS", "FILM",
+	"ANDRETTI FILM", "GLASSES", "AMULET", "FACIAL KIT", "CAT FOOD",
+	"MONKEY WRENCH", "BIG DICK CARD", "BRA", "BOLT", nullptr
 };
 
 const byte ROOM_TABLE1[] = {
@@ -436,12 +487,12 @@ const char *const ROOM_DESCR[] = {
 
 const int ROOM_NUMB = 48;
 
-const byte CHAR_TABLE0[] = {
+const byte MMCHAR_0[] = {
 	0x02, 0x31, 0x00, 0x08, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
 	0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
 };
-const byte CHAR_TABLE2[] = {
+const byte MMCHAR_2[] = {
 	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0x32, 0x33, 0x00, 0x01, 0x00,
 	0xff, 0xff, 0xff, 0xff, 0xff, 0x33, 0x00, 0x00, 0x00, 0x33,
@@ -454,13 +505,13 @@ const byte CHAR_TABLE2[] = {
 	0x00, 0x12, 0x00, 0x33, 0x00, 0x0a, 0x00, 0x33, 0x00, 0x13,
 	0x00, 0xff, 0xff,
 };
-const byte CHAR_TABLE3[] = {
+const byte MMCHAR_3[] = {
 	0x02, 0x31, 0x00, 0x03, 0x00, 0x35, 0x00, 0x37, 0x00, 0x02,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x4b, 0x37, 0x00, 0x01, 0x00,
 	0xff, 0x37, 0x00, 0x03, 0x00, 0x37, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE4[] = {
+const byte MMCHAR_4[] = {
 	0x01, 0x31, 0x00, 0x0a, 0x00, 0x36, 0x00, 0x35, 0x00, 0x02,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x49, 0x35, 0x00, 0x01, 0x00,
 	0xff, 0xff, 0xff, 0xff, 0xff, 0x35, 0x00, 0x00, 0x00, 0x35,
@@ -473,7 +524,7 @@ const byte CHAR_TABLE4[] = {
 	0x00, 0x13, 0x00, 0x35, 0x00, 0x0b, 0x00, 0x35, 0x00, 0x14,
 	0x00, 0xff, 0xff,
 };
-const byte CHAR_TABLE5[] = {
+const byte MMCHAR_5[] = {
 	0x01, 0x31, 0x00, 0x08, 0x00, 0x37, 0x00, 0x34, 0x00, 0x02,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x48, 0x34, 0x00, 0x01, 0x00,
 	0xff, 0xff, 0xff, 0xff, 0xff, 0x34, 0x00, 0x00, 0x00, 0x43,
@@ -490,31 +541,31 @@ const byte CHAR_TABLE5[] = {
 	0x00, 0x0f, 0x00, 0x43, 0x00, 0x0d, 0x00, 0x34, 0x00, 0x10,
 	0x00, 0xff, 0xff,
 };
-const byte CHAR_TABLE6[] = {
+const byte MMCHAR_6[] = {
 	0x02, 0x31, 0x00, 0x03, 0x00, 0x38, 0x00, 0x44, 0x00, 0x03,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x4e, 0x44, 0x00, 0x01, 0x00,
 	0xff, 0x44, 0x00, 0x02, 0x00, 0x44, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE7[] = {
+const byte MMCHAR_7[] = {
 	0x02, 0x31, 0x00, 0x01, 0x00, 0x39, 0x00, 0x38, 0x00, 0x02,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x4c, 0x38, 0x00, 0x01, 0x00,
 	0xff, 0x38, 0x00, 0x03, 0x00, 0x38, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE8[] = {
+const byte MMCHAR_8[] = {
 	0x03, 0xff, 0xff, 0xff, 0xff, 0x3a, 0x00, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0x4d, 0x3b, 0x00, 0x01, 0x00,
 	0xff, 0x3b, 0x00, 0x02, 0x00, 0x3b, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE9[] = {
+const byte MMCHAR_9[] = {
 	0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0x59, 0x4a, 0x00, 0x01, 0x00,
 	0xff, 0x4a, 0x00, 0x02, 0x00, 0x4a, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE10[] = {
+const byte MMCHAR_10[] = {
 	0x01, 0x31, 0x00, 0x0a, 0x00, 0x3c, 0x00, 0x36, 0x00, 0x02,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x4a, 0x36, 0x00, 0x01, 0x00,
 	0xff, 0xff, 0xff, 0xff, 0xff, 0x36, 0x00, 0x00, 0x00, 0x36,
@@ -532,19 +583,19 @@ const byte CHAR_TABLE10[] = {
 	0x00, 0x36, 0x00, 0x11, 0x00, 0x36, 0x00, 0x21, 0x00, 0x36,
 	0x00, 0x12, 0x00, 0x36, 0x00, 0x22, 0x00, 0xff, 0xff,
 };
-const byte CHAR_TABLE11[] = {
+const byte MMCHAR_11[] = {
 	0x03, 0xff, 0xff, 0xff, 0xff, 0x3d, 0x00, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0x55, 0x45, 0x00, 0x01, 0x00,
 	0xff, 0x45, 0x00, 0x02, 0x00, 0x45, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE12[] = {
+const byte MMCHAR_12[] = {
 	0x03, 0xff, 0xff, 0xff, 0xff, 0x3e, 0x00, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x40, 0x00, 0x01, 0x00,
 	0xff, 0x40, 0x00, 0x02, 0x00, 0x40, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE13[] = {
+const byte MMCHAR_13[] = {
 	0x00, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x46, 0x00, 0x02,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x56, 0x46, 0x00, 0x01, 0x00,
 	0xff, 0x46, 0x00, 0x03, 0x00, 0x46, 0x00, 0x00, 0x00, 0x46,
@@ -557,7 +608,7 @@ const byte CHAR_TABLE13[] = {
 	0x00, 0x14, 0x00, 0x46, 0x00, 0x0c, 0x00, 0x46, 0x00, 0x15,
 	0x00, 0xff, 0xff,
 };
-const byte CHAR_TABLE15[] = {
+const byte MMCHAR_15[] = {
 	0x00, 0xff, 0xff, 0xff, 0xff, 0x41, 0x00, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0x57, 0x47, 0x00, 0x01, 0x00,
 	0xff, 0xff, 0xff, 0xff, 0xff, 0x47, 0x00, 0x00, 0x00, 0x47,
@@ -565,43 +616,43 @@ const byte CHAR_TABLE15[] = {
 	0x00, 0x47, 0x00, 0x06, 0x00, 0x47, 0x00, 0x04, 0x00, 0x47,
 	0x00, 0x07, 0x00, 0xff, 0xff,
 };
-const byte CHAR_TABLE16[] = {
+const byte MMCHAR_16[] = {
 	0x03, 0xff, 0xff, 0xff, 0xff, 0x42, 0x00, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0x54, 0x41, 0x00, 0x01, 0x00,
 	0xff, 0x41, 0x00, 0x02, 0x00, 0x41, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE18[] = {
+const byte MMCHAR_18[] = {
 	0x02, 0x31, 0x00, 0x07, 0x00, 0x44, 0x00, 0x3c, 0x00, 0x03,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x50, 0x3c, 0x00, 0x01, 0x00,
 	0xff, 0x3c, 0x00, 0x02, 0x00, 0x3c, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE19[] = {
+const byte MMCHAR_19[] = {
 	0x02, 0x31, 0x00, 0x07, 0x00, 0x45, 0x00, 0x3d, 0x00, 0x03,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x51, 0x3d, 0x00, 0x01, 0x00,
 	0xff, 0x3d, 0x00, 0x02, 0x00, 0x3d, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE20[] = {
+const byte MMCHAR_20[] = {
 	0x02, 0x31, 0x00, 0x02, 0x00, 0x46, 0x00, 0x48, 0x00, 0x02,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x58, 0x48, 0x00, 0x01, 0x00,
 	0xff, 0x48, 0x00, 0x03, 0x00, 0x48, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE21[] = {
+const byte MMCHAR_21[] = {
 	0x02, 0x31, 0x00, 0x07, 0x00, 0x47, 0x00, 0x3e, 0x00, 0x03,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x52, 0x3e, 0x00, 0x01, 0x00,
 	0xff, 0x3e, 0x00, 0x02, 0x00, 0x3e, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE23[] = {
+const byte MMCHAR_23[] = {
 	0x02, 0x31, 0x00, 0x08, 0x00, 0x49, 0x00, 0x3f, 0x00, 0x03,
 	0x00, 0x80, 0x00, 0xf7, 0x00, 0x53, 0x3f, 0x00, 0x01, 0x00,
 	0xff, 0x3f, 0x00, 0x02, 0x00, 0x3f, 0x00, 0x00, 0x00, 0xff,
 	0xff,
 };
-const byte CHAR_TABLE24[] = {
+const byte MMCHAR_24[] = {
 	0x02, 0x32, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0x47, 0x32, 0x00, 0x02, 0x00,
 	0xff, 0xff, 0xff, 0xff, 0xff, 0x32, 0x00, 0x01, 0x00, 0x32,
@@ -612,13 +663,13 @@ const byte CHAR_TABLE24[] = {
 	0x00, 0x08, 0x00, 0x32, 0x00, 0x0f, 0x00, 0x32, 0x00, 0x09,
 	0x00, 0x32, 0x00, 0x10, 0x00, 0xff, 0xff
 };
-const byte CHAR_TABLE25[] = {
+const byte MMCHAR_25[] = {
 	0x02, 0x39, 0x00, 0x01, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 	0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 	0x39, 0x00, 0x00, 0x00, 0x39, 0x00, 0x02, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0xFF, 0xFF
 };
-const byte CHAR_TABLE26[] = {
+const byte MMCHAR_26[] = {
 	0x01, 0x3a, 0x00, 0x01, 0x00, 0x0a, 0x00, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x3a, 0x00, 0x02, 0x00,
 	0xff, 0x3a, 0x00, 0x03, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x42,
@@ -638,7 +689,7 @@ const byte CHAR_TABLE26[] = {
 	0x00, 0x3a, 0x00, 0x14, 0x00, 0x42, 0x00, 0x11, 0x00, 0x3a,
 	0x00, 0x15, 0x00, 0xff, 0xff
 };
-const byte CHAR_TABLE27[] = {
+const byte MMCHAR_27[] = {
 	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 	0xff, 0x00, 0x00, 0x00, 0x00, 0x58, 0x49, 0x00, 0x01, 0x00,
 	0xff, 0xff, 0xff, 0xff, 0xff, 0x49, 0x00, 0x00, 0x00, 0x49,
@@ -650,73 +701,144 @@ const byte CHAR_TABLE27[] = {
 	0x00, 0x49, 0x00, 0x10, 0x00, 0x49, 0x00, 0x09, 0x00, 0x49,
 	0x00, 0x11, 0x00, 0xff, 0xff,
 };
-const byte *const CHAR_TABLE[] = {
-	CHAR_TABLE0, nullptr, CHAR_TABLE2, CHAR_TABLE3, CHAR_TABLE4, CHAR_TABLE5,
-	CHAR_TABLE6, CHAR_TABLE7, CHAR_TABLE8, CHAR_TABLE9, CHAR_TABLE10,
-	CHAR_TABLE11, CHAR_TABLE12, CHAR_TABLE13, nullptr, CHAR_TABLE15,
-	CHAR_TABLE16, nullptr, CHAR_TABLE18, CHAR_TABLE19, CHAR_TABLE20,
-	CHAR_TABLE21, nullptr, CHAR_TABLE23, CHAR_TABLE24, CHAR_TABLE25,
-	CHAR_TABLE26, CHAR_TABLE27
+
+// HACK: MMCHAR_0 has been used to replace the missing CHAR: 1, 14, 17 and 22
+const byte *const CHARTBL_MM[] = {
+	MMCHAR_0,  MMCHAR_0,  MMCHAR_2,  MMCHAR_3,  MMCHAR_4,
+	MMCHAR_5,  MMCHAR_6,  MMCHAR_7,  MMCHAR_8,  MMCHAR_9,
+	MMCHAR_10, MMCHAR_11, MMCHAR_12, MMCHAR_13, MMCHAR_0,
+	MMCHAR_15, MMCHAR_16, MMCHAR_0,  MMCHAR_18, MMCHAR_19,
+	MMCHAR_20, MMCHAR_21, MMCHAR_0,  MMCHAR_23, MMCHAR_24,
+	MMCHAR_25, MMCHAR_26, MMCHAR_27
 };
 
-// TODO: Fix that array
-const int COMBO_TABLE[54][4] = {
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 },
-	{ -1, -1, -1, -1 }
+const int SIDEOFFR[] = {  4, 0, 7, 10,  3, 1, 2, 13, 0, 0, 0, 0 };
+const int SIDEOFFL[] = { 11, 6, 1,  4, 10, 6, 1,  4, 0, 0, 0, 0 };
+const int SIDEOFFU[] = {  1, 2, 0,  2,  2, 1, 1,  0, 0, 0, 0, 0 };
+const int SIDEOFFD[] = {  2, 0, 1,  1,  0, 1, 1,  1, 2, 0, 0, 0 };
+
+const byte CREDIT_DATA[] = {
+	0x1F, 0x00, 0x49, 0x00, 0x00, 0x00, 0xB7, 0x00, 0x49, 0x00,
+	0x01, 0x00, 0x79, 0x00, 0x6F, 0x00, 0x02, 0x00, 0xFF, 0xFF,
+	0xEA, 0x01, 0x75, 0x00, 0x46, 0x00, 0x03, 0x00, 0x46, 0x00,
+	0x5E, 0x00, 0x04, 0x00, 0xFF, 0xFF, 0xEA, 0x01, 0x72, 0x00,
+	0x3E, 0x00, 0x05, 0x00, 0x46, 0x00, 0x57, 0x00, 0x04, 0x00,
+	0x5C, 0x00, 0x6E, 0x00, 0x06, 0x00, 0xFF, 0xFF, 0xEA, 0x01,
+	0x63, 0x00, 0x48, 0x00, 0x07, 0x00, 0x2A, 0x00, 0x65, 0x00,
+	0x08, 0x00, 0xFF, 0xFF, 0xEA, 0x01, 0x7E, 0x00, 0x39, 0x00,
+	0x09, 0x00, 0x5C, 0x00, 0x57, 0x00, 0x06, 0x00, 0x45, 0x00,
+	0x6B, 0x00, 0x04, 0x00, 0xFF, 0xFF, 0xEA, 0x01, 0x5F, 0x00,
+	0x46, 0x00, 0x0A, 0x00, 0x67, 0x00, 0x62, 0x00, 0x0B, 0x00,
+	0x47, 0x00, 0x76, 0x00, 0x0C, 0x00, 0xFF, 0xFF, 0xEA, 0x01,
+	0x62, 0x00, 0x38, 0x00, 0x0D, 0x00, 0x47, 0x00, 0x55, 0x00,
+	0x0E, 0x00, 0x49, 0x00, 0x6A, 0x00, 0x0F, 0x00, 0xFF, 0xFF,
+	0xEA, 0x01, 0x18, 0x00, 0x22, 0x00, 0x10, 0x00, 0x17, 0x00,
+	0x3E, 0x00, 0x11, 0x00, 0x16, 0x00, 0x52, 0x00, 0x12, 0x00,
+	0xEE, 0x00, 0x7B, 0x00, 0x13, 0x00, 0xB5, 0x00, 0x93, 0x00,
+	0x0B, 0x00, 0xFF, 0xFF, 0xF4, 0x01, 0xFF, 0xFF, 0xFF, 0xFF
 };
 
-} // End of namespace Martian
+const byte ICON_PALETTE[] = {
+	0x3F, 0x3F, 0x00, 0x00, 0x07, 0x16,
+	0x00, 0x0A, 0x1A, 0x00, 0x0D, 0x1F,
+	0x00, 0x11, 0x28, 0x00, 0x15, 0x30,
+	0x00, 0x19, 0x39, 0x00, 0x1B, 0x3F,
+	0x00, 0x2D, 0x3A 
+};
+
+const int RMOUSE[10][2] = {
+	{ 7, 36 },    { 38, 68 },   { 70, 99 },   { 102, 125 }, { 128, 152 },
+	{ 155, 185 }, { 188, 216 }, { 219, 260 }, { 263, 293 }, { 295, 314 }
+};
+
+const char *const TRAVDATA[] = {
+	"GALACTIC PICTURES", "TERRAFORM", "WASHROOM", "MR. BIG", "ALEXIS' HOME",
+	"JOHNNY FEDORA", "JUNKYARD IN", "TEX'S OFFICE", "MURDER SCENE", "PLAZA HOTEL",
+	"RESTAURANT", "GIFT SHOP", "LOVE SCENE", "RICK LOGAN", "HUT",
+	"SMUGGLERS BASE", "PYRAMID", "CASINO", "CAS LOBBY", "BAR",
+	"DUCTWORK", "RESTROOM", "OFFICE", "SAFE", "ALLEY",
+	"POWER PLANT", "PLANT OFFICE", "PLANT ROOM", "TEMPLE", "IN TEMPLE",
+	"JANE MANSFIELD'S HOME", "AEROBICS ACADEMY", "DR. LAWRENCE BARKLEY", "COLONISTS CAMP", "IN SLUM",
+	"REMOTE OUTPOST", "WALK", "CAVE", "PRISON", "ORACLE",
+	"JOCQUES SPARROW", "MAC MALDEN", "CHANTAL VARGAS", "GUY CALLABERO", "ROCKWELL BACHE",
+	"FERRIS COLLETTE", "NORA DESMOND ALEXANDER", "LOWELL PERCIVAL", "MICHELE BLOODWORTH", "BRADLEY ERICSON",
+	"COOPER BRADBURY", nullptr
+};
+
+const char *const _askTBL[] = {
+	"NONE", "MARSHALL ALEXANDER", "TERRAFORM CORP.", "COLLIER STANTON", "ROCKWELL BACHE",
+	"JOCQUES SPARROW", "NORA DESMOND ALEXANDER", "GALACTIC PICTURES", "LAWRENCE BARKLEY", "TMS",
+	"MAC MALDEN", "STANTON EXPEDITION", "LOWELL PERCIVAL", "CHANTAL VARGAS", "RICK LOGAN",
+	"ALEXIS ALEXANDER", "FERRIS COLLETT", "GUY CALLABERO", "ORACLE STONE", "THOMAS DANGERFIELD",
+	"JANE MANSFIELD", "STACY CRAWFORD", "DICK CASTRO", "ROCKY BULLWINKEL", "DEACON HAWKE",
+	"NATHAN BLOODWORTH", "MICHELLE BLOODWORTH", "BRADLEY ERICSON", "COOPER BRADBURY", "MARTIAN MEMORANDUM",
+	"JOHNNY FEDORA", "RHONDA FOXWORTH", "ANGELO ANDRETTI", "TEX MURPHY", "ROBERT BLOODWORTH",
+	"LARRRY HAMMOND", nullptr
+};
+
+byte HELP[] = {
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+};
 
+const byte DEATH_SCREENS[] = {
+	5, 5, 3, 3, 7, 4, 6, 2, 2, 2, 1, 5, 3, 5, 2, 8, 5, 3, 8, 5
+};
+
+const char *const DEATHMESSAGE[] = {
+	"A VICIOUS THUG PULLS OUT HIS GUN AND AIR CONDITIONS YOUR BRAIN.",
+	"BIG DICK COMES BACK AND ANNOUNCES YOUR TIME IS UP. ONE OF HIS BOYS PROCEEDS TO PART YOUR EYEBROWS.",
+	"ALTHOUGH HIS FIRST SHOT MISSED, THE PUNK FINDS YOU AND TURNS YOU INTO A DOUGHNUT.",
+	"THE CREEP SPOTS YOU. HE TURNS AND FIRES HIS WEAPON. IT BURNS A HOLE A BUZZARD CAN FLY THROUGH.",
+	"OBVIOUSLY RICK LOGAN HAS A FEW TRICK UP HIS SLEEVE. A TREMENDOUS WEIGHT HITS YOUR HEAD. YOU MUMBLE; WATCH OUT FOR THAT TREE...",
+	"SLOWLY SINKING IN THE SLIMY OOZE, YOU THINK OF SEVERAL JELLO WRESTLING MATCHES YOU'VE ATTENDED. BUT NO MORE...",
+	"THE PATH SUDDENLY GIVES WAY AND YOU FEEL MANY STAKES TEAR THROUGH YOUR FLESH. HOW DO YOU LIKE YOUR STAKE",
+	"THE SNAKE SINKS ITS FANGS INTO YOU LEG. THE POISON WORKS QUICKLY. THE SNAKE THEN SWALLOWS YOU WHOLE.",
+	"YOU FADE AWAY, GLOWING LIKE A LIGHTBULB.",
+	"YOU TOUCH THE BUBBLING RADIOACTIVE SELTZER. IT IMMEDIATELY CAUSES VITAL ORGANS TO ELONGATE AND EXPLODE. YOU DIE WITH AN ABSURD AND FOOLISH LOOK ON YOUR FACE.",
+	"THE DOGS PRETTY HUNGRY. IT WON'T TAKE HIM LONG TO FINISH SO SIT BACK AND ENJOY IT.",
+	"ROCKY DOESN'T LIKE BEING FOLLOWED. HE DECIDES TO BEAT YOU. WITHIN AND INCH OF YOUR LIFE. UNFORTUNATELY, HE MISJUDGED THE DISTANCE",
+	"YOU STUMBLE INTO DEADLY LASER FIRE.",
+	"THE OUTPOST AND YOUR BODY PARTS ARE BLOWN TO KINGDOM COME.",
+	"YOU REACH THE TOP, BUT YOUR AIR SOON RUNS OUT LEAVING YOU BREATHLESS.",
+	"YOU DIE IN THE FIERY EXPLOSION.",
+	"YOU FALL HUNDREDS OF FEET TO YOUR DEATH.",
+	"YOU WALK ONTO A PRESSURE SENSITIVE SECURITY PAD. A LASER ZEROS IN AND BLOWS A HOLE THE SIZE OF A SUBARU TIRE THROUGH YOU.",
+	"DANGERFIELD'S EXPERIMENT BACKFIRES. IT RELEASES A DEMON FROM HIS SUBCONSCIOUS WHICH DESTROYS THE ENTIRE PLANET.",
+	"ONCE DANGERFIELD GETS OUT OF HIS CHAMBER, HE PULLS OUT A WEAPON AND LETS YOU HAVE IT."
+};
+
+const char *const SPEC7MESSAGE = {
+	"THOMAS DANGERFIELD'S MAD EXPERIMENT OF ATTEMPTING TO HARNESS THE STONE'S POWER, ENDED HIS LIFE. DANGERFIELD WAS A DECENT HUMAN " \
+	"BEING ONCE, BUT WAS DRIVEN INSANE BY HIS QUEST FOR THE ULTIMATE POWER. ALEXIS AND I DECIDE THAT DEACON HAWKE IS THE ONLY " \
+	"LOGICAL CHOICE FOR THE STONE. WE ARRIVE AT THE TEMPLE WHERE SHE IS WAITING FOR US. SHE TURNS AND WHISPERS; 'YOU HAVE RETURNED " \
+	"THE STONE TO THE MISTRESS OF THE LIGHT. YOU HAVE SURELY SAVED THE WORLD FROM ANNIHILATION BUT YOU MUST CONTINUE TO BE DILIGENT. " \
+	"MANKIND MAY YET PROVE TO BE THE AUTHOR OF HIS OWN DEMISE. REVERENCE LIFE. PROTECT THE LIVING THINGS AND RECYCLE. AND NOW FOR " \
+	"THE SAFETY OF MANKIND, I MUST TAKE THE STONE. PERHAPS SOMEDAY, WHEN THE HUMAN RACE IS READY, IT WILL BE RETURNED. UNTIL THEN "\
+	"FAREWELL...'"
+};
+
+const byte _byte1EEB5[] = {
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	0, 0, 0, 0, 0, 1, 0, 1, 1, 1,
+	1
+};
+
+const int PICTURERANGE[][2] = {
+// { min X, max X}, {min Y, max Y}
+	{ 20, 30 },  { 82, 87 },
+	{ 20, 30 },  { 105, 110 },
+	{ 0, 8 },    { 92, 100 },
+	{ 42, 46 },  { 92, 100 },
+	{ 9, 41 },   { 88, 104 },
+	{ 9, 41 },   { 117, 133 },
+	{ -1, -1 }
+};
+
+} // End of namespace Martian
 } // End of namespace Access
diff --git a/engines/access/martian/martian_resources.h b/engines/access/martian/martian_resources.h
index a52967d42a..2eb810ac80 100644
--- a/engines/access/martian/martian_resources.h
+++ b/engines/access/martian/martian_resources.h
@@ -31,22 +31,46 @@ namespace Martian {
 
 extern const char *const FILENAMES[];
 
+extern const int SIDEOFFR[];
+extern const int SIDEOFFL[];
+extern const int SIDEOFFU[];
+extern const int SIDEOFFD[];
+
 extern const byte *const CURSORS[4];
 
-extern const int TRAVEL_POS[][2];
+extern const int _travelPos[][2];
 
+extern const int INVENTORY_SIZE;
 extern const char *const INVENTORY_NAMES[];
 
 extern const byte *const ROOM_TABLE[];
 extern const char *const ROOM_DESCR[];
 extern const int ROOM_NUMB;
 
-extern const byte *const CHAR_TABLE[];
+extern const byte *const CHARTBL_MM[];
 
-extern const int COMBO_TABLE[54][4];
+extern const int SIDEOFFR[];
+extern const int SIDEOFFL[];
+extern const int SIDEOFFU[];
+extern const int SIDEOFFD[];
 
-} // End of namespace Martian
+extern const byte CREDIT_DATA[];
+extern const byte ICON_PALETTE[];
+
+extern const int RMOUSE[10][2];
+
+extern byte HELP[];
+extern const char *const _askTBL[];
+extern const char *const TRAVDATA[];
 
+extern const byte DEATH_SCREENS[];
+extern const char *const DEATHMESSAGE[];
+extern const char *const SPEC7MESSAGE;
+
+extern const byte _byte1EEB5[];
+extern const int PICTURERANGE[][2];
+
+} // End of namespace Martian
 } // End of namespace Access
 
 #endif /* ACCESS_MARTIAN_RESOURCES_H */
diff --git a/engines/access/martian/martian_room.cpp b/engines/access/martian/martian_room.cpp
index e9d1b9d8cf..d5b03db246 100644
--- a/engines/access/martian/martian_room.cpp
+++ b/engines/access/martian/martian_room.cpp
@@ -43,72 +43,47 @@ void MartianRoom::loadRoom(int roomNumber) {
 }
 
 void MartianRoom::reloadRoom() {
-	loadRoom(_vm->_player->_roomNumber);
-
-	if (_roomFlag != 1) {
-		_vm->_currentMan = _roomFlag;
-		_vm->_currentManOld = _roomFlag;
-		_vm->_manScaleOff = 0;
-
-		switch (_vm->_currentMan) {
-		case 0:
-			_vm->_player->loadSprites("MAN.LZ");
-			break;
-
-		case 2:
-			_vm->_player->loadSprites("JMAN.LZ");
-			break;
+//	_vm->_currentMan = _roomFlag;
+//	_vm->_currentManOld = _roomFlag;
+//	_vm->_manScaleOff = 0;
 
-		case 3:
-			_vm->_player->loadSprites("OVERHEAD.LZ");
-			_vm->_manScaleOff = 1;
-			break;
+	_vm->_player->loadTexPalette();
+	_vm->_player->loadSprites("TEX.LZ");
 
-		default:
-			break;
-		}
-	}
+	loadRoom(_vm->_player->_roomNumber);
 
 	reloadRoom1();
 }
 
 void MartianRoom::reloadRoom1() {
-	if (_vm->_player->_roomNumber == 29 || _vm->_player->_roomNumber == 31
-			|| _vm->_player->_roomNumber == 42 || _vm->_player->_roomNumber == 44) {
-		//Resource *spriteData = _vm->_files->loadFile("MAYA.LZ");
-		//_vm->_inactive._spritesPtr = new SpriteResource(_vm, spriteData);
-		//delete spriteData;
-		_vm->_currentCharFlag = false;
-	}
-
 	_selectCommand = -1;
-	_vm->_events->setNormalCursor(CURSOR_CROSSHAIRS);
-	_vm->_mouseMode = 0;
-	_vm->_boxSelect = true;
+	_vm->_boxSelect = false; //-1
 	_vm->_player->_playerOff = false;
 
-	_vm->_screen->fadeOut();
+	_vm->_screen->forceFadeOut();
+	_vm->_events->hideCursor();
 	_vm->_screen->clearScreen();
+	_vm->_events->showCursor();
 	roomSet();
+	_vm->_player->load();
 
-	// TODO: Refactor
+	if (_vm->_player->_roomNumber != 47)
+		_vm->_player->calcManScale();
 
+	_vm->_events->hideCursor();
+	roomMenu();
 	_vm->_screen->setBufferScan();
 	setupRoom();
 	setWallCodes();
 	buildScreen();
+	_vm->copyBF2Vid();
 
-	if (!_vm->_screen->_vesaMode) {
-		_vm->copyBF2Vid();
-	} else if (_vm->_player->_roomNumber != 20 && _vm->_player->_roomNumber != 24
-			&& _vm->_player->_roomNumber != 33) {
-		_vm->_screen->setPalette();
-		_vm->copyBF2Vid();
-	}
-
+	_vm->_screen->setManPalette();
+	_vm->_events->showCursor();
 	_vm->_player->_frame = 0;
 	_vm->_oldRects.clear();
 	_vm->_newRects.clear();
+	_vm->_events->clearEvents();
 }
 
 void MartianRoom::roomSet() {
@@ -116,6 +91,12 @@ void MartianRoom::roomSet() {
 	_vm->_scripts->_sequence = 1000;
 	_vm->_scripts->searchForSequence();
 	_vm->_scripts->executeScript();
+
+	for (int i = 0; i < 30; i++)
+		_byte26CD2[i] = 0;
+
+	for (int i = 0; i < 10; i++)
+		_byte26CBC[i] = 0;
 }
 
 void MartianRoom::roomMenu() {
@@ -126,16 +107,31 @@ void MartianRoom::roomMenu() {
 	_vm->_screen->saveScreen();
 	_vm->_screen->setDisplayScan();
 	_vm->_destIn = _vm->_screen;	// TODO: Redundant
-	_vm->_screen->plotImage(spr, 0, Common::Point(0, 177));
-	_vm->_screen->plotImage(spr, 1, Common::Point(143, 177));
+	_vm->_screen->plotImage(spr, 0, Common::Point(5, 184));
+	_vm->_screen->plotImage(spr, 1, Common::Point(155, 184));
 
 	_vm->_screen->restoreScreen();
 	delete spr;
 }
 
 void MartianRoom::mainAreaClick() {
+	Common::Point &mousePos = _vm->_events->_mousePos;
+	Common::Point pt = _vm->_events->calcRawMouse();
+	Screen &screen = *_vm->_screen;
+	Player &player = *_vm->_player;
+
+	if (_selectCommand == -1) {
+		player._moveTo = pt;
+		player._playerMove = true;
+	} else if (mousePos.x >= screen._windowXAdd &&
+		mousePos.x <= (screen._windowXAdd + screen._vWindowBytesWide) &&
+		mousePos.y >= screen._windowYAdd &&
+		mousePos.y <= (screen._windowYAdd + screen._vWindowLinesTall)) {
+			if (checkBoxes1(pt) >= 0) {
+				checkBoxes3();
+			}
+	}
 }
 
 } // End of namespace Martian
-
 } // End of namespace Access
diff --git a/engines/access/martian/martian_room.h b/engines/access/martian/martian_room.h
index 85529ce8f0..11501b6e57 100644
--- a/engines/access/martian/martian_room.h
+++ b/engines/access/martian/martian_room.h
@@ -39,6 +39,9 @@ private:
 	MartianEngine *_game;
 
 	void roomSet();
+
+	int _byte26CD2[30];
+	int _byte26CBC[10];
 protected:
 	virtual void loadRoom(int roomNumber);
 
@@ -52,8 +55,6 @@ public:
 
 	virtual ~MartianRoom();
 
-	virtual void loadRoomData(const byte *roomData) { warning("TODO - loadRoomData"); }
-
 	virtual void init4Quads() { }
 
 	virtual void roomMenu();
diff --git a/engines/access/martian/martian_scripts.cpp b/engines/access/martian/martian_scripts.cpp
index 0578872092..a9b5de5597 100644
--- a/engines/access/martian/martian_scripts.cpp
+++ b/engines/access/martian/martian_scripts.cpp
@@ -34,7 +34,300 @@ MartianScripts::MartianScripts(AccessEngine *vm) : Scripts(vm) {
 	_game = (MartianEngine *)_vm;
 }
 
+void MartianScripts::cmdSpecial0() {
+	_vm->_sound->stopSound();
+	_vm->_midi->stopSong();
+
+	_vm->_midi->loadMusic(47, 1);
+	_vm->_midi->midiPlay();
+	_vm->_midi->setLoop(true);
+
+	_vm->_events->_vbCount = 300;
+	while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0)
+		_vm->_events->pollEventsAndWait();
+
+	_vm->_screen->forceFadeOut();
+	_vm->_files->loadScreen("HOUSE.SC");
+
+	_vm->_video->setVideo(_vm->_screen, Common::Point(46, 30), "HVID.VID", 20);
+	
+	do {
+		_vm->_video->playVideo();
+		if (_vm->_video->_videoFrame == 4) {
+			_vm->_screen->flashPalette(16);
+			_vm->_sound->playSound(4);
+			do {
+				_vm->_events->pollEvents();
+			} while (!_vm->shouldQuit() && _vm->_sound->_playingSound);
+			_vm->_timers[31]._timer = _vm->_timers[31]._initTm = 40;
+		}
+	} while (!_vm->_video->_videoEnd && !_vm->shouldQuit());
+
+	if (_vm->_video->_videoEnd) {
+		_vm->_screen->flashPalette(12);
+		_vm->_sound->playSound(4);
+		do {
+			_vm->_events->pollEvents();
+		} while (!_vm->shouldQuit() && _vm->_sound->_playingSound);
+		_vm->_midi->stopSong();
+		_vm->_midi->freeMusic();
+		warning("TODO: Pop Midi");
+	}
+}
+
+void MartianScripts::cmdSpecial1(int param1) {
+	_vm->_events->hideCursor();
+	
+	if (param1 != -1) {
+		_vm->_files->loadScreen(49, param1);
+		_vm->_buffer2.copyBuffer(_vm->_screen);
+	}
+
+	_vm->_screen->setIconPalette();
+	_vm->_screen->forceFadeIn();
+	_vm->_events->showCursor();
+}
+
+void MartianScripts::cmdSpecial3() {
+	_vm->_screen->forceFadeOut();
+	_vm->_events->hideCursor();
+	_vm->_files->loadScreen(57, 3);
+	_vm->_buffer2.copyFrom(*_vm->_screen);
+
+	_vm->_screen->setIconPalette();
+	_vm->_events->showCursor();
+	_vm->_screen->forceFadeIn();
+}
+
+void MartianScripts::doIntro(int param1) {
+	_game->doSpecial5(param1);
+}
+
+void MartianScripts::cmdSpecial6() {
+	_vm->_midi->stopSong();
+	_vm->_screen->setDisplayScan();
+	_vm->_events->clearEvents();
+	_vm->_screen->forceFadeOut();
+	_vm->_events->hideCursor();
+	_vm->_files->loadScreen(49, 9);
+	_vm->_events->showCursor();
+	_vm->_screen->setIconPalette();
+	_vm->_screen->forceFadeIn();
+
+	Resource *cellsRes = _vm->_files->loadFile("CELLS00.LZ");
+	_vm->_objectsTable[0] = new SpriteResource(_vm, cellsRes);
+	delete cellsRes;
+
+	_vm->_timers[20]._timer = _vm->_timers[20]._initTm = 30;
+	_vm->_fonts._charSet._lo = 1;
+	_vm->_fonts._charSet._hi = 10;
+	_vm->_fonts._charFor._lo = 1;
+	_vm->_fonts._charFor._hi = 255;
+
+	_vm->_screen->_maxChars = 50;
+	_vm->_screen->_printOrg = _vm->_screen->_printStart = Common::Point(24, 18);
+
+	Resource *notesRes = _vm->_files->loadFile("ETEXT.DAT");
+	notesRes->_stream->seek(72);
+
+	// Read the message
+	Common::String msg = "";
+	byte c;
+	while ((c = (char)notesRes->_stream->readByte()) != '\0')
+		msg += c;
+
+	//display the message
+	_game->showDeathText(msg);
+
+	delete notesRes;
+	delete _vm->_objectsTable[0];
+	_vm->_objectsTable[0] = nullptr;
+	_vm->_midi->stopSong();
+}
+
+void MartianScripts::cmdSpecial7() {
+	_vm->_room->clearRoom();
+	_vm->_midi->loadMusic(47, 8);
+
+	_vm->_sound->freeSounds();
+	Resource *sound = _vm->_sound->loadSound(46, 14);
+	_vm->_sound->_soundTable.push_back(SoundEntry(sound, 1));
+
+	_vm->_screen->setDisplayScan();
+	_vm->_screen->forceFadeOut();
+	_vm->_events->hideCursor();
+
+	_vm->_files->loadScreen(40, 3);
+	_vm->_buffer1.copyBuffer(_vm->_screen);
+	_vm->_buffer2.copyBuffer(_vm->_screen);
+
+	_vm->_events->showCursor();
+	_vm->_screen->setIconPalette();
+	_vm->_screen->forceFadeIn();
+
+	// Load objects specific to this special scene
+	Resource *data = _vm->_files->loadFile(40, 2);
+	_game->_spec7Objects = new SpriteResource(_vm, data);
+	delete data;
+
+	// Load animation data
+	_vm->_animation->freeAnimationData();
+	Resource *animResource = _vm->_files->loadFile(40, 1);
+	_vm->_animation->loadAnimations(animResource);
+	delete animResource;
+
+	// Load script
+	Resource *newScript = _vm->_files->loadFile(40, 0);
+	_vm->_scripts->setScript(newScript);
+
+	_vm->_images.clear();
+	_vm->_oldRects.clear();
+	_vm->_scripts->_sequence = 0;
+
+	_vm->_sound->playSound(0);
+	
+	do {
+		charLoop();
+	} while (_vm->_flags[134] != 1);
+
+	do {
+		_vm->_events->pollEvents();
+	} while (!_vm->shouldQuit() && _vm->_sound->_playingSound);
+
+	_game->_numAnimTimers = 0;
+	_vm->_animation->freeAnimationData();
+	_vm->_scripts->freeScriptData();
+	_vm->_sound->freeSounds();
+
+	_vm->_screen->forceFadeOut();
+	_vm->_midi->midiPlay();
+	_vm->_midi->setLoop(true);
+	_vm->_events->hideCursor();
+
+	_vm->_files->loadScreen(40, 4);
+	_vm->_buffer1.copyBuffer(_vm->_screen);
+	_vm->_buffer2.copyBuffer(_vm->_screen);
+
+	_vm->_events->showCursor();
+	_vm->_screen->setIconPalette();
+	_vm->_screen->forceFadeIn();
+
+	// Setup fonts
+	_vm->_fonts._charSet._hi = 10;
+	_vm->_fonts._charSet._lo = 1;
+	_vm->_fonts._charFor._lo = 247;
+	_vm->_fonts._charFor._hi = 255;
+	_vm->_screen->_maxChars = 50;
+	_vm->_screen->_printOrg = Common::Point(24, 18);
+	_vm->_screen->_printStart = Common::Point(24, 18);
+
+	// Display death message
+	_game->showDeathText(Common::String(SPEC7MESSAGE));
+
+	_vm->_events->showCursor();
+	_vm->_screen->copyBuffer(&_vm->_buffer1);
+	_vm->_events->hideCursor();
+
+	_vm->_video->setVideo(_vm->_screen, Common::Point(120, 16), FileIdent(40, 5), 10);
+	
+	while (!_vm->shouldQuit() && !_vm->_video->_videoEnd) {
+		_vm->_video->playVideo();
+		_vm->_events->pollEventsAndWait();
+	}
+
+	_vm->_sound->freeSounds();
+	sound = _vm->_sound->loadSound(40, 8);
+	_vm->_sound->_soundTable.push_back(SoundEntry(sound, 1));
+	sound = _vm->_sound->loadSound(40, 9);
+	_vm->_sound->_soundTable.push_back(SoundEntry(sound, 1));
+	sound = _vm->_sound->loadSound(40, 10);
+	_vm->_sound->_soundTable.push_back(SoundEntry(sound, 1));
+
+	_vm->_screen->forceFadeOut();
+	_vm->_files->loadScreen(40, 7);
+	_vm->_destIn = _vm->_screen;
+	
+	_vm->_screen->plotImage(_game->_spec7Objects, 8, Common::Point(104, 176));
+	_vm->_screen->plotImage(_game->_spec7Objects, 7, Common::Point(102, 160));
+	_vm->_events->showCursor();
+	_vm->_screen->forceFadeIn();
+
+	_vm->_events->_vbCount = 100;
+	while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0)
+		_vm->_events->pollEventsAndWait();
+
+	_vm->_sound->playSound(0);
+	do {
+		_vm->_events->pollEvents();
+	} while (!_vm->shouldQuit() && _vm->_sound->_playingSound);
+
+	_vm->_events->_vbCount = 80;
+	while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0)
+		_vm->_events->pollEventsAndWait();
+
+	_vm->_sound->playSound(1);
+	do {
+		_vm->_events->pollEvents();
+	} while (!_vm->shouldQuit() && _vm->_sound->_playingSound);
+
+	_vm->_events->_vbCount = 80;
+	while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0)
+		_vm->_events->pollEventsAndWait();
+	
+	_vm->_sound->playSound(2);
+	do {
+		_vm->_events->pollEvents();
+	} while (!_vm->shouldQuit() && _vm->_sound->_playingSound);
+
+	_vm->_sound->freeSounds();
+
+	delete _game->_spec7Objects;
+	_game->_spec7Objects = nullptr;
+
+	_vm->_events->hideCursor();
+	_vm->_screen->forceFadeOut();
+	_vm->_files->loadScreen(40, 6);
+	_vm->_events->showCursor();
+	_vm->_screen->forceFadeIn();
+
+	_vm->_events->waitKeyMouse();
+	_vm->_midi->stopSong();
+	_vm->_midi->freeMusic();
+
+	// The original was jumping to the restart label in main
+	_vm->_restartFl = true;
+	_vm->_events->pollEvents();
+}
+
 void MartianScripts::executeSpecial(int commandIndex, int param1, int param2) {
+	switch (commandIndex) {
+	case 0:
+		cmdSpecial0();
+		break;
+	case 1:
+		cmdSpecial1(param1);
+		break;
+	case 2:
+		warning("TODO: cmdSpecial2");
+		break;
+	case 3:
+		cmdSpecial3();
+		break;
+	case 4:
+		warning("TODO: cmdSpecial4");
+		break;
+	case 5:
+		doIntro(param1);
+		break;
+	case 6:
+		cmdSpecial6();
+		break;
+	case 7:
+		cmdSpecial7();
+		break;
+	default:
+		warning("Unexpected Special code %d - Skipped", commandIndex);
+	}
 }
 
 typedef void(MartianScripts::*MartianScriptMethodPtr)();
diff --git a/engines/access/martian/martian_scripts.h b/engines/access/martian/martian_scripts.h
index fc7495fc47..9c2141276e 100644
--- a/engines/access/martian/martian_scripts.h
+++ b/engines/access/martian/martian_scripts.h
@@ -35,9 +35,18 @@ class MartianEngine;
 class MartianScripts : public Scripts {
 private:
 	MartianEngine *_game;
+
+	void cmdSpecial0();
+	void cmdSpecial1(int param1);
+	void cmdSpecial3();
+	void doIntro(int param1);
+	void cmdSpecial6();
+	void cmdSpecial7();
+
 protected:
 	virtual void executeSpecial(int commandIndex, int param1, int param2);
 	virtual void executeCommand(int commandIndex);
+
 public:
 	MartianScripts(AccessEngine *vm);
 };
diff --git a/engines/access/module.mk b/engines/access/module.mk
index b6961aeca9..f7cf7f2261 100644
--- a/engines/access/module.mk
+++ b/engines/access/module.mk
@@ -28,6 +28,7 @@ MODULE_OBJS := \
 	amazon/amazon_room.o \
 	amazon/amazon_scripts.o \
 	martian/martian_game.o \
+	martian/martian_player.o \
 	martian/martian_resources.o \
 	martian/martian_room.o \
 	martian/martian_scripts.o
diff --git a/engines/access/player.cpp b/engines/access/player.cpp
index e47daf532c..0162491aee 100644
--- a/engines/access/player.cpp
+++ b/engines/access/player.cpp
@@ -26,24 +26,25 @@
 #include "access/access.h"
 #include "access/resources.h"
 #include "access/amazon/amazon_player.h"
+#include "access/martian/martian_player.h"
 
 namespace Access {
 
 Player *Player::init(AccessEngine *vm) {
 	switch (vm->getGameID()) {
 	case GType_Amazon:
+		vm->_playerDataCount = 8;
 		return new Amazon::AmazonPlayer(vm);
+	case GType_MartianMemorandum:
+		vm->_playerDataCount = 10;
+		return new Martian::MartianPlayer(vm);
 	default:
+		vm->_playerDataCount = 8;
 		return new Player(vm);
 	}
 }
 
 Player::Player(AccessEngine *vm) : Manager(vm), ImageEntry() {
-	Common::fill(&_walkOffRight[0], &_walkOffRight[PLAYER_DATA_COUNT], 0);
-	Common::fill(&_walkOffLeft[0], &_walkOffLeft[PLAYER_DATA_COUNT], 0);
-	Common::fill(&_walkOffUp[0], &_walkOffUp[PLAYER_DATA_COUNT], 0);
-	Common::fill(&_walkOffDown[0], &_walkOffDown[PLAYER_DATA_COUNT], 0);
-
 	_playerSprites = nullptr;
 	_playerSprites1 = nullptr;
 	_manPal1 = nullptr;
@@ -78,14 +79,36 @@ Player::Player(AccessEngine *vm) : Manager(vm), ImageEntry() {
 	_downWalkMin = _downWalkMax = 0;
 	_diagUpWalkMin = _diagUpWalkMax = 0;
 	_diagDownWalkMin = _diagDownWalkMax = 0;
+	_walkOffRight = _walkOffLeft = nullptr;
+	_walkOffUp = _walkOffDown = nullptr;
+	_walkOffUR = _walkOffDR = nullptr;
+	_walkOffUL = _walkOffDL = nullptr;
 }
 
 Player::~Player() {
 	delete _playerSprites;
 	delete[] _manPal1;
+	delete[] _walkOffRight;
+	delete[] _walkOffLeft;
+	delete[] _walkOffUp;
+	delete[] _walkOffDown;
+	delete[] _walkOffUR;
+	delete[] _walkOffDR;
+	delete[] _walkOffUL;
+	delete[] _walkOffDL;
 }
 
 void Player::load() {
+	int dataCount = _vm->_playerDataCount;
+	_walkOffRight = new int[dataCount];
+	_walkOffLeft = new int[dataCount];
+	_walkOffUp = new int[dataCount];
+	_walkOffDown = new int[dataCount];
+	_walkOffUR = new Common::Point[dataCount];
+	_walkOffDR = new Common::Point[dataCount];
+	_walkOffUL = new Common::Point[dataCount];
+	_walkOffDL = new Common::Point[dataCount];
+
 	_playerOffset.x = _vm->_screen->_scaleTable1[25];
 	_playerOffset.y = _vm->_screen->_scaleTable1[67];
 	_leftDelta = -3;
@@ -94,21 +117,6 @@ void Player::load() {
 	_downDelta = -10;
 	_scrollConst = 5;
 
-	for (int i = 0; i < PLAYER_DATA_COUNT; ++i) {
-		_walkOffRight[i] = SIDEOFFR[i];
-		_walkOffLeft[i] = SIDEOFFL[i];
-		_walkOffUp[i] = SIDEOFFU[i];
-		_walkOffDown[i] = SIDEOFFD[i];
-		_walkOffUR[i].x = DIAGOFFURX[i];
-		_walkOffUR[i].y = DIAGOFFURY[i];
-		_walkOffDR[i].x = DIAGOFFDRX[i];
-		_walkOffDR[i].y = DIAGOFFDRY[i];
-		_walkOffUL[i].x = DIAGOFFULX[i];
-		_walkOffUL[i].y = DIAGOFFULY[i];
-		_walkOffDL[i].x = DIAGOFFDLX[i];
-		_walkOffDL[i].y = DIAGOFFDLY[i];
-	}
-
 	_sideWalkMin = 0;
 	_sideWalkMax = 7;
 	_upWalkMin = 16;
@@ -122,16 +130,35 @@ void Player::load() {
 
 	_playerSprites = _playerSprites1;
 	if (_manPal1) {
-		Common::copy(_manPal1 + 0x270, _manPal1 + 0x270 + 0x60, _vm->_screen->_manPal);
+		// Those values are from MM as Amazon doesn't use it
+		Common::copy(_manPal1 + 0x2A0, _manPal1 + 0x2A0 + 0x42, _vm->_screen->_manPal);
 	} else {
 		Common::fill(_vm->_screen->_manPal, _vm->_screen->_manPal + 0x60, 0);
 	}
 }
 
+void Player::loadTexPalette() {
+	Resource *texPal = _vm->_files->loadFile("TEXPAL.COL");
+	int size = texPal->_size;
+	assert(size == 768);
+	_manPal1 = new byte[size];
+	memcpy(_manPal1, texPal->data(), size);	
+}
+
 void Player::loadSprites(const Common::String &name) {
 	freeSprites();
 
 	Resource *data = _vm->_files->loadFile(name);
+
+#if 0
+	Common::DumpFile *outFile = new Common::DumpFile();
+	Common::String outName = name + ".dump";
+	outFile->open(outName);
+	outFile->write(data->data(), data->_size);
+	outFile->finalize();
+	outFile->close();
+#endif
+
 	_playerSprites1 = new SpriteResource(_vm, data);
 	delete data;
 }
@@ -357,7 +384,7 @@ void Player::walkRight() {
 		if (_frame > _sideWalkMax)
 			_frame = _sideWalkMin;
 
-		plotCom(0);
+		plotCom0();
 	}
 }
 
@@ -388,7 +415,7 @@ void Player::walkUpLeft() {
 	tempL = _rawPlayerLow.y - _vm->_screen->_scaleTable2[walkOffset];
 	_rawYTempL = (byte)tempL;
 	_rawYTemp = _rawPlayer.y - _vm->_screen->_scaleTable1[walkOffset] -
-		(tempL < 0 ? 1 : 0);;
+		(tempL < 0 ? 1 : 0);
 
 	if (_vm->_room->codeWalls()) {
 		plotCom2();
@@ -634,15 +661,19 @@ void Player::checkMove() {
 }
 
 void Player::plotCom(int flags) {
-	_flags &= ~2;
-	_flags &= ~8;
+	_flags &= ~IMGFLAG_BACKWARDS;
+	_flags &= ~IMGFLAG_UNSCALED;
 	_flags |= flags;
 
 	plotCom3();
 }
 
+void Player::plotCom0() {
+	plotCom(_vm->getGameID() == GType_Amazon ? 0 : IMGFLAG_BACKWARDS);
+}
+
 void Player::plotCom1() {
-	plotCom(2);
+	plotCom(_vm->getGameID() == GType_Amazon ? IMGFLAG_BACKWARDS : 0);
 }
 
 void Player::plotCom2() {
@@ -709,8 +740,12 @@ void Player::checkScroll() {
 	}
 }
 
-bool Player::scrollUp() {
-	_scrollAmount = -(_vm->_screen->_clipHeight - _playerY - _scrollThreshold);
+bool Player::scrollUp(int forcedAmount) {
+	if (forcedAmount == -1)
+		_scrollAmount = -(_vm->_screen->_clipHeight - _playerY - _scrollThreshold);
+	else
+		_scrollAmount = forcedAmount;
+
 	if ((_vm->_scrollRow + _vm->_screen->_vWindowHeight) >=
 			_vm->_room->_playFieldHeight)
 		return true;
@@ -737,8 +772,12 @@ bool Player::scrollUp() {
 	return false;
 }
 
-bool Player::scrollDown() {
-	_scrollAmount = -(_playerY - _scrollThreshold);
+bool Player::scrollDown(int forcedAmount) {
+	if (forcedAmount == -1)
+		_scrollAmount = -(_playerY - _scrollThreshold);
+	else
+		_scrollAmount = forcedAmount;
+
 	_scrollFlag = true;
 	_vm->_scrollY -= _scrollAmount;
 	if (_vm->_scrollY >= 0)
@@ -762,9 +801,13 @@ bool Player::scrollDown() {
 	return true;
 }
 
-bool Player::scrollLeft() {
+bool Player::scrollLeft(int forcedAmount) {
 	Screen &screen = *_vm->_screen;
-	_scrollAmount = -(_vm->_screen->_clipWidth - _playerX - _scrollThreshold);
+	if (forcedAmount == -1)
+		_scrollAmount = -(_vm->_screen->_clipWidth - _playerX - _scrollThreshold);
+	else
+		_scrollAmount = forcedAmount;
+
 	if ((_vm->_scrollCol + screen._vWindowWidth) == _vm->_room->_playFieldWidth) {
 		_scrollEnd = 2;
 		_vm->_scrollX = 0;
@@ -789,8 +832,12 @@ bool Player::scrollLeft() {
 	}
 }
 
-bool Player::scrollRight() {
-	_scrollAmount = -(_playerX - _scrollThreshold);
+bool Player::scrollRight(int forcedAmount) {
+	if (forcedAmount == -1)
+		_scrollAmount = -(_playerX - _scrollThreshold);
+	else
+		_scrollAmount = forcedAmount;
+
 	_scrollFlag = true;
 	_vm->_scrollX -= _scrollAmount;
 
diff --git a/engines/access/player.h b/engines/access/player.h
index 329cc15ed2..3c554556dd 100644
--- a/engines/access/player.h
+++ b/engines/access/player.h
@@ -31,8 +31,6 @@
 
 namespace Access {
 
-#define PLAYER_DATA_COUNT 8
-
 enum Direction {
 	NONE = 0,
 	UP = 1,
@@ -58,11 +56,11 @@ protected:
 	int _diagUpWalkMin, _diagUpWalkMax;
 	int _diagDownWalkMin, _diagDownWalkMax;
 	SpriteResource *_playerSprites1;
-	byte *_manPal1;
 	int _scrollEnd;
 	int _inactiveYOff;
 
 	void plotCom(int v1);
+	void plotCom0();
 	void plotCom1();
 	void plotCom2();
 	void plotCom3();
@@ -76,22 +74,19 @@ protected:
 	void walkUpRight();
 	void walkDownRight();
 	void checkScrollUp();
-	bool scrollUp();
-	bool scrollDown();
-	bool scrollLeft();
-	bool scrollRight();
 public:
 	Direction _playerDirection;
 	SpriteResource *_playerSprites;
 	// Fields in original Player structure
-	int _walkOffRight[PLAYER_DATA_COUNT];
-	int _walkOffLeft[PLAYER_DATA_COUNT];
-	int _walkOffUp[PLAYER_DATA_COUNT];
-	int _walkOffDown[PLAYER_DATA_COUNT];
-	Common::Point _walkOffUR[PLAYER_DATA_COUNT];
-	Common::Point _walkOffDR[PLAYER_DATA_COUNT];
-	Common::Point _walkOffUL[PLAYER_DATA_COUNT];
-	Common::Point _walkOffDL[PLAYER_DATA_COUNT];
+	byte *_manPal1;
+	int *_walkOffRight;
+	int *_walkOffLeft;
+	int *_walkOffUp;
+	int *_walkOffDown;
+	Common::Point *_walkOffUR;
+	Common::Point *_walkOffDR;
+	Common::Point *_walkOffUL;
+	Common::Point *_walkOffDL;
 	byte _rawTempL;
 	int _rawXTemp;
 	byte _rawYTempL;
@@ -125,6 +120,8 @@ public:
 
 	virtual void load();
 
+	void loadTexPalette();
+
 	void loadSprites(const Common::String &name);
 
 	void freeSprites();
@@ -137,6 +134,10 @@ public:
 
 	void calcPlayer();
 
+	bool scrollUp(int forcedAmount = -1);
+	bool scrollDown(int forcedAmount = -1);
+	bool scrollLeft(int forcedAmount = -1);
+	bool scrollRight(int forcedAmount = -1);
 	void checkScroll();
 
 	void checkMove();
diff --git a/engines/access/resources.cpp b/engines/access/resources.cpp
index 4157cdfc0d..8699a4a82f 100644
--- a/engines/access/resources.cpp
+++ b/engines/access/resources.cpp
@@ -46,35 +46,17 @@ const byte INITIAL_PALETTE[18 * 3] = {
 	0x00, 0x00, 0x00
 };
 
-const int SIDEOFFR[] = { 5, 5, 5, 5, 5, 5, 5, 5, 0 };
-const int SIDEOFFL[] = { 5, 5, 5, 5, 5, 5, 5, 5, 0 };
-const int SIDEOFFU[] = { 2, 2, 2, 2, 2, 2, 2, 2, 0 };
-const int SIDEOFFD[] = { 2, 2, 2, 2, 2, 2, 2, 2, 0 };
-const int DIAGOFFURX[] = { 4, 5, 2, 2, 3, 4, 2, 2, 0 };
-const int DIAGOFFURY[] = { 2, 3, 2, 2, 2, 3, 1, 1, 0 };
-const int DIAGOFFDRX[] = { 4, 5, 4, 3, 5, 4, 5, 1, 0 };
-const int DIAGOFFDRY[] = { 3, 2, 1, 2, 2, 1, 2, 1, 0 };
-const int DIAGOFFULX[] = { 4, 5, 4, 3, 3, 2, 2, 2, 0 };
-const int DIAGOFFULY[] = { 3, 3, 1, 2, 2, 1, 1, 1, 0 };
-const int DIAGOFFDLX[] = { 4, 5, 3, 3, 5, 4, 6, 1, 0 };
-const int DIAGOFFDLY[] = { 2, 2, 1, 2, 3, 1, 2, 1, 0 };
-
-const int RMOUSE[10][2] = {
-	{ 0, 35 }, { 0, 0 }, { 36, 70 }, { 71, 106 }, { 107, 141 },
-	{ 142, 177 }, { 178, 212 }, { 213, 248 }, { 249, 283 }, { 284, 318 }
-};
-
-const char *const LOOK_MESSAGE = "LOOKING THERE REVEALS NOTHING OF INTEREST.";
-const char *const GET_MESSAGE  = "YOU CAN'T TAKE THAT.";
-const char *const OPEN_MESSAGE = "THAT DOESN'T OPEN.";
-const char *const MOVE_MESSAGE = "THAT WON'T MOVE.";
-const char *const USE_MESSAGE  = "THAT DOESN'T SEEM TO WORK.";
-const char *const GO_MESSAGE   = "YOU CAN'T CLIMB THAT.";
-const char *const HELP_MESSAGE = "THIS OBJECT REQUIRES NO HINTS";
-const char *const TALK_MESSAGE = "THERE SEEMS TO BE NO RESPONSE.";
 const char *const GENERAL_MESSAGES[] = {
-	LOOK_MESSAGE, OPEN_MESSAGE, MOVE_MESSAGE, GET_MESSAGE, USE_MESSAGE,
-	GO_MESSAGE, TALK_MESSAGE, HELP_MESSAGE, HELP_MESSAGE, USE_MESSAGE
+	"LOOKING THERE REVEALS NOTHING OF INTEREST.", // LOOK_MESSAGE
+	"THAT DOESN'T OPEN.",               // OPEN_MESSAGE
+	"THAT WON'T MOVE."                  // MOVE_MESSAGE
+	"YOU CAN'T TAKE THAT.",             // GET_MESSAGE
+	"THAT DOESN'T SEEM TO WORK.",       // USE_MESSAGE
+	"YOU CAN'T CLIMB THAT.",            // GO_MESSAGE
+	"THERE SEEMS TO BE NO RESPONSE.",   // TALK_MESSAGE
+	"THIS OBJECT REQUIRES NO HINTS",    // HELP_MESSAGE
+	"THIS OBJECT REQUIRES NO HINTS",    // HELP_MESSAGE
+	"THAT DOESN'T SEEM TO WORK.",       // USE_MESSAGE
 };
 
 const int INVCOORDS[][4] = {
diff --git a/engines/access/resources.h b/engines/access/resources.h
index 8d59b1b1f1..07b8e5ada9 100644
--- a/engines/access/resources.h
+++ b/engines/access/resources.h
@@ -29,21 +29,6 @@ namespace Access {
 
 extern const byte INITIAL_PALETTE[18 * 3];
 
-extern const int SIDEOFFR[];
-extern const int SIDEOFFL[];
-extern const int SIDEOFFU[];
-extern const int SIDEOFFD[];
-extern const int DIAGOFFURX[];
-extern const int DIAGOFFURY[];
-extern const int DIAGOFFDRX[];
-extern const int DIAGOFFDRY[];
-extern const int DIAGOFFULX[];
-extern const int DIAGOFFULY[];
-extern const int DIAGOFFDLX[];
-extern const int DIAGOFFDLY[];
-
-extern const int RMOUSE[10][2];
-
 extern const char *const GENERAL_MESSAGES[];
 
 extern const int INVCOORDS[][4];
diff --git a/engines/access/room.cpp b/engines/access/room.cpp
index 607259ec6f..c91b37c65d 100644
--- a/engines/access/room.cpp
+++ b/engines/access/room.cpp
@@ -38,6 +38,23 @@ Room::Room(AccessEngine *vm) : Manager(vm) {
 	_selectCommand = 0;
 	_conFlag = false;
 	_selectCommand = -1;
+
+	switch (vm->getGameID()) {
+	case GType_Amazon:
+		for (int i = 0; i < 10; i++) {
+			_rMouse[i][0] = Amazon::RMOUSE[i][0];
+			_rMouse[i][1] = Amazon::RMOUSE[i][1];
+		}
+		break;
+	case GType_MartianMemorandum:
+		for (int i = 0; i < 10; i++) {
+			_rMouse[i][0] = Martian::RMOUSE[i][0];
+			_rMouse[i][1] = Martian::RMOUSE[i][1];
+		}
+		break;
+	default:
+		error("Game not supported");
+	}
 }
 
 Room::~Room() {
@@ -55,6 +72,91 @@ void Room::freeTileData() {
 	_tile = nullptr;
 }
 
+void Room::clearCamera() {
+	_vm->_player->_scrollFlag = true;
+	_vm->_events->hideCursor();
+
+	_vm->_screen->_orgX1 = 48;
+	_vm->_screen->_orgY1 = 24;
+	_vm->_screen->_orgX2 = 274;
+	_vm->_screen->_orgY2 = 152;
+	_vm->_screen->_lColor = 0;
+	_vm->_screen->drawRect();
+
+	_vm->_events->showCursor();
+
+	_vm->_events->_vbCount = 4;
+	while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0)
+		_vm->_events->pollEventsAndWait();
+}
+
+void Room::takePicture() {
+	_vm->_events->pollEvents();
+	if (!_vm->_events->_leftButton)
+		return;
+
+	Common::Array<Common::Rect> pictureCoords;
+	for (int i = 0; Martian::PICTURERANGE[i][0] != -1; i += 2) {
+		pictureCoords.push_back(Common::Rect(Martian::PICTURERANGE[i][0], Martian::PICTURERANGE[i + 1][0],
+			                                 Martian::PICTURERANGE[i][1], Martian::PICTURERANGE[i + 1][1]));
+	}
+
+	int result = _vm->_events->checkMouseBox1(pictureCoords);
+
+	if (result == 4) {
+		_vm->_events->debounceLeft();
+		if (_vm->_inventory->_inv[44]._value != ITEM_IN_INVENTORY) {
+			Common::String msg = "YOU HAVE NO MORE FILM.";
+			_vm->_scripts->doCmdPrint_v1(msg);
+			return;
+		}
+
+		// TODO: simplify the second part of the test when tested
+		if ((_vm->_scrollCol < 35) || ((_vm->_scrollRow >= 10) && (_vm->_scrollRow >= 20))){
+			Common::String msg = "THAT ISN'T INTERESTING ENOUGH TO WASTE FILM ON.";
+			_vm->_scripts->doCmdPrint_v1(msg);
+			return;
+		}
+
+		if (_vm->_inventory->_inv[26]._value != ITEM_USED) {
+			Common::String msg = "ALTHOUGH IT WOULD MAKE A NICE PICTURE, YOU MAY FIND SOMETHING MORE INTERESTING TO USE YOUR FILM ON.";
+			_vm->_scripts->doCmdPrint_v1(msg);
+			return;
+		}
+
+		Common::String msg = "THAT PHOTO MAY COME IN HANDY SOME DAY.";
+		_vm->_scripts->doCmdPrint_v1(msg);
+		_vm->_inventory->_inv[8]._value = ITEM_IN_INVENTORY;
+		_vm->_pictureTaken++;
+		if (_vm->_pictureTaken == 16)
+			_vm->_inventory->_inv[44]._value = ITEM_USED;
+
+		_vm->_events->debounceLeft();
+		_vm->_sound->playSound(0);
+		clearCamera();
+		return;
+	} else if (result == 5) {
+		if (_vm->_flags[26] != 2) {
+			_vm->_video->closeVideo();
+			_vm->_video->_videoEnd = true;
+		}
+		_vm->_player->_roomNumber = 7;
+		_vm->_room->_function = FN_CLEAR1;
+		return;
+	} else if (result >= 0) 
+		_vm->_player->_move = (Direction)(result + 1);
+
+	_vm->_player->_scrollFlag = false;
+	if (_vm->_player->_move == UP)
+		_vm->_player->scrollDown(2);
+	else if (_vm->_player->_move == DOWN)
+		_vm->_player->scrollUp(2);
+	else if (_vm->_player->_move == LEFT)
+		_vm->_player->scrollRight(2);
+	else if (_vm->_player->_move == RIGHT)
+		_vm->_player->scrollLeft(2);
+}
+
 void Room::doRoom() {
 	bool reloadFlag = false;
 
@@ -84,9 +186,13 @@ void Room::doRoom() {
 			_vm->_events->pollEventsAndWait();
 			_vm->_canSaveLoad = false;
 
-			_vm->_player->walk();
-			_vm->_midi->midiRepeat();
-			_vm->_player->checkScroll();
+			if ((_vm->getGameID() == GType_MartianMemorandum) && (_vm->_player->_roomNumber == 47)) {
+				takePicture();
+			} else {
+				_vm->_player->walk();
+				_vm->_midi->midiRepeat();
+				_vm->_player->checkScroll();
+			}
 
 			doCommands();
 			if (_vm->shouldQuitOrRestart())
@@ -136,7 +242,8 @@ void Room::doRoom() {
 				} else {
 					_vm->plotList();
 
-					if (_vm->_events->_mousePos.y < 177)
+					if (((_vm->getGameID() == GType_MartianMemorandum) && (_vm->_events->_mousePos.y < 184)) ||
+						((_vm->getGameID() == GType_Amazon) && (_vm->_events->_mousePos.y < 177)))
 						_vm->_events->setCursor(_vm->_events->_normalMouse);
 					else
 						_vm->_events->setCursor(CURSOR_ARROW);
@@ -173,8 +280,8 @@ void Room::loadRoomData(const byte *roomData) {
 	_vm->_establishFlag = false;
 	if (roomInfo._estIndex != -1) {
 		_vm->_establishFlag = true;
-		if (_vm->_establishTable[roomInfo._estIndex] != 1) {
-			_vm->_establishTable[roomInfo._estIndex] = 1;
+		if (!_vm->_establishTable[roomInfo._estIndex]) {
+			_vm->_establishTable[roomInfo._estIndex] = true;
 			_vm->establish(0, roomInfo._estIndex);
 		}
 	}
@@ -455,8 +562,8 @@ void Room::doCommands() {
 		if (_vm->_events->_mouseRow >= 22) {
 			// Mouse in user interface area
 			for (commandId = 0; commandId < 10; ++commandId) {
-				if (_vm->_events->_mousePos.x >= RMOUSE[commandId][0] &&
-					_vm->_events->_mousePos.x < RMOUSE[commandId][1])
+				if (_vm->_events->_mousePos.x >= _rMouse[commandId][0] &&
+					_vm->_events->_mousePos.x < _rMouse[commandId][1])
 					break;
 			}
 			if (commandId < 10)
@@ -489,9 +596,6 @@ void Room::cycleCommand(int incr) {
 }
 
 void Room::handleCommand(int commandId) {
-	if (commandId == 1)
-		--commandId;
-
 	if (commandId == 9) {
 		_vm->_events->debounceLeft();
 		_vm->_canSaveLoad = true;
@@ -510,41 +614,90 @@ void Room::executeCommand(int commandId) {
 	EventsManager &events = *_vm->_events;
 	_selectCommand = commandId;
 
-	switch (commandId) {
-	case 0:
-		events.forceSetCursor(CURSOR_LOOK);
-		break;
-	case 2:
-		events.forceSetCursor(CURSOR_USE);
-		break;
-	case 3:
-		events.forceSetCursor(CURSOR_TAKE);
-		break;
-	case 4:
-		events.setCursor(CURSOR_ARROW);
-		if (_vm->_inventory->newDisplayInv() == 2) {
-			commandOff();
+	if (_vm->getGameID() == GType_MartianMemorandum) {
+		switch (commandId) {
+		case 4:
+			events.setCursor(CURSOR_ARROW);
+			if (_vm->_inventory->displayInv() == 2) {
+				commandOff();
+				return;
+			}
+			if (_vm->_useItem == 39) {
+				if (_vm->_player->_roomNumber == 23)
+					_vm->_currentMan = 1;
+				commandOff();
+				return;
+			} else if (_vm->_useItem == 6) {
+				_vm->_flags[3] = 2;
+				_vm->_scripts->converse1(24);
+
+				_conFlag = true;
+				while (_conFlag && !_vm->shouldQuitOrRestart()) {
+					_conFlag = false;
+					_vm->_scripts->executeScript();
+				}
+
+				_vm->_boxSelect = true;
+				return;
+			}
+			break;
+		case 7:
+			walkCursor();
 			return;
+		case 8: {
+			events.forceSetCursor(CURSOR_CROSSHAIRS);
+			_vm->_scripts->_sequence = 10000;
+			_vm->_scripts->searchForSequence();
+
+			_conFlag = true;
+			while (_conFlag && !_vm->shouldQuitOrRestart()) {
+				_conFlag = false;
+				_vm->_scripts->executeScript();
+			}
+
+			_vm->_boxSelect = true;
+			return;
+			}
+		default:
+			// No set cursor in MM. Forcing to CROSSHAIRS
+			events.setCursor(CURSOR_CROSSHAIRS);
+			break;
+		}
+	} else {
+		switch (commandId) {
+		case 0:
+		case 1:
+			events.forceSetCursor(CURSOR_LOOK);
+			break;
+		case 2:
+			events.forceSetCursor(CURSOR_USE);
+			break;
+		case 3:
+			events.forceSetCursor(CURSOR_TAKE);
+			break;
+		case 4:
+			events.setCursor(CURSOR_ARROW);
+			if (_vm->_inventory->newDisplayInv() == 2) {
+				commandOff();
+				return;
+			}
+			break;
+		case 5:
+			events.forceSetCursor(CURSOR_CLIMB);
+			break;
+		case 6:
+			events.forceSetCursor(CURSOR_TALK);
+			break;
+		case 7:
+			walkCursor();
+			return;
+		case 8:
+			events.forceSetCursor(CURSOR_HELP);
+			break;
+		default:
+			break;
 		}
-		break;
-	case 5:
-		events.forceSetCursor(CURSOR_CLIMB);
-		break;
-	case 6:
-		events.forceSetCursor(CURSOR_TALK);
-		break;
-	case 7:
-		walkCursor();
-		return;
-	case 8:
-		events.forceSetCursor(CURSOR_HELP);
-		break;
-	default:
-		break;
 	}
-
-	// Draw the default toolbar menu at the bottom of the screen
-	roomMenu();
 	_vm->_screen->saveScreen();
 	_vm->_screen->setDisplayScan();
 
@@ -555,7 +708,7 @@ void Room::executeCommand(int commandId) {
 
 	// Draw the button as selected
 	_vm->_screen->plotImage(spr, _selectCommand + 2,
-		Common::Point(RMOUSE[_selectCommand][0], 176));
+		Common::Point(_rMouse[_selectCommand][0], (_vm->getGameID() == GType_MartianMemorandum) ? 184 : 176));
 
 	_vm->_screen->restoreScreen();
 	_vm->_boxSelect = true;
diff --git a/engines/access/room.h b/engines/access/room.h
index eec273e3f4..12e7375428 100644
--- a/engines/access/room.h
+++ b/engines/access/room.h
@@ -72,6 +72,8 @@ private:
 	int calcLR(int yp);
 	int calcUD(int xp);
 
+	void takePicture();
+
 	/**
 	 * Cycles forwards or backwards through the list of commands
 	 */
@@ -103,6 +105,8 @@ protected:
 	 */
 	void executeCommand(int commandId);
 
+	void clearCamera();
+
 	virtual void reloadRoom() = 0;
 
 	virtual void reloadRoom1() = 0;
@@ -126,6 +130,7 @@ public:
 	byte *_tile;
 	int _selectCommand;
 	bool _conFlag;
+	int _rMouse[10][2];
 public:
 	Room(AccessEngine *vm);
 
diff --git a/engines/access/screen.cpp b/engines/access/screen.cpp
index 970a8f3079..41f6194238 100644
--- a/engines/access/screen.cpp
+++ b/engines/access/screen.cpp
@@ -113,6 +113,20 @@ void Screen::setInitialPalettte() {
 	g_system->getPaletteManager()->setPalette(INITIAL_PALETTE, 0, 18);
 }
 
+void Screen::setManPalette() {
+	for (int i = 0; i < 0x42; i++) {
+		_rawPalette[672 + i] = VGA_COLOR_TRANS(_manPal[i]);
+	}
+}
+
+void Screen::setIconPalette() {
+	if (_vm->getGameID() == GType_MartianMemorandum) {
+		for (int i = 0; i < 0x1B; i++) {
+			_rawPalette[741 + i] = VGA_COLOR_TRANS(Martian::ICON_PALETTE[i]);
+		}
+	}
+}
+
 void Screen::loadPalette(int fileNum, int subfile) {
 	Resource *res = _vm->_files->loadFile(fileNum, subfile);
 	byte *palette = res->data();
@@ -189,7 +203,7 @@ void Screen::forceFadeIn() {
 		for (int idx = 0; idx < PALETTE_SIZE; ++idx, ++srcP, ++destP) {
 			if (*destP != *srcP) {
 				repeatFlag = true;
-				*destP = MAX((int)*destP + FADE_AMOUNT, (int)*srcP);
+				*destP = MIN((int)*destP + FADE_AMOUNT, (int)*srcP);
 			}
 		}
 
@@ -267,6 +281,11 @@ void Screen::drawRect() {
 	ASurface::drawRect();
 }
 
+void Screen::drawBox() {
+	addDirtyRect(Common::Rect(_orgX1, _orgY1, _orgX2, _orgY2));
+	ASurface::drawBox();
+}
+
 void Screen::transBlitFrom(ASurface *src, const Common::Point &destPos) {
 	addDirtyRect(Common::Rect(destPos.x, destPos.y, destPos.x + src->w, destPos.y + src->h));
 	ASurface::transBlitFrom(src, destPos);
@@ -322,6 +341,10 @@ void Screen::cyclePaletteBackwards() {
 	}
 }
 
+void Screen::flashPalette(int count) {
+	warning("TODO: Implement flashPalette");
+}
+
 void Screen::addDirtyRect(const Common::Rect &r) {
 	_dirtyRects.push_back(r);
 	assert(r.isValidRect() && r.width() > 0 && r.height() > 0);
diff --git a/engines/access/screen.h b/engines/access/screen.h
index d45a533f9a..52485e5c7c 100644
--- a/engines/access/screen.h
+++ b/engines/access/screen.h
@@ -92,6 +92,8 @@ public:
 
 	virtual void drawRect();
 
+	virtual void drawBox();
+
 	virtual void transBlitFrom(ASurface *src, const Common::Point &destPos);
 
 	virtual void transBlitFrom(ASurface *src, const Common::Rect &bounds);
@@ -137,7 +139,12 @@ public:
 	/**
 	 * Set icon palette
 	 */
-	void setIconPalette() {}
+	void setIconPalette();
+
+	/**
+	 * Set Tex palette (Martian Memorandum)
+	 */
+	void setManPalette();
 
 	void loadPalette(int fileNum, int subfile);
 
@@ -151,6 +158,8 @@ public:
 
 	void getPalette(byte *pal);
 
+	void flashPalette(int count);
+
 	/**
 	 * Copy a buffer to the screen
 	 */
diff --git a/engines/access/scripts.cpp b/engines/access/scripts.cpp
index 1bd24894d7..41dd5cc0d0 100644
--- a/engines/access/scripts.cpp
+++ b/engines/access/scripts.cpp
@@ -39,12 +39,101 @@ Scripts::Scripts(AccessEngine *vm) : Manager(vm) {
 	_choiceStart = 0;
 	_charsOrg = Common::Point(0, 0);
 	_texsOrg = Common::Point(0, 0);
+	setOpcodes();
 }
 
 Scripts::~Scripts() {
 	freeScriptData();
 }
 
+void Scripts::setOpcodes() {
+	COMMAND_LIST[0] = &Scripts::cmdObject;
+	COMMAND_LIST[1] = &Scripts::cmdEndObject;
+	COMMAND_LIST[2] = &Scripts::cmdJumpLook;
+	COMMAND_LIST[3] = &Scripts::cmdJumpHelp;
+	COMMAND_LIST[4] = &Scripts::cmdJumpGet;
+	COMMAND_LIST[5] = &Scripts::cmdJumpMove;
+	COMMAND_LIST[6] = &Scripts::cmdJumpUse;
+	COMMAND_LIST[7] = &Scripts::cmdJumpTalk;
+	COMMAND_LIST[8] = &Scripts::cmdNull;
+	COMMAND_LIST[9] = &Scripts::cmdPrint_v1;
+	COMMAND_LIST[10] = &Scripts::cmdRetPos;
+	COMMAND_LIST[11] = &Scripts::cmdAnim;
+	COMMAND_LIST[12] = &Scripts::cmdSetFlag;
+	COMMAND_LIST[13] = &Scripts::cmdCheckFlag;
+	COMMAND_LIST[14] = &Scripts::cmdGoto;
+	COMMAND_LIST[15] = &Scripts::cmdAddScore;
+	COMMAND_LIST[16] = &Scripts::cmdSetInventory;
+	COMMAND_LIST[17] = &Scripts::cmdCheckInventory;
+	COMMAND_LIST[18] = &Scripts::cmdSetTex;
+	COMMAND_LIST[19] = &Scripts::cmdNewRoom;
+	COMMAND_LIST[20] = &Scripts::cmdConverse;
+	COMMAND_LIST[21] = &Scripts::cmdCheckFrame;
+	COMMAND_LIST[22] = &Scripts::cmdCheckAnim;
+	COMMAND_LIST[23] = &Scripts::cmdSnd;
+	COMMAND_LIST[24] = &Scripts::cmdRetNeg;
+	COMMAND_LIST[25] = &Scripts::cmdRetPos;
+	COMMAND_LIST[26] = &Scripts::cmdCheckLoc;
+	COMMAND_LIST[27] = &Scripts::cmdSetAnim;
+	COMMAND_LIST[28] = &Scripts::cmdDispInv_v1;
+	COMMAND_LIST[29] = &Scripts::cmdSetAbout;
+	COMMAND_LIST[30] = &Scripts::cmdSetTimer;
+	COMMAND_LIST[31] = &Scripts::cmdCheckTimer;
+	COMMAND_LIST[32] = &Scripts::cmdSetTravel;
+	COMMAND_LIST[33] = &Scripts::cmdJumpGoto;
+	COMMAND_LIST[34] = &Scripts::cmdSetVideo;
+	COMMAND_LIST[35] = &Scripts::cmdPlayVideo;
+	COMMAND_LIST[36] = &Scripts::cmdPlotImage;
+	COMMAND_LIST[37] = &Scripts::cmdSetDisplay;
+	COMMAND_LIST[38] = &Scripts::cmdSetBuffer;
+	COMMAND_LIST[39] = &Scripts::cmdSetScroll;
+	COMMAND_LIST[40] = &Scripts::cmdSaveRect;
+	COMMAND_LIST[41] = &Scripts::cmdVideoEnded;
+	COMMAND_LIST[42] = &Scripts::cmdSetBufVid;
+	COMMAND_LIST[43] = &Scripts::cmdPlayBufVid;
+	COMMAND_LIST[44] = &Scripts::cmdRemoveLast;
+	COMMAND_LIST[45] = &Scripts::cmdDoTravel;
+	COMMAND_LIST[46] = &Scripts::cmdCheckAbout;
+	COMMAND_LIST[47] = &Scripts::cmdSpecial;
+	COMMAND_LIST[48] = &Scripts::cmdSetCycle;
+	COMMAND_LIST[49] = &Scripts::cmdCycle;
+	COMMAND_LIST[50] = &Scripts::cmdCharSpeak;
+	COMMAND_LIST[51] = &Scripts::cmdTexSpeak;
+	COMMAND_LIST[52] = &Scripts::cmdTexChoice;
+	COMMAND_LIST[53] = &Scripts::cmdWait;
+	COMMAND_LIST[54] = &Scripts::cmdSetConPos;
+	COMMAND_LIST[55] = &Scripts::cmdCheckVFrame;
+	COMMAND_LIST[56] = &Scripts::cmdJumpChoice;
+	COMMAND_LIST[57] = &Scripts::cmdReturnChoice;
+	COMMAND_LIST[58] = &Scripts::cmdClearBlock;
+	COMMAND_LIST[59] = &Scripts::cmdLoadSound;
+	COMMAND_LIST[60] = &Scripts::cmdFreeSound;
+	COMMAND_LIST[61] = &Scripts::cmdSetVideoSound;
+	COMMAND_LIST[62] = &Scripts::cmdPlayVideoSound;
+	COMMAND_LIST[63] = &Scripts::cmdPrintWatch;
+	COMMAND_LIST[64] = &Scripts::cmdDispAbout;
+	COMMAND_LIST[65] = &Scripts::cmdPushLocation;
+	COMMAND_LIST[66] = &Scripts::cmdCheckTravel;
+	COMMAND_LIST[67] = &Scripts::cmdBlock;
+	COMMAND_LIST[68] = &Scripts::cmdPlayerOff;
+	COMMAND_LIST[69] = &Scripts::cmdPlayerOn;
+	COMMAND_LIST[70] = &Scripts::cmdDead;
+	COMMAND_LIST[71] = &Scripts::cmdFadeOut;
+	COMMAND_LIST[72] = &Scripts::cmdEndVideo;
+	COMMAND_LIST[73] = &Scripts::cmdHelp_v1;
+}
+
+void Scripts::setOpcodes_v2() {
+	COMMAND_LIST[9] = &Scripts::cmdPrint_v2;
+	COMMAND_LIST[15] = &Scripts::cmdSetInventory;
+	COMMAND_LIST[28] = &Scripts::cmdDispInv_v2;
+	COMMAND_LIST[29] = &Scripts::cmdSetTimer;
+	COMMAND_LIST[32] = &Scripts::cmdJumpGoto;
+	COMMAND_LIST[40] = &Scripts::cmdVideoEnded;
+	COMMAND_LIST[45] = COMMAND_LIST[46] = &Scripts::cmdSpecial;
+	COMMAND_LIST[63] = COMMAND_LIST[64] = COMMAND_LIST[66] = COMMAND_LIST[67] = &Scripts::cmdPushLocation;
+}
+
 void Scripts::setScript(Resource *res, bool restartFlag) {
 	_resource = res;
 	_data = res->_stream;
@@ -86,6 +175,50 @@ void Scripts::charLoop() {
 	_endFlag = endFlag;
 }
 
+void Scripts::clearWatch() {
+	_vm->_events->hideCursor();
+	_vm->_screen->_orgX1 = 128;
+	_vm->_screen->_orgY1 = 57;
+	_vm->_screen->_orgX2 = 228;
+	_vm->_screen->_orgY2 = 106;
+	_vm->_screen->_lColor = 0;
+	_vm->_screen->drawRect();
+
+	_vm->_events->showCursor();
+}
+
+void Scripts::printWatch() {
+	_vm->_fonts._charSet._lo = 8;
+	_vm->_fonts._charSet._hi = 2;
+	_vm->_fonts._charFor._lo = 2;
+	_vm->_fonts._charFor._hi = 255;
+
+	_vm->_screen->_maxChars = 19;
+	_vm->_screen->_printOrg = Common::Point(128, 58);
+	_vm->_screen->_printStart = Common::Point(128, 58);
+	clearWatch();
+
+	Common::String msg = readString();
+	Common::String line = "";
+	int width = 0;
+	bool lastLine;
+	do {
+		lastLine = _vm->_fonts._font2.getLine(msg, _vm->_screen->_maxChars * 6, line, width);
+		// Draw the text
+		_vm->_bubbleBox->printString(line);
+
+		_vm->_screen->_printOrg.y += 6;
+		_vm->_screen->_printOrg.x = _vm->_screen->_printStart.x;
+
+		if (_vm->_screen->_printOrg.y == 106) {
+			_vm->_events->waitKeyMouse();
+			clearWatch();
+			_vm->_screen->_printOrg.y = _vm->_screen->_printStart.y;
+		}
+	} while (!lastLine);
+	_vm->_events->waitKeyMouse();
+}
+
 void Scripts::findNull() {
 	// No implementation required in ScummVM, the strings in the script files are already skipped by the use of readByte()
 }
@@ -109,37 +242,7 @@ int Scripts::executeScript() {
 	return _returnCode;
 }
 
-typedef void(Scripts::*ScriptMethodPtr)();
-
 void Scripts::executeCommand(int commandIndex) {
-	static const ScriptMethodPtr COMMAND_LIST[] = {
-		&Scripts::cmdObject, &Scripts::cmdEndObject, &Scripts::cmdJumpLook,
-		&Scripts::cmdJumpHelp, &Scripts::cmdJumpGet, &Scripts::cmdJumpMove,
-		&Scripts::cmdJumpUse, &Scripts::cmdJumpTalk, &Scripts::cmdNull,
-		&Scripts::cmdPrint, &Scripts::cmdRetPos, &Scripts::cmdAnim,
-		&Scripts::cmdSetFlag, &Scripts::cmdCheckFlag, &Scripts::cmdGoto,
-		&Scripts::cmdAddScore, &Scripts::cmdSetInventory, &Scripts::cmdCheckInventory,
-		&Scripts::cmdSetTex, &Scripts::cmdNewRoom, &Scripts::cmdConverse,
-		&Scripts::cmdCheckFrame, &Scripts::cmdCheckAnim, &Scripts::cmdSnd,
-		&Scripts::cmdRetNeg, &Scripts::cmdRetPos, &Scripts::cmdCheckLoc,
-		&Scripts::cmdSetAnim, &Scripts::cmdDispInv, &Scripts::cmdSetAbout,
-		&Scripts::cmdSetTimer, &Scripts::cmdCheckTimer, &Scripts::cmdSetTravel,
-		&Scripts::cmdJumpGoto, &Scripts::cmdSetVideo, &Scripts::cmdPlayVideo,
-		&Scripts::cmdPlotImage, &Scripts::cmdSetDisplay, &Scripts::cmdSetBuffer,
-		&Scripts::cmdSetScroll, &Scripts::cmdSaveRect, &Scripts::cmdVideoEnded,
-		&Scripts::cmdSetBufVid, &Scripts::cmdPlayBufVid, &Scripts::cmdRemoveLast,
-		&Scripts::cmdDoTravel, &Scripts::cmdCheckAbout, &Scripts::cmdSpecial,
-		&Scripts::cmdSetCycle, &Scripts::cmdCycle, &Scripts::cmdCharSpeak,
-		&Scripts::cmdTexSpeak, &Scripts::cmdTexChoice, &Scripts::cmdWait,
-		&Scripts::cmdSetConPos, &Scripts::cmdCheckVFrame, &Scripts::cmdJumpChoice,
-		&Scripts::cmdReturnChoice, &Scripts::cmdClearBlock, &Scripts::cmdLoadSound,
-		&Scripts::cmdFreeSound, &Scripts::cmdSetVideoSound, &Scripts::cmdPlayVideoSound,
-		&Scripts::cmdPrintWatch, &Scripts::cmdDispAbout, &Scripts::cmdPushLocation,
-		&Scripts::cmdCheckTravel, &Scripts::cmdBlock, &Scripts::cmdPlayerOff,
-		&Scripts::cmdPlayerOn, &Scripts::cmdDead, &Scripts::cmdFadeOut,
-		&Scripts::cmdEndVideo
-	};
-
 	(this->*COMMAND_LIST[commandIndex])();
 }
 
@@ -198,18 +301,36 @@ void Scripts::cmdNull() {
 
 #define PRINT_TIMER 25
 
-void Scripts::cmdPrint() {
+void Scripts::cmdPrint_v2() {
 	// Get a text line for display
 	Common::String msg = readString();
 	printString(msg);
 }
 
-void Scripts::printString(const Common::String &msg) {
+void Scripts::doCmdPrint_v1(Common::String msg) {
 	_vm->_screen->_printOrg = Common::Point(20, 42);
-	_vm->_screen->_printStart = Common::Point(20, 42);
-	_vm->_timers[PRINT_TIMER]._timer = 50;
-	_vm->_timers[PRINT_TIMER]._initTm = 50;
-	++_vm->_timers[PRINT_TIMER]._flag;
+	_vm->_screen->_printStart = Common::Point(20, 32);
+	_vm->_bubbleBox->placeBubble(msg);
+	_vm->_events->waitKeyMouse();
+	_vm->_events->hideCursor();
+	_vm->_screen->restoreBlock();
+	_vm->_events->showCursor();
+	findNull();
+}
+
+void Scripts::cmdPrint_v1() {
+	Common::String msg = readString();
+	doCmdPrint_v1(msg);
+}
+
+void Scripts::printString(const Common::String &msg) {
+	if (_vm->getGameID() != GType_MartianMemorandum) {
+		_vm->_screen->_printOrg = Common::Point(20, 42);
+		_vm->_screen->_printStart = Common::Point(20, 42);
+		_vm->_timers[PRINT_TIMER]._timer = 50;
+		_vm->_timers[PRINT_TIMER]._initTm = 50;
+		++_vm->_timers[PRINT_TIMER]._flag;
+	}
 
 	// Display the text in a bubble, and wait for a keypress or mouse click
 	_vm->_bubbleBox->placeBubble(msg);
@@ -268,11 +389,6 @@ void Scripts::cmdGoto() {
 }
 
 void Scripts::cmdAddScore() {
-	if (!_vm->isDemo()) {
-		cmdSetInventory();
-		return;
-	}
-
 	_data->skip(1);
 }
 
@@ -338,8 +454,8 @@ void Scripts::cmdNewRoom() {
 	cmdRetPos();
 }
 
-void Scripts::cmdConverse() {
-	_vm->_conversation = _data->readUint16LE();
+void Scripts::converse1(int val) {
+	_vm->_conversation = val;
 	_vm->_room->clearRoom();
 	_vm->freeChar();
 	_vm->_char->loadChar(_vm->_conversation);
@@ -355,6 +471,11 @@ void Scripts::cmdConverse() {
 	}
 }
 
+void Scripts::cmdConverse() {
+	int val = _data->readUint16LE();
+	converse1(val);
+}
+
 void Scripts::cmdCheckFrame() {
 	int id = _data->readUint16LE();
 	Animation *anim = _vm->_animation->findAnimation(id);
@@ -409,17 +530,19 @@ void Scripts::cmdSetAnim() {
 		_vm->_animation->setAnimTimer(anim);
 }
 
-void Scripts::cmdDispInv() {
+void Scripts::cmdDispInv_v1() {
+	_vm->_inventory->displayInv();
+}
+
+void Scripts::cmdDispInv_v2() {
 	_vm->_inventory->newDisplayInv();
 }
 
 void Scripts::cmdSetAbout() {
-	if (!_vm->isDemo()) {
-		cmdSetTimer();
-		return;
-	}
-
-	error("TODO: DEMO - cmdSetAbout");
+	int idx = _data->readByte();
+	int val = _data->readByte();
+	_vm->_ask[idx] = val;
+	_vm->_startAboutBox = _vm->_startAboutItem = 0;
 }
 
 void Scripts::cmdSetTimer() {
@@ -461,11 +584,10 @@ void Scripts::cmdCheckTimer() {
 }
 
 void Scripts::cmdSetTravel() {
-	if (!_vm->isDemo()) {
-		cmdJumpGoto();
-		return;
-	}
-	error("TODO: DEMO - cmdSetTravel");
+	int idx = _data->readByte();
+	int dest = _data->readByte();
+	_vm->_travel[idx] = dest;
+	_vm->_startTravelItem = _vm->_startTravelBox = 0;
 }
 
 void Scripts::cmdJumpGoto() {
@@ -517,11 +639,11 @@ void Scripts::cmdSetScroll() {
 }
 
 void Scripts::cmdSaveRect() {
-	if (!_vm->isDemo()) {
-		cmdVideoEnded();
-		return;
-	}
-	error("TODO: DEMO - cmdSaveRect");
+	int x = _vm->_screen->_lastBoundsX;
+	int y = _vm->_screen->_lastBoundsY;
+	int w = _vm->_screen->_lastBoundsW;
+	int h = _vm->_screen->_lastBoundsH;
+	_vm->_newRects.push_back(Common::Rect(x, y, x + w, x + h));
 }
 
 void Scripts::cmdVideoEnded() {
@@ -553,19 +675,81 @@ void Scripts::cmdRemoveLast() {
 }
 
 void Scripts::cmdDoTravel() {
-	if (!_vm->isDemo()) {
-		cmdSpecial();
+	while (true) {
+		_vm->_travelBox->getList(Martian::TRAVDATA, _vm->_travel);
+		int btnSelected = 0;
+		int boxX = _vm->_travelBox->doBox_v1(_vm->_startTravelItem, _vm->_startTravelBox, btnSelected);
+		_vm->_startTravelItem = _vm->_boxDataStart;
+		_vm->_startTravelBox = _vm->_boxSelectY;
+
+		if (boxX == -1)
+			btnSelected = 2;
+
+		if (btnSelected != 2) {
+			int idx = _vm->_travelBox->_tempListIdx[boxX];
+			if (Martian::_byte1EEB5[idx] != _vm->_byte26CB5) {
+				_vm->_bubbleBox->_bubbleTitle = "_travel";
+				_vm->_bubbleBox->printString("YOU CAN'T GET THERE FROM HERE.");
+				continue;
+			}
+			if (_vm->_player->_roomNumber != idx) {
+				_vm->_player->_roomNumber = idx;
+				_vm->_room->_function = FN_CLEAR1;
+				if (Martian::_travelPos[idx][0] == -1) {
+					_vm->_player->_roomNumber = idx;
+					_vm->_room->_conFlag = true;
+					_vm->_scripts->converse1(Martian::_travelPos[idx][1]);
+					return;
+				}
+				_vm->_player->_rawPlayer = Common::Point(Martian::_travelPos[idx][0], Martian::_travelPos[idx][1]);
+				cmdRetPos();
+				return;
+			}
+		}
+
+		if (_vm->_player->_roomNumber == -1)
+			continue;
+
 		return;
 	}
-	error("TODO: DEMO - cmdDoTravel");
 }
 
-void Scripts::cmdCheckAbout() {
-	if (!_vm->isDemo()) {
-		cmdSpecial();
-		return;
+void Scripts::cmdHelp_v1() {
+	int idx = 0;
+	for (int i = 0; i < 40; i++) {
+		byte c = _data->readByte();
+		if (c != 0xFF) {
+			Common::String tmpStr = c + readString();
+			if (Martian::HELP[i]) {
+				_vm->_helpBox->_tempList[idx] = tmpStr;
+				_vm->_helpBox->_tempListIdx[idx] = i;
+				++idx;
+			}
+		} else
+			break;
 	}
-	error("TODO: DEMO - cmdCheckAbout");
+	_vm->_helpBox->_tempList[idx] = "";
+
+	int btnSelected = 0;
+	int boxX = _vm->_helpBox->doBox_v1(0, 0, btnSelected);
+
+	if (boxX == -1)
+		btnSelected = 2;
+
+	if (btnSelected != 2)
+		_vm->_useItem = _vm->_helpBox->_tempListIdx[boxX];
+	else
+		_vm->_useItem = -1;
+}
+
+void Scripts::cmdCheckAbout() {
+	int idx = _data->readSint16LE();
+	int val = _data->readSint16LE();
+
+	if (_vm->_ask[idx] == val)
+		cmdGoto();
+	else
+		_data->skip(2);
 }
 
 void Scripts::cmdSpecial() {
@@ -574,7 +758,7 @@ void Scripts::cmdSpecial() {
 	int p2 = _data->readUint16LE();
 
 	if (_specialFunction == 1) {
-		if (_vm->_establishTable[p2] == 1)
+		if (_vm->_establishTable[p2])
 			return;
 
 		_vm->_screen->savePalette();
@@ -616,33 +800,48 @@ void Scripts::cmdCharSpeak() {
 void Scripts::cmdTexSpeak() {
 	_vm->_screen->_printOrg = _texsOrg;
 	_vm->_screen->_printStart = _texsOrg;
-	_vm->_screen->_maxChars = 20;
+	_vm->_screen->_maxChars = (_vm->getGameID() == GType_MartianMemorandum) ? 23 : 20;
 
 	byte v;
 	Common::String tmpStr = "";
 	while ((v = _data->readByte()) != 0)
 		tmpStr += (char)v;
 
-	_vm->_bubbleBox->_bubbleDisplStr = Common::String("JASON");
+	if (_vm->getGameID() == GType_MartianMemorandum)
+		_vm->_bubbleBox->_bubbleDisplStr = Common::String("TEX");
+	else
+		_vm->_bubbleBox->_bubbleDisplStr = Common::String("JASON");
+
 	_vm->_bubbleBox->placeBubble1(tmpStr);
 	findNull();
 }
 
 #define BTN_COUNT 6
 void Scripts::cmdTexChoice() {
-	static const int BTN_RANGES[BTN_COUNT][2] = {
-		{ 0, 76 }, { 77, 154 }, { 155, 232 }, { 233, 276 }, { 0, 0 },
-		{ 277, 319 }
+	// MM is defining 2 times the last range in the original.
+	static const int BTN_RANGES_v1[BTN_COUNT][2] = {
+		{ 0, 60 }, { 64, 124 }, { 129, 192 }, { 194, 227 }, { 233, 292 }, { 297, 319 }
+	};
+
+	static const int BTN_RANGES_v2[BTN_COUNT][2] = {
+		{ 0, 76 }, { 77, 154 }, { 155, 232 }, { 233, 276 }, { 0, 0 }, { 277, 319 }
 	};
 
+
 	_vm->_oldRects.clear();
 	_choiceStart = _data->pos() - 1;
 	_vm->_fonts._charSet._lo = 1;
 	_vm->_fonts._charSet._hi = 8;
-	_vm->_fonts._charFor._lo = 55;
 	_vm->_fonts._charFor._hi = 255;
+	
+	if (_vm->getGameID() == GType_MartianMemorandum) {
+		_vm->_fonts._charFor._lo = 247;
+		_vm->_screen->_maxChars = 23;
+	} else {
+		_vm->_fonts._charFor._lo = 55;
+		_vm->_screen->_maxChars = 20;
+	}
 
-	_vm->_screen->_maxChars = 20;
 	_vm->_screen->_printOrg = _texsOrg;
 	_vm->_screen->_printStart = _texsOrg;
 
@@ -659,7 +858,7 @@ void Scripts::cmdTexChoice() {
 
 	Common::Array<Common::Rect> responseCoords;
 	responseCoords.push_back(_vm->_bubbleBox->_bounds);
-	_vm->_screen->_printOrg.y = _vm->_bubbleBox->_bounds.bottom + 11;
+	_vm->_screen->_printOrg.y = _vm->_bubbleBox->_bounds.bottom + ((_vm->getGameID() == GType_MartianMemorandum) ? 20 : 11);
 
 	findNull();
 
@@ -672,7 +871,7 @@ void Scripts::cmdTexChoice() {
 		_vm->_bubbleBox->calcBubble(tmpStr);
 		_vm->_bubbleBox->printBubble(tmpStr);
 		responseCoords.push_back(_vm->_bubbleBox->_bounds);
-		_vm->_screen->_printOrg.y = _vm->_bubbleBox->_bounds.bottom + 11;
+		_vm->_screen->_printOrg.y = _vm->_bubbleBox->_bounds.bottom + ((_vm->getGameID() == GType_MartianMemorandum) ? 20 : 11);
 	}
 
 	findNull();
@@ -687,7 +886,7 @@ void Scripts::cmdTexChoice() {
 		_vm->_bubbleBox->calcBubble(tmpStr);
 		_vm->_bubbleBox->printBubble(tmpStr);
 		responseCoords.push_back(_vm->_bubbleBox->_bounds);
-		_vm->_screen->_printOrg.y = _vm->_bubbleBox->_bounds.bottom + 11;
+		_vm->_screen->_printOrg.y = _vm->_bubbleBox->_bounds.bottom + ((_vm->getGameID() == GType_MartianMemorandum) ? 20 : 11);
 	}
 
 	findNull();
@@ -702,11 +901,13 @@ void Scripts::cmdTexChoice() {
 
 		_vm->_bubbleBox->_bubbleDisplStr = _vm->_bubbleBox->_bubbleTitle;
 		if (_vm->_events->_leftButton) {
-			if (_vm->_events->_mouseRow >= 22) {
+			if (_vm->_events->_mouseRow >= ((_vm->getGameID() == GType_MartianMemorandum) ? 23 : 22)) {
 				_vm->_events->debounceLeft();
 				int x = _vm->_events->_mousePos.x;
 				for (int i = 0; i < BTN_COUNT; i++) {
-					if ((x >= BTN_RANGES[i][0]) && (x < BTN_RANGES[i][1])) {
+					if (((_vm->getGameID() == GType_MartianMemorandum) && (x >= BTN_RANGES_v1[i][0]) && (x < BTN_RANGES_v1[i][1])) 
+					||  ((_vm->getGameID() == GType_Amazon) && (x >= BTN_RANGES_v2[i][0]) && (x < BTN_RANGES_v2[i][1]))) {
+
 						choice = i;
 						break;
 					}
@@ -827,39 +1028,46 @@ void Scripts::cmdPlayVideoSound() {
 }
 
 void Scripts::cmdPrintWatch() {
-	if (!_vm->isDemo()) {
-		cmdPushLocation();
-		return;
-	}
-	error("TODO: DEMO - cmdPrintWatch");
+	printWatch();
+	findNull();
 }
 
 void Scripts::cmdDispAbout() {
-	if (!_vm->isDemo()) {
-		cmdPushLocation();
-		return;
-	}
-	error("TODO: DEMO - cmdDispAbout");
+	_vm->_travelBox->getList(Martian::_askTBL, _vm->_ask);
+	int btnSelected = 0;
+	int boxX = _vm->_aboutBox->doBox_v1(_vm->_startAboutItem, _vm->_startAboutBox, btnSelected);
+	_vm->_startAboutItem = _vm->_boxDataStart;
+	_vm->_startAboutBox = _vm->_boxSelectY;
+
+	if (boxX == -1)
+		btnSelected = 2;
+
+	if (btnSelected == 2)
+		_vm->_useItem = -1;
+	else
+		_vm->_useItem = _vm->_travelBox->_tempListIdx[boxX];		
 }
 
 void Scripts::cmdPushLocation() {
-	error("TODO cmdPushLocation");
+	_choiceStart = _data->pos() - 1;
 }
 
 void Scripts::cmdCheckTravel() {
-	if (!_vm->isDemo()) {
-		cmdPushLocation();
-		return;
-	}
-	error("TODO: DEMO - cmdCheckTravel");
+	int idx = _data->readSint16LE();
+	int val = _data->readUint16LE();
+
+	if (_vm->_travel[idx] == val)
+		cmdGoto();
+	else
+		_data->skip(2);
 }
 
 void Scripts::cmdBlock() {
-	if (!_vm->isDemo()) {
-		cmdPushLocation();
-		return;
-	}
-	error("TODO: DEMO - cmdBlock");
+	error("TODO: cmdBlock");
+	/*int val1 = */_data->readSint16LE();
+	/*int val2 = */_data->readUint16LE();
+	/*int val3 = */_data->readSint16LE();
+	/*int val4 = */_data->readUint16LE();
 }
 
 void Scripts::cmdPlayerOff() {
diff --git a/engines/access/scripts.h b/engines/access/scripts.h
index cfadf6d901..07fd6acfb1 100644
--- a/engines/access/scripts.h
+++ b/engines/access/scripts.h
@@ -35,18 +35,25 @@ class Scripts;
 #define SCRIPT_START_BYTE 0xE0
 #define ROOM_SCRIPT 2000
 
+typedef void(Scripts::*ScriptMethodPtr)();
+
 class Scripts : public Manager {
 private:
 	Resource *_resource;
 	int _specialFunction;
 
-	void charLoop();
+	void clearWatch();
+	void printWatch();
+
 protected:
 	Common::SeekableReadStream *_data;
+	ScriptMethodPtr COMMAND_LIST[100];
 
 	virtual void executeSpecial(int commandIndex, int param1, int param2) = 0;
 	virtual void executeCommand(int commandIndex);
 
+	void charLoop();
+
 	/**
 	 * Read a null terminated string from the script
 	 */
@@ -61,7 +68,8 @@ protected:
 	void cmdJumpUse();
 	void cmdJumpTalk();
 	void cmdNull();
-	void cmdPrint();
+	void cmdPrint_v1();
+	void cmdPrint_v2();
 	void cmdAnim();
 	void cmdSetFlag();
 	void cmdCheckFlag();
@@ -83,7 +91,8 @@ protected:
 	void cmdRetNeg();
 	void cmdCheckLoc();
 	void cmdSetAnim();
-	void cmdDispInv();
+	void cmdDispInv_v1();
+	void cmdDispInv_v2();
 	void cmdSetAbout();
 	void cmdSetTimer();
 	void cmdCheckTimer();
@@ -127,7 +136,8 @@ protected:
 	void cmdDead();
 	void cmdFadeOut();
 	void cmdEndVideo();
-	void cmdHelp();
+	void cmdHelp_v1();
+	void cmdHelp_v2();
 	void cmdCycleBack();
 	void cmdSetHelp();
 public:
@@ -138,11 +148,15 @@ public:
 	int _choice;
 	int32 _choiceStart;
 	Common::Point _charsOrg, _texsOrg;
+
 public:
 	Scripts(AccessEngine *vm);
 
 	virtual ~Scripts();
 
+	void setOpcodes();
+	void setOpcodes_v2();
+
 	void setScript(Resource *data, bool restartFlag = false);
 
 	void freeScriptData();
@@ -152,6 +166,7 @@ public:
 	int executeScript();
 
 	void findNull();
+	void doCmdPrint_v1(Common::String msg);
 
 	/**
 	 * Print a given message to the screen in a bubble box
@@ -161,6 +176,7 @@ public:
 	// Script commands that need to be public
 	void cmdFreeSound();
 	void cmdRetPos();
+	void converse1(int val);
 };
 
 } // End of namespace Access
diff --git a/engines/access/sound.cpp b/engines/access/sound.cpp
index da267bdc4c..51ffb88f37 100644
--- a/engines/access/sound.cpp
+++ b/engines/access/sound.cpp
@@ -21,9 +21,12 @@
  */
 
 #include "common/algorithm.h"
+#include "common/config-manager.h"
 #include "audio/mixer.h"
 #include "audio/decoders/raw.h"
 #include "audio/decoders/wave.h"
+// Miles Audio
+#include "audio/miles.h"
 #include "access/access.h"
 #include "access/sound.h"
 
@@ -47,9 +50,6 @@ void SoundManager::clearSounds() {
 	if (_mixer->isSoundHandleActive(_effectsHandle))
 		_mixer->stopHandle(_effectsHandle);
 
-	if (_queue.size())
-		_queue.remove_at(0);
-
 	while (_queue.size()) {
 		delete _queue[0];
 		_queue.remove_at(0);
@@ -75,26 +75,26 @@ Resource *SoundManager::loadSound(int fileNum, int subfile) {
 	return _vm->_files->loadFile(fileNum, subfile);
 }
 
-void SoundManager::playSound(int soundIndex) {
-	debugC(1, kDebugSound, "playSound(%d)", soundIndex);
+void SoundManager::playSound(int soundIndex, bool loop) {
+	debugC(1, kDebugSound, "playSound(%d, %d)", soundIndex, loop);
 
 	int priority = _soundTable[soundIndex]._priority;
-	playSound(_soundTable[soundIndex]._res, priority);
+	playSound(_soundTable[soundIndex]._res, priority, loop);
 }
 
-void SoundManager::playSound(Resource *res, int priority) {
+void SoundManager::playSound(Resource *res, int priority, bool loop) {
 	debugC(1, kDebugSound, "playSound");
 
 	byte *resourceData = res->data();
 
 	assert(res->_size >= 32);
 
+	Audio::RewindableAudioStream *audioStream;
+
 	if (READ_BE_UINT32(resourceData) == MKTAG('R','I','F','F')) {
 		// CD version uses WAVE-files
 		Common::SeekableReadStream *waveStream = new Common::MemoryReadStream(resourceData, res->_size, DisposeAfterUse::NO);
-		Audio::RewindableAudioStream *audioStream = Audio::makeWAVStream(waveStream, DisposeAfterUse::YES);
-		_queue.push_back(audioStream);
-
+		audioStream = Audio::makeWAVStream(waveStream, DisposeAfterUse::YES);
 	} else if (READ_BE_UINT32(resourceData) == MKTAG('S', 'T', 'E', 'V')) {
 		// sound files have a fixed header of 32 bytes in total
 		//  header content:
@@ -134,16 +134,20 @@ void SoundManager::playSound(Resource *res, int priority) {
 			return;
 		}
 
-		Audio::RewindableAudioStream *audioStream = Audio::makeRawStream(resourceData + 32, sampleSize, sampleRate, 0, DisposeAfterUse::NO);
-		_queue.push_back(audioStream);
-
+		audioStream = Audio::makeRawStream(resourceData + 32, sampleSize, sampleRate, 0, DisposeAfterUse::NO);
 	} else
 		error("Unknown format");
 
+	if (loop) {
+		_queue.push_back(new Audio::LoopingAudioStream(audioStream, 0, DisposeAfterUse::NO));
+	} else {
+		_queue.push_back(audioStream);
+	}
+
 	if (!_mixer->isSoundHandleActive(_effectsHandle))
 		_mixer->playStream(Audio::Mixer::kSFXSoundType, &_effectsHandle,
 						_queue[0], -1, _mixer->kMaxChannelVolume, 0,
-						DisposeAfterUse::YES);
+						DisposeAfterUse::NO);
 }
 
 void SoundManager::checkSoundQueue() {
@@ -152,12 +156,13 @@ void SoundManager::checkSoundQueue() {
 	if (_queue.empty() || _mixer->isSoundHandleActive(_effectsHandle))
 		return;
 
+	delete _queue[0];
 	_queue.remove_at(0);
 
-	if (_queue.size())
+	if (_queue.size() && _queue[0])
 		_mixer->playStream(Audio::Mixer::kSFXSoundType, &_effectsHandle,
 		   _queue[0], -1, _mixer->kMaxChannelVolume, 0,
-		   DisposeAfterUse::YES);
+		   DisposeAfterUse::NO);
 }
 
 bool SoundManager::isSFXPlaying() {
@@ -178,7 +183,7 @@ void SoundManager::loadSounds(Common::Array<RoomInfo::SoundIdent> &sounds) {
 void SoundManager::stopSound() {
 	debugC(3, kDebugSound, "stopSound");
 
-	_mixer->stopHandle(Audio::SoundHandle());
+	_mixer->stopHandle(_effectsHandle);
 }
 
 void SoundManager::freeSounds() {
@@ -194,18 +199,63 @@ MusicManager::MusicManager(AccessEngine *vm) : _vm(vm) {
 	_music = nullptr;
 	_tempMusic = nullptr;
 	_isLooping = false;
+	_driver = nullptr;
+	_byte1F781 = false;
+
+	MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_MT32);
+	MusicType musicType = MidiDriver::getMusicType(dev);
+
+	// Amazon Guardians of Eden uses MIDPAK inside MIDIDRV.AP
+	// AdLib patches are inside MIDIDRV.AP too, 2nd resource file
+	//
+	// Amazon Guardians of Eden (demo) seems to use another type of driver, possibly written by Access themselves
+	// Martian Memorandum uses this other type of driver as well, which means it makes sense to reverse engineer it.
+	//
+	switch (musicType) {
+	case MT_ADLIB: {
+		if (_vm->getGameID() == GType_Amazon) {
+			Resource   *midiDrvResource = _vm->_files->loadFile(92, 1);
+			Common::MemoryReadStream *adLibInstrumentStream = new Common::MemoryReadStream(midiDrvResource->data(), midiDrvResource->_size);
+
+			_driver = Audio::MidiDriver_Miles_AdLib_create("", "", adLibInstrumentStream);
+
+			delete midiDrvResource;
+			delete adLibInstrumentStream;
+		} else {
+			MidiPlayer::createDriver();
+		}
+		break;
+	}
+	case MT_MT32:
+		_driver = Audio::MidiDriver_Miles_MT32_create("");
+		_nativeMT32 = true;
+		break;
+	case MT_GM:
+		if (ConfMan.getBool("native_mt32")) {
+			_driver = Audio::MidiDriver_Miles_MT32_create("");
+			_nativeMT32 = true;
+		}
+		break;
+
+	default:
+		break;
+	}
 
+#if 0
 	MidiPlayer::createDriver();
 	MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_GM);
+#endif
 
-	int retValue = _driver->open();
-	if (retValue == 0) {
-		if (_nativeMT32)
-			_driver->sendMT32Reset();
-		else
-			_driver->sendGMReset();
+	if (_driver) {
+		int retValue = _driver->open();
+		if (retValue == 0) {
+			if (_nativeMT32)
+				_driver->sendMT32Reset();
+			else
+				_driver->sendGMReset();
 
-		_driver->setTimerCallback(this, &timerCallback);
+			_driver->setTimerCallback(this, &timerCallback);
+		}
 	}
 }
 
@@ -215,16 +265,23 @@ MusicManager::~MusicManager() {
 }
 
 void MusicManager::send(uint32 b) {
+	// Pass data directly to driver
+	_driver->send(b);
+#if 0
 	if ((b & 0xF0) == 0xC0 && !_nativeMT32) {
 		b = (b & 0xFFFF00FF) | MidiDriver::_mt32ToGm[(b >> 8) & 0xFF] << 8;
 	}
 
 	Audio::MidiPlayer::send(b);
+#endif
 }
 
 void MusicManager::midiPlay() {
 	debugC(1, kDebugSound, "midiPlay");
 
+	if (!_driver)
+		return;
+
 	if (_music->_size < 4) {
 		error("midiPlay() wrong music resource size");
 	}
@@ -262,6 +319,8 @@ bool MusicManager::checkMidiDone() {
 void MusicManager::midiRepeat() {
 	debugC(1, kDebugSound, "midiRepeat");
 
+	if (!_driver)
+		return;
 	if (!_parser)
 		return;
 
@@ -274,6 +333,9 @@ void MusicManager::midiRepeat() {
 void MusicManager::stopSong() {
 	debugC(1, kDebugSound, "stopSong");
 
+	if (!_driver)
+		return;
+
 	stop();
 }
 
@@ -292,6 +354,9 @@ void MusicManager::loadMusic(FileIdent file) {
 void MusicManager::newMusic(int musicId, int mode) {
 	debugC(1, kDebugSound, "newMusic(%d, %d)", musicId, mode);
 
+	if (!_driver)
+		return;
+
 	if (mode == 1) {
 		stopSong();
 		freeMusic();
diff --git a/engines/access/sound.h b/engines/access/sound.h
index 90f6656e26..e11a6b9730 100644
--- a/engines/access/sound.h
+++ b/engines/access/sound.h
@@ -49,20 +49,21 @@ private:
 	AccessEngine *_vm;
 	Audio::Mixer *_mixer;
 	Audio::SoundHandle _effectsHandle;
-	Common::Array<Audio::RewindableAudioStream *> _queue;
+	Common::Array<Audio::AudioStream *> _queue;
 
 	void clearSounds();
 
-	void playSound(Resource *res, int priority);
+	void playSound(Resource *res, int priority, bool loop);
 public:
 	Common::Array<SoundEntry> _soundTable;
+	bool _playingSound;
 public:
 	SoundManager(AccessEngine *vm, Audio::Mixer *mixer);
 	~SoundManager();
 
 	void loadSoundTable(int idx, int fileNum, int subfile, int priority = 1);
 
-	void playSound(int soundIndex);
+	void playSound(int soundIndex, bool loop = false);
 	void checkSoundQueue();
 	bool isSFXPlaying();
 
@@ -84,6 +85,7 @@ private:
 
 public:
 	Resource *_music;
+	bool _byte1F781;
 
 public:
 	MusicManager(AccessEngine *vm);
diff --git a/engines/access/video.cpp b/engines/access/video.cpp
index 63d0aa5c89..5fc5f6762c 100644
--- a/engines/access/video.cpp
+++ b/engines/access/video.cpp
@@ -48,17 +48,13 @@ VideoPlayer::~VideoPlayer() {
 	closeVideo();
 }
 
-
-void VideoPlayer::setVideo(ASurface *vidSurface, const Common::Point &pt, const FileIdent &videoFile, int rate) {
+void VideoPlayer::setVideo(ASurface *vidSurface, const Common::Point &pt, int rate) {
 	_vidSurface = vidSurface;
 	vidSurface->_orgX1 = pt.x;
 	vidSurface->_orgY1 = pt.y;
 	_vm->_timers[31]._timer = rate;
 	_vm->_timers[31]._initTm = rate;
 
-	// Open up video stream
-	_videoData = _vm->_files->loadFile(videoFile);
-
 	// Load in header
 	_header._frameCount = _videoData->_stream->readUint16LE();
 	_header._width = _videoData->_stream->readUint16LE();
@@ -91,6 +87,20 @@ void VideoPlayer::setVideo(ASurface *vidSurface, const Common::Point &pt, const
 	_videoEnd = false;
 }
 
+void VideoPlayer::setVideo(ASurface *vidSurface, const Common::Point &pt, const Common::String filename, int rate) {
+	// Open up video stream
+	_videoData = _vm->_files->loadFile(filename);
+
+	setVideo(vidSurface, pt, rate);
+}
+
+void VideoPlayer::setVideo(ASurface *vidSurface, const Common::Point &pt, const FileIdent &videoFile, int rate) {
+	// Open up video stream
+	_videoData = _vm->_files->loadFile(videoFile);
+	
+	setVideo(vidSurface, pt, rate);
+}
+
 void VideoPlayer::closeVideo() {
 	delete _videoData;
 	_videoData = nullptr;
diff --git a/engines/access/video.h b/engines/access/video.h
index 17825db367..83c8995d3e 100644
--- a/engines/access/video.h
+++ b/engines/access/video.h
@@ -51,6 +51,7 @@ private:
 	Common::Rect _videoBounds;
 
 	void getFrame();
+	void setVideo(ASurface *vidSurface, const Common::Point &pt, int rate);
 public:
 	int _videoFrame;
 	bool _soundFlag;
@@ -64,6 +65,7 @@ public:
 	 * Start up a video
 	 */
 	void setVideo(ASurface *vidSurface, const Common::Point &pt, const FileIdent &videoFile, int rate);
+	void setVideo(ASurface *vidSurface, const Common::Point &pt, const Common::String filename, int rate);
 
 	/**
 	 * Decodes a frame of the video
diff --git a/engines/agi/agi.cpp b/engines/agi/agi.cpp
index 1e663ec29a..2b5d7137bc 100644
--- a/engines/agi/agi.cpp
+++ b/engines/agi/agi.cpp
@@ -97,50 +97,62 @@ void AgiEngine::processEvents() {
 			}
 			break;
 		case Common::EVENT_LBUTTONDOWN:
-			key = BUTTON_LEFT;
-			_mouse.button = kAgiMouseButtonLeft;
-			keyEnqueue(key);
-			_mouse.x = event.mouse.x;
-			_mouse.y = event.mouse.y;
+			if (_game.mouseEnabled) {
+				key = BUTTON_LEFT;
+				_mouse.button = kAgiMouseButtonLeft;
+				keyEnqueue(key);
+				_mouse.x = event.mouse.x;
+				_mouse.y = event.mouse.y;
+			}
 			break;
 		case Common::EVENT_RBUTTONDOWN:
-			key = BUTTON_RIGHT;
-			_mouse.button = kAgiMouseButtonRight;
-			keyEnqueue(key);
-			_mouse.x = event.mouse.x;
-			_mouse.y = event.mouse.y;
+			if (_game.mouseEnabled) {
+				key = BUTTON_RIGHT;
+				_mouse.button = kAgiMouseButtonRight;
+				keyEnqueue(key);
+				_mouse.x = event.mouse.x;
+				_mouse.y = event.mouse.y;
+			}
 			break;
 		case Common::EVENT_WHEELUP:
-			key = WHEEL_UP;
-			keyEnqueue(key);
+			if (_game.mouseEnabled) {
+				key = WHEEL_UP;
+				keyEnqueue(key);
+			}
 			break;
 		case Common::EVENT_WHEELDOWN:
-			key = WHEEL_DOWN;
-			keyEnqueue(key);
+			if (_game.mouseEnabled) {
+				key = WHEEL_DOWN;
+				keyEnqueue(key);
+			}
 			break;
 		case Common::EVENT_MOUSEMOVE:
-			_mouse.x = event.mouse.x;
-			_mouse.y = event.mouse.y;
-
-			if (!_game.mouseFence.isEmpty()) {
-				if (_mouse.x < _game.mouseFence.left)
-					_mouse.x = _game.mouseFence.left;
-				if (_mouse.x > _game.mouseFence.right)
-					_mouse.x = _game.mouseFence.right;
-				if (_mouse.y < _game.mouseFence.top)
-					_mouse.y = _game.mouseFence.top;
-				if (_mouse.y > _game.mouseFence.bottom)
-					_mouse.y = _game.mouseFence.bottom;
-
-				g_system->warpMouse(_mouse.x, _mouse.y);
+			if (_game.mouseEnabled) {
+				_mouse.x = event.mouse.x;
+				_mouse.y = event.mouse.y;
+
+				if (!_game.mouseFence.isEmpty()) {
+					if (_mouse.x < _game.mouseFence.left)
+						_mouse.x = _game.mouseFence.left;
+					if (_mouse.x > _game.mouseFence.right)
+						_mouse.x = _game.mouseFence.right;
+					if (_mouse.y < _game.mouseFence.top)
+						_mouse.y = _game.mouseFence.top;
+					if (_mouse.y > _game.mouseFence.bottom)
+						_mouse.y = _game.mouseFence.bottom;
+
+					g_system->warpMouse(_mouse.x, _mouse.y);
+				}
 			}
 
 			break;
 		case Common::EVENT_LBUTTONUP:
 		case Common::EVENT_RBUTTONUP:
-			_mouse.button = kAgiMouseButtonUp;
-			_mouse.x = event.mouse.x;
-			_mouse.y = event.mouse.y;
+			if (_game.mouseEnabled) {
+				_mouse.button = kAgiMouseButtonUp;
+				_mouse.x = event.mouse.x;
+				_mouse.y = event.mouse.y;
+			}
 			break;
 		case Common::EVENT_KEYDOWN:
 			if (event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_d) {
@@ -496,12 +508,15 @@ AgiBase::AgiBase(OSystem *syst, const AGIGameDescription *gameDesc) : Engine(sys
 	// Assign default values to the config manager, in case settings are missing
 	ConfMan.registerDefault("originalsaveload", "false");
 	ConfMan.registerDefault("altamigapalette", "false");
+	ConfMan.registerDefault("mousesupport", "true");
 
 	_noSaveLoadAllowed = false;
 
 	_rnd = new Common::RandomSource("agi");
 	_sound = 0;
 
+	_fontData = NULL;
+
 	initFeatures();
 	initVersion();
 }
@@ -550,6 +565,19 @@ AgiEngine::AgiEngine(OSystem *syst, const AGIGameDescription *gameDesc) : AgiBas
 	memset(&_debug, 0, sizeof(struct AgiDebug));
 	memset(&_mouse, 0, sizeof(struct Mouse));
 
+	_game.mouseEnabled = true;
+	if (!ConfMan.getBool("mousesupport")) {
+		// we effectively disable the mouse for games, that explicitly do not want mouse support to be enabled
+		_game.mouseEnabled = false;
+	}
+
+	// We are currently using the custom font for all fanmade games
+	if (!(getFeatures() & (GF_FANMADE | GF_AGDS))) {
+		_fontData = fontData_Sierra; // original Sierra font
+	} else {
+		_fontData = fontData_FanGames; // our (own?) custom font, that supports umlauts etc.
+	}
+
 	_game._vm = this;
 
 	_game.clockEnabled = false;
@@ -708,7 +736,9 @@ Common::Error AgiBase::init() {
 }
 
 Common::Error AgiEngine::go() {
-	CursorMan.showMouse(true);
+	if (_game.mouseEnabled) {
+		CursorMan.showMouse(true);
+	}
 	setTotalPlayTime(0);
 
 	if (_game.state < STATE_LOADED) {
diff --git a/engines/agi/agi.h b/engines/agi/agi.h
index 6256de05d2..04e02dcf87 100644
--- a/engines/agi/agi.h
+++ b/engines/agi/agi.h
@@ -643,6 +643,7 @@ struct AgiGame {
 	int simpleSave;					/**< select simple savegames */
 
 	Common::Rect mouseFence;		/**< rectangle set by fence.mouse command */
+	bool mouseEnabled;              /**< if mouse is supposed to be active */
 
 	// IF condition handling
 	int testResult;
@@ -780,6 +781,8 @@ protected:
 
 	void initRenderMode();
 
+	const uint8 *_fontData;
+
 public:
 	GfxMgr *_gfx;
 
@@ -839,6 +842,8 @@ public:
 
 	bool canLoadGameStateCurrently();
 	bool canSaveGameStateCurrently();
+
+	const uint8 *getFontData() { return _fontData; };
 };
 
 typedef void (*AgiCommand)(AgiGame *state, uint8 *p);
diff --git a/engines/agi/detection.cpp b/engines/agi/detection.cpp
index 3230b4e5d3..823ec7be66 100644
--- a/engines/agi/detection.cpp
+++ b/engines/agi/detection.cpp
@@ -138,21 +138,41 @@ static const PlainGameDescriptor agiGames[] = {
 	{0, 0}
 };
 
-static const ExtraGuiOption agiExtraGuiOption = {
-	_s("Use original save/load screens"),
-	_s("Use the original save/load screens, instead of the ScummVM ones"),
-	"originalsaveload",
-	false
-};
+#include "agi/detection_tables.h"
 
-static const ExtraGuiOption agiExtraGuiOptionAmiga = {
-	_s("Use an alternative palette"),
-	_s("Use an alternative palette, common for all Amiga games. This was the old behavior"),
-	"altamigapalette",
-	false
-};
+static const ADExtraGuiOptionsMap optionsList[] = {
+	{
+		GAMEOPTION_ORIGINAL_SAVELOAD,
+		{
+			_s("Use original save/load screens"),
+			_s("Use the original save/load screens, instead of the ScummVM ones"),
+			"originalsaveload",
+			false
+		}
+	},
+
+	{
+		GAMEOPTION_AMIGA_ALTERNATIVE_PALETTE,
+		{
+			_s("Use an alternative palette"),
+			_s("Use an alternative palette, common for all Amiga games. This was the old behavior"),
+			"altamigapalette",
+			false
+		}
+	},
+
+	{
+		GAMEOPTION_DISABLE_MOUSE,
+		{
+			_s("Mouse support"),
+			_s("Enables mouse support. Allows to use mouse for movement and in game menus."),
+			"mousesupport",
+			true
+		}
+	},
 
-#include "agi/detection_tables.h"
+	AD_EXTRA_GUI_OPTIONS_TERMINATOR
+};
 
 using namespace Agi;
 
@@ -161,7 +181,7 @@ class AgiMetaEngine : public AdvancedMetaEngine {
 	mutable Common::String	_extra;
 
 public:
-	AgiMetaEngine() : AdvancedMetaEngine(Agi::gameDescriptions, sizeof(Agi::AGIGameDescription), agiGames) {
+	AgiMetaEngine() : AdvancedMetaEngine(Agi::gameDescriptions, sizeof(Agi::AGIGameDescription), agiGames, optionsList) {
 		_singleid = "agi";
 		_guioptions = GUIO1(GUIO_NOSPEECH);
 	}
@@ -175,7 +195,6 @@ public:
 
 	virtual bool hasFeature(MetaEngineFeature f) const;
 	virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const;
-	virtual const ExtraGuiOptions getExtraGuiOptions(const Common::String &target) const;
 	virtual SaveStateList listSaves(const char *target) const;
 	virtual int getMaximumSaveSlot() const;
 	virtual void removeSaveState(const char *target, int slot) const;
@@ -234,14 +253,6 @@ bool AgiMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameD
 	return res;
 }
 
-const ExtraGuiOptions AgiMetaEngine::getExtraGuiOptions(const Common::String &target) const {
-	ExtraGuiOptions options;
-	options.push_back(agiExtraGuiOption);
-	if (target.contains("-amiga"))
-		options.push_back(agiExtraGuiOptionAmiga);
-	return options;
-}
-
 SaveStateList AgiMetaEngine::listSaves(const char *target) const {
 	const uint32 AGIflag = MKTAG('A','G','I',':');
 	Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
diff --git a/engines/agi/detection_tables.h b/engines/agi/detection_tables.h
index 2d7fba3507..af3d93288e 100644
--- a/engines/agi/detection_tables.h
+++ b/engines/agi/detection_tables.h
@@ -22,7 +22,16 @@
 
 namespace Agi {
 
-#define GAME_LVFPN(id,extra,fname,md5,size,lang,ver,features,gid,platform,interp) { \
+#define GAMEOPTION_ORIGINAL_SAVELOAD          GUIO_GAMEOPTIONS1
+#define GAMEOPTION_AMIGA_ALTERNATIVE_PALETTE  GUIO_GAMEOPTIONS2
+#define GAMEOPTION_DISABLE_MOUSE               GUIO_GAMEOPTIONS3
+// TODO: properly implement GAMEOPTIONs
+
+#define GAMEOPTIONS_DEFAULT                   GUIO2(GAMEOPTION_ORIGINAL_SAVELOAD,GAMEOPTION_DISABLE_MOUSE)
+#define GAMEOPTIONS_AMIGA                     GUIO2(GAMEOPTION_ORIGINAL_SAVELOAD,GAMEOPTION_AMIGA_ALTERNATIVE_PALETTE)
+#define GAMEOPTIONS_FANMADE_MOUSE             GUIO1(GAMEOPTION_ORIGINAL_SAVELOAD)
+
+#define GAME_LVFPN(id,extra,fname,md5,size,lang,ver,features,gid,platform,interp,guioptions) { \
 		{ \
 			id, \
 			extra, \
@@ -30,7 +39,7 @@ namespace Agi {
 			lang, \
 			platform, \
 			ADGF_NO_FLAGS,					\
-			GUIO0()			\
+			guioptions			\
 		}, \
 		gid, \
 		interp, \
@@ -38,7 +47,7 @@ namespace Agi {
 		ver \
 	}
 
-#define GAME_LVFPNF(id,name,fname,md5,size,lang,ver,features,gid,platform,interp) { \
+#define GAME_LVFPNF(id,name,fname,md5,size,lang,ver,features,gid,platform,interp,guioptions) { \
 		{ \
 			id, \
 			name, \
@@ -46,7 +55,7 @@ namespace Agi {
 			lang, \
 			platform, \
 			ADGF_USEEXTRAASTITLE,					\
-			GUIO0()					\
+			guioptions					\
 		}, \
 		gid, \
 		interp, \
@@ -54,43 +63,52 @@ namespace Agi {
 		ver \
 	}
 
-#define BOOTER2(id,extra,fname,md5,size,ver,gid) GAME_LVFPN(id,extra,fname,md5,size,Common::EN_ANY,ver,0,gid,Common::kPlatformDOS,GType_V2)
-#define GAME(id,extra,md5,ver,gid) GAME_LVFPN(id,extra,"logdir",md5,-1,Common::EN_ANY,ver,0,gid,Common::kPlatformDOS,GType_V2)
-#define GAME3(id,extra,fname,md5,ver,gid) GAME_LVFPN(id,extra,fname,md5,-1,Common::EN_ANY,ver,0,gid,Common::kPlatformDOS,GType_V3)
+#define BOOTER2(id,extra,fname,md5,size,ver,gid) GAME_LVFPN(id,extra,fname,md5,size,Common::EN_ANY,ver,0,gid,Common::kPlatformDOS,GType_V2,GAMEOPTIONS_DEFAULT)
+#define GAME(id,extra,md5,ver,gid) GAME_LVFPN(id,extra,"logdir",md5,-1,Common::EN_ANY,ver,0,gid,Common::kPlatformDOS,GType_V2,GAMEOPTIONS_DEFAULT)
+#define GAME3(id,extra,fname,md5,ver,gid) GAME_LVFPN(id,extra,fname,md5,-1,Common::EN_ANY,ver,0,gid,Common::kPlatformDOS,GType_V3,GAMEOPTIONS_DEFAULT)
 
-#define GAME_P(id,extra,md5,ver,gid,platform) GAME_LVFPN(id,extra,"logdir",md5,-1,Common::EN_ANY,ver,0,gid,platform,GType_V2)
+#define GAME_P(id,extra,md5,ver,gid,platform) GAME_LVFPN(id,extra,"logdir",md5,-1,Common::EN_ANY,ver,0,gid,platform,GType_V2,GAMEOPTIONS_DEFAULT)
+#define GAME_PO(id,extra,md5,ver,gid,platform,guioptions) GAME_LVFPN(id,extra,"logdir",md5,-1,Common::EN_ANY,ver,0,gid,platform,GType_V2,guioptions)
 
-#define GAME_FP(id,extra,md5,ver,flags,gid,platform) GAME_LVFPN(id,extra,"logdir",md5,-1,Common::EN_ANY,ver,flags,gid,platform,GType_V2)
+#define GAME_FP(id,extra,md5,ver,flags,gid,platform) GAME_LVFPN(id,extra,"logdir",md5,-1,Common::EN_ANY,ver,flags,gid,platform,GType_V2,GAMEOPTIONS_DEFAULT)
+#define GAME_FPO(id,extra,md5,ver,flags,gid,platform,guioptions) GAME_LVFPN(id,extra,"logdir",md5,-1,Common::EN_ANY,ver,flags,gid,platform,GType_V2,guioptions)
 #define GAME_F(id,extra,md5,ver,flags,gid) GAME_FP(id,extra,md5,ver,flags,gid,Common::kPlatformDOS)
+#define GAME_FO(id,extra,md5,ver,flags,gid,guioptions) GAME_FPO(id,extra,md5,ver,flags,gid,Common::kPlatformDOS,guioptions)
 
-#define GAME_PS(id,extra,md5,size,ver,gid,platform) GAME_LVFPN(id,extra,"logdir",md5,size,Common::EN_ANY,ver,0,gid,platform,GType_V2)
+#define GAME_PS(id,extra,md5,size,ver,gid,platform) GAME_LVFPN(id,extra,"logdir",md5,size,Common::EN_ANY,ver,0,gid,platform,GType_V2,GAMEOPTIONS_DEFAULT)
 
-#define GAME_LPS(id,extra,md5,size,lang,ver,gid,platform) GAME_LVFPN(id,extra,"logdir",md5,size,lang,ver,0,gid,platform,GType_V2)
+#define GAME_LPS(id,extra,md5,size,lang,ver,gid,platform) GAME_LVFPN(id,extra,"logdir",md5,size,lang,ver,0,gid,platform,GType_V2,GAMEOPTIONS_DEFAULT)
 
-#define GAME_LFPS(id,extra,md5,size,lang,ver,flags,gid,platform) GAME_LVFPN(id,extra,"logdir",md5,size,lang,ver,flags,gid,platform,GType_V2)
+#define GAME_LFPS(id,extra,md5,size,lang,ver,flags,gid,platform) GAME_LVFPN(id,extra,"logdir",md5,size,lang,ver,flags,gid,platform,GType_V2,GAMEOPTIONS_DEFAULT)
 
-#define GAME3_P(id,extra,fname,md5,ver,flags,gid,platform) GAME_LVFPN(id,extra,fname,md5,-1,Common::EN_ANY,ver,flags,gid,platform,GType_V3)
+#define GAME3_P(id,extra,fname,md5,ver,flags,gid,platform) GAME_LVFPN(id,extra,fname,md5,-1,Common::EN_ANY,ver,flags,gid,platform,GType_V3,GAMEOPTIONS_DEFAULT)
+#define GAME3_PO(id,extra,fname,md5,ver,flags,gid,platform,guioptions) GAME_LVFPN(id,extra,fname,md5,-1,Common::EN_ANY,ver,flags,gid,platform,GType_V3,guioptions)
 
-#define GAMEpre_P(id,extra,fname,md5,ver,gid,platform) GAME_LVFPN(id,extra,fname,md5,-1,Common::EN_ANY,ver,0,gid,platform,GType_PreAGI)
+#define GAMEpre_P(id,extra,fname,md5,ver,gid,platform) GAME_LVFPN(id,extra,fname,md5,-1,Common::EN_ANY,ver,0,gid,platform,GType_PreAGI,GAMEOPTIONS_DEFAULT)
+#define GAMEpre_PO(id,extra,fname,md5,ver,gid,platform,guioptions) GAME_LVFPN(id,extra,fname,md5,-1,Common::EN_ANY,ver,0,gid,platform,GType_PreAGI,guioptions)
 
-#define GAMEpre_PS(id,extra,fname,md5,size,ver,gid,platform) GAME_LVFPN(id,extra,fname,md5,size,Common::EN_ANY,ver,0,gid,platform,GType_PreAGI)
+#define GAMEpre_PS(id,extra,fname,md5,size,ver,gid,platform) GAME_LVFPN(id,extra,fname,md5,size,Common::EN_ANY,ver,0,gid,platform,GType_PreAGI,GAMEOPTIONS_DEFAULT)
 
-#define GAME3_PS(id,extra,fname,md5,size,ver,flags,gid,platform) GAME_LVFPN(id,extra,fname,md5,size,Common::EN_ANY,ver,flags,gid,platform,GType_V3)
+#define GAME3_PS(id,extra,fname,md5,size,ver,flags,gid,platform) GAME_LVFPN(id,extra,fname,md5,size,Common::EN_ANY,ver,flags,gid,platform,GType_V3,GAMEOPTIONS_DEFAULT)
+#define GAME3_PSO(id,extra,fname,md5,size,ver,flags,gid,platform,guioptions) GAME_LVFPN(id,extra,fname,md5,size,Common::EN_ANY,ver,flags,gid,platform,GType_V3,guioptions)
 
-#define FANMADE_ILVF(id,name,md5,lang,ver,features) GAME_LVFPNF(id,name,"logdir",md5,-1,lang,ver,(GF_FANMADE|features),GID_FANMADE,Common::kPlatformDOS,GType_V2)
+#define FANMADE_ILVFO(id,name,md5,lang,ver,features,guioptions) GAME_LVFPNF(id,name,"logdir",md5,-1,lang,ver,(GF_FANMADE|features),GID_FANMADE,Common::kPlatformDOS,GType_V2,guioptions)
 
-#define FANMADE_ISVP(id,name,md5,size,ver,platform) GAME_LVFPNF(id,name,"logdir",md5,size,Common::EN_ANY,ver,GF_FANMADE,GID_FANMADE,platform,GType_V2)
-#define FANMADE_SVP(name,md5,size,ver,platform) FANMADE_ISVP("agi-fanmade",name,md5,size,ver,platform)
+#define FANMADE_ISVPO(id,name,md5,size,ver,platform,guioptions) GAME_LVFPNF(id,name,"logdir",md5,size,Common::EN_ANY,ver,GF_FANMADE,GID_FANMADE,platform,GType_V2,guioptions)
+#define FANMADE_SVP(name,md5,size,ver,platform) FANMADE_ISVPO("agi-fanmade",name,md5,size,ver,platform,GAMEOPTIONS_DEFAULT)
 
-#define FANMADE_LVF(name,md5,lang,ver,features) FANMADE_ILVF("agi-fanmade",name,md5,lang,ver,features)
+#define FANMADE_LVFO(name,md5,lang,ver,features,guioptions) FANMADE_ILVFO("agi-fanmade",name,md5,lang,ver,features,guioptions)
 
-#define FANMADE_LF(name,md5,lang,features) FANMADE_LVF(name,md5,lang,0x2917,features)
+#define FANMADE_LF(name,md5,lang,features) FANMADE_LVFO(name,md5,lang,0x2917,features,GAMEOPTIONS_DEFAULT)
+#define FANMADE_LFO(name,md5,lang,features,guioptions) FANMADE_LVFO(name,md5,lang,0x2917,features,guioptions)
 #define FANMADE_IF(id,name,md5,features) FANMADE_ILVF(id,name,md5,Common::EN_ANY,0x2917,features)
 
-#define FANMADE_V(name,md5,ver) FANMADE_LVF(name,md5,Common::EN_ANY,ver,0)
+#define FANMADE_V(name,md5,ver) FANMADE_LVFO(name,md5,Common::EN_ANY,ver,0,GAMEOPTIONS_DEFAULT)
 #define FANMADE_F(name,md5,features) FANMADE_LF(name,md5,Common::EN_ANY,features)
+#define FANMADE_FO(name,md5,features,guioptions) FANMADE_LFO(name,md5,Common::EN_ANY,features,guioptions)
 #define FANMADE_L(name,md5,lang) FANMADE_LF(name,md5,lang,0)
 #define FANMADE_I(id,name,md5) FANMADE_IF(id,name,md5,0)
+#define FANMADE_O(name,md5,guioptions) FANMADE_FO(name,md5,0,guioptions)
 
 #define FANMADE(name,md5) FANMADE_F(name,md5,0)
 
@@ -130,7 +148,7 @@ static const AGIGameDescription gameDescriptions[] = {
 			Common::EN_ANY,
 			Common::kPlatformDOS,
 			ADGF_NO_FLAGS,
-			GUIO0()
+			GAMEOPTIONS_DEFAULT
 		},
 		GID_BC,
 		GType_V1,
@@ -151,7 +169,7 @@ static const AGIGameDescription gameDescriptions[] = {
 			Common::EN_ANY,
 			Common::kPlatformDOS,
 			ADGF_NO_FLAGS,
-			GUIO0()
+			GAMEOPTIONS_DEFAULT
 		},
 		GID_BC,
 		GType_V1,
@@ -172,7 +190,7 @@ static const AGIGameDescription gameDescriptions[] = {
 			Common::EN_ANY,
 			Common::kPlatformDOS,
 			ADGF_NO_FLAGS,
-			GUIO0()
+			GAMEOPTIONS_DEFAULT
 		},
 		GID_BC,
 		GType_V1,
@@ -181,7 +199,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	},
 
 	// Black Cauldron (Amiga) 2.00 6/14/87
-	GAME_P("bc", "2.00 1987-06-14", "7b01694af21213b4727bb94476f64eb5", 0x2440, GID_BC, Common::kPlatformAmiga),
+	GAME_PO("bc", "2.00 1987-06-14", "7b01694af21213b4727bb94476f64eb5", 0x2440, GID_BC, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// Black Cauldron (Apple IIgs) 1.0O 2/24/89 (CE)
 	// Menus not tested
@@ -210,7 +228,7 @@ static const AGIGameDescription gameDescriptions[] = {
 
 	// Donald Duck's Playground (Amiga) 1.0C
 	// Menus not tested
-	GAME_P("ddp", "1.0C 1987-04-27", "550971d196f65190a5c760d2479406ef", 0x2272, GID_DDP, Common::kPlatformAmiga),
+	GAME_PO("ddp", "1.0C 1987-04-27", "550971d196f65190a5c760d2479406ef", 0x2272, GID_DDP, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// Donald Duck's Playground (ST) 1.0A 8/8/86
 	// Menus not tested
@@ -221,7 +239,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	GAME_PS("ddp", "1.0C 1986-06-09", "550971d196f65190a5c760d2479406ef", 132, 0x2272, GID_DDP, Common::kPlatformDOS),
 
 	// Gold Rush! (Amiga) 1.01 1/13/89 aka 2.05 3/9/89	# 2.316
-	GAME3_PS("goldrush", "1.01 1989-01-13 aka 2.05 1989-03-09", "dirs", "a1d4de3e75c2688c1e2ca2634ffc3bd8", 2399, 0x3149, 0, GID_GOLDRUSH, Common::kPlatformAmiga),
+	GAME3_PSO("goldrush", "1.01 1989-01-13 aka 2.05 1989-03-09", "dirs", "a1d4de3e75c2688c1e2ca2634ffc3bd8", 2399, 0x3149, 0, GID_GOLDRUSH, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// Gold Rush! (Apple IIgs) 1.0M 2/28/89 (CE) aka 2.01 12/22/88
 	// Menus not tested
@@ -252,7 +270,7 @@ static const AGIGameDescription gameDescriptions[] = {
 			Common::EN_ANY,
 			Common::kPlatformMacintosh,
 			ADGF_NO_FLAGS,
-			GUIO0()
+			GAMEOPTIONS_DEFAULT
 		},
 		GID_GOLDRUSH,
 		GType_V3,
@@ -269,7 +287,7 @@ static const AGIGameDescription gameDescriptions[] = {
 
 	// King's Quest 1 (Amiga) 1.0U		# 2.082
 	// The original game did not have menus, they are enabled under ScummVM
-	GAME_FP("kq1", "1.0U 1986", "246c695324f1c514aee2b904fa352fad", 0x2440, GF_MENUS, GID_KQ1, Common::kPlatformAmiga),
+	GAME_FPO("kq1", "1.0U 1986", "246c695324f1c514aee2b904fa352fad", 0x2440, GF_MENUS, GID_KQ1, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// King's Quest 1 (ST) 1.0V
 	// The original game did not have menus, they are enabled under ScummVM
@@ -298,7 +316,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	GAME_P("kq2", "2.0A 1988-06-16 (CE)", "5203c8b95250a2ecfee93ddb99414753", 0x2917, GID_KQ2, Common::kPlatformApple2GS),
 
 	// King's Quest 2 (Amiga) 2.0J
-	GAME_P("kq2", "2.0J 1987-01-29", "b866f0fab2fad91433a637a828cfa410", 0x2440, GID_KQ2, Common::kPlatformAmiga),
+	GAME_PO("kq2", "2.0J 1987-01-29", "b866f0fab2fad91433a637a828cfa410", 0x2440, GID_KQ2, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// King's Quest 2 (Mac) 2.0R
 	GAME_P("kq2", "2.0R 1988-03-23", "cbdb0083317c8e7cfb7ac35da4bc7fdc", 0x2440, GID_KQ2, Common::kPlatformMacintosh),
@@ -324,7 +342,7 @@ static const AGIGameDescription gameDescriptions[] = {
 
 	// King's Quest 3 (Amiga) 1.01 11/8/86
 	// The original game did not have menus, they are enabled under ScummVM
-	GAME_FP("kq3", "1.01 1986-11-08", "8ab343306df0e2d98f136be4e8cfd0ef", 0x2440, GF_MENUS, GID_KQ3, Common::kPlatformAmiga),
+	GAME_FPO("kq3", "1.01 1986-11-08", "8ab343306df0e2d98f136be4e8cfd0ef", 0x2440, GF_MENUS, GID_KQ3, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// King's Quest 3 (ST) 1.02 11/18/86
 	// Does not have menus, crashes if menus are enforced. Therefore, ESC pauses the game
@@ -340,7 +358,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	// Original pauses with ESC, has menus accessible with mouse.
 	// ver = 0x3086 -> menus accessible with ESC or mouse, bug #2835581 (KQ3: Game Crash When Leaving Tavern as Fly).
 	// ver = 0x3149 -> menus accessible with mouse, ESC pauses game, bug #2835581 disappears.
-	GAME3_PS("kq3", "2.15 1989-11-15", "dirs", "8e35bded2bc5cf20f5eec2b15523b155", 1805, 0x3149, 0, GID_KQ3, Common::kPlatformAmiga),
+	GAME3_PSO("kq3", "2.15 1989-11-15", "dirs", "8e35bded2bc5cf20f5eec2b15523b155", 1805, 0x3149, 0, GID_KQ3, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// King's Quest 3 (PC) 1.01 11/08/86 [AGI 2.272]
 	// Does not have menus, crashes if menus are enforced. Therefore, ESC pauses the game
@@ -405,7 +423,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	GAME_P("lsl1", "1.04 1987-06-18", "8b579f8673fe9448c2538f5ed9887cf0", 0x2440, GID_LSL1, Common::kPlatformAtariST),
 
 	// Leisure Suit Larry 1 (Amiga) 1.05 6/26/87	# x.yyy
-	GAME_P("lsl1", "1.05 1987-06-26", "3f5d26d8834ca49c147fb60936869d56", 0x2440, GID_LSL1, Common::kPlatformAmiga),
+	GAME_PO("lsl1", "1.05 1987-06-26", "3f5d26d8834ca49c147fb60936869d56", 0x2440, GID_LSL1, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// Leisure Suit Larry 1 (IIgs) 1.0E
 	GAME_P("lsl1", "1.0E 1987", "5f9e1dd68d626c6d303131c119582ad4", 0x2440, GID_LSL1, Common::kPlatformApple2GS),
@@ -423,7 +441,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	GAME3_P("mh1", "2.0E 1988-10-05 (CE)", "mhdir", "2f1509f76f24e6e7d213f2dadebbf156", 0x3149, 0, GID_MH1, Common::kPlatformApple2GS),
 
 	// Manhunter NY (Amiga) 1.06 3/18/89
-	GAME3_P("mh1", "1.06 1989-03-18", "dirs", "92c6183042d1c2bb76236236a7d7a847", 0x3149, GF_OLDAMIGAV20, GID_MH1, Common::kPlatformAmiga),
+	GAME3_PO("mh1", "1.06 1989-03-18", "dirs", "92c6183042d1c2bb76236236a7d7a847", 0x3149, GF_OLDAMIGAV20, GID_MH1, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// reported by Filippos (thebluegr) in bugreport #1654500
 	// Manhunter NY (PC 5.25") 1.22 8/31/88 [AGI 3.002.107]
@@ -442,7 +460,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	GAME3_P("mh2", "1.0 1989-07-29", "mh2dir", "5e3581495708b952fea24438a6c7e040", 0x3149, 0, GID_MH1, Common::kPlatformAtariST),
 
 	// Manhunter SF (Amiga) 3.06 8/17/89		# 2.333
-	GAME3_PS("mh2", "3.06 1989-08-17", "dirs", "b412e8a126368b76696696f7632d4c16", 2573, 0x3086, GF_OLDAMIGAV20, GID_MH2, Common::kPlatformAmiga),
+	GAME3_PSO("mh2", "3.06 1989-08-17", "dirs", "b412e8a126368b76696696f7632d4c16", 2573, 0x3086, GF_OLDAMIGAV20, GID_MH2, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// Manhunter SF (PC 5.25") 3.03 8/17/89 [AGI 3.002.149]
 	GAME3("mh2", "3.03 1989-08-17 5.25\"", "mh2dir", "b90e4795413c43de469a715fb3c1fa93", 0x3149, GID_MH2),
@@ -464,7 +482,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	// Mixed-Up Mother Goose (Amiga) 1.1
 	// Problematic: crashes
 	// Menus not tested
-	GAME3_PS("mixedup", "1.1 1986-12-10", "dirs", "5c1295fe6daaf95831195ba12894dbd9", 2021, 0x3086, 0, GID_MIXEDUP, Common::kPlatformAmiga),
+	GAME3_PSO("mixedup", "1.1 1986-12-10", "dirs", "5c1295fe6daaf95831195ba12894dbd9", 2021, 0x3086, 0, GID_MIXEDUP, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 #endif
 
 	// Mixed Up Mother Goose (IIgs)
@@ -486,7 +504,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	GAME_P("pq1", "2.0B 1988-04-21", "e7c175918372336461e3811d594f482f", 0x2917, GID_PQ1, Common::kPlatformApple2GS),
 
 	// Police Quest 1 (Amiga) 2.0B 2/22/89	# 2.310
-	GAME3_PS("pq1", "2.0B 1989-02-22", "dirs", "cfa93e5f2aa7378bddd10ad6746a2ffb", 1613, 0x3149, 0, GID_PQ1, Common::kPlatformAmiga),
+	GAME3_PSO("pq1", "2.0B 1989-02-22", "dirs", "cfa93e5f2aa7378bddd10ad6746a2ffb", 1613, 0x3149, 0, GID_PQ1, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// Police Quest 1 (IIgs) 2.0A-88318
 	GAME_P("pq1", "2.0A 1988-03-18", "8994e39d0901de3d07cecfb954075bb5", 0x2917, GID_PQ1, Common::kPlatformApple2GS),
@@ -524,7 +542,7 @@ static const AGIGameDescription gameDescriptions[] = {
 
 	// Space Quest 1 (Amiga) 1.2			# 2.082
 	// The original game did not have menus, they are enabled under ScummVM
-	GAME_FP("sq1", "1.2 1986", "0b216d931e95750f1f4837d6a4b821e5", 0x2440, GF_MENUS | GF_OLDAMIGAV20, GID_SQ1, Common::kPlatformAmiga),
+	GAME_FPO("sq1", "1.2 1986", "0b216d931e95750f1f4837d6a4b821e5", 0x2440, GF_MENUS | GF_OLDAMIGAV20, GID_SQ1, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// Space Quest 1 (Mac) 1.5D
 	GAME_P("sq1", "1.5D 1987-04-02", "ce88419aadd073d1c6682d859b3d8aa2", 0x2440, GID_SQ1, Common::kPlatformMacintosh),
@@ -570,7 +588,7 @@ static const AGIGameDescription gameDescriptions[] = {
 			Common::EN_ANY,
 			Common::kPlatformAmiga,
 			ADGF_NO_FLAGS,
-			GUIO0()
+			GAMEOPTIONS_AMIGA
 		},
 		GID_SQ2,
 		GType_V2,
@@ -616,7 +634,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	GAMEpre_P("winnie", "", "title.pic", "2e7900c1ccaa7671d65405f6d1efed30", 0x0000, GID_WINNIE, Common::kPlatformDOS),
 
 	// Winnie the Pooh in the Hundred Acre Wood (Amiga)
-	GAMEpre_P("winnie", "", "title", "2e7900c1ccaa7671d65405f6d1efed30", 0x0000, GID_WINNIE, Common::kPlatformAmiga),
+	GAMEpre_PO("winnie", "", "title", "2e7900c1ccaa7671d65405f6d1efed30", 0x0000, GID_WINNIE, Common::kPlatformAmiga, GAMEOPTIONS_AMIGA),
 
 	// Winnie the Pooh in the Hundred Acre Wood (C64)
 	GAMEpre_P("winnie", "", "title.pic", "d4eb97cffc866110f71e1ec9f84fe643", 0x0000, GID_WINNIE, Common::kPlatformC64),
@@ -630,15 +648,15 @@ static const AGIGameDescription gameDescriptions[] = {
 	// Xmas Card 1986 (CoCo3 360k) [AGI 2.072]
 	GAME_PS("xmascard", "", "25ad35e9628fc77e5e0dd35852a272b6", 768, 0x2440, GID_XMASCARD, Common::kPlatformCoCo3),
 
-	FANMADE_F("2 Player Demo", "4279f46b3cebd855132496476b1d2cca", GF_AGIMOUSE),
+	FANMADE_FO("2 Player Demo", "4279f46b3cebd855132496476b1d2cca", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("AGI Combat", "0be6a8a9e19203dcca0067d280798871"),
 	FANMADE("AGI Contest 1 Template", "d879aed25da6fc655564b29567358ae2"),
 	FANMADE("AGI Contest 2 Template", "5a2fb2894207eff36c72f5c1b08bcc07"),
-	FANMADE("AGI Mouse Demo 0.60 demo 1", "c07e2519de674c67386cb2cc6f2e3904"),
-	FANMADE("AGI Mouse Demo 0.60 demo 2", "cc49d8b88ed6faf4f53ce92c84e0fe1b"),
-	FANMADE("AGI Mouse Demo 0.70", "3497c291e4afb6f758e61740678a2aec"),
-	FANMADE_F("AGI Mouse Demo 1.00", "20397f0bf0ef936f416bb321fb768fc7", GF_AGIMOUSE),
-	FANMADE_F("AGI Mouse Demo 1.10", "f4ad396b496d6167635ad0b410312ab8", GF_AGIMOUSE|GF_AGIPAL),
+	FANMADE_O("AGI Mouse Demo 0.60 demo 1", "c07e2519de674c67386cb2cc6f2e3904", GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_O("AGI Mouse Demo 0.60 demo 2", "cc49d8b88ed6faf4f53ce92c84e0fe1b", GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_O("AGI Mouse Demo 0.70", "3497c291e4afb6f758e61740678a2aec", GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_FO("AGI Mouse Demo 1.00", "20397f0bf0ef936f416bb321fb768fc7", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_FO("AGI Mouse Demo 1.10", "f4ad396b496d6167635ad0b410312ab8", GF_AGIMOUSE|GF_AGIPAL, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("AGI Piano (v1.0)", "8778b3d89eb93c1d50a70ef06ef10310"),
 	FANMADE("AGI Quest (v1.46-TJ0)", "1cf1a5307c1a0a405f5039354f679814"),
 	GAME("tetris", "", "7a874e2db2162e7a4ce31c9130248d8a", 0x2917, GID_FANMADE),
@@ -657,15 +675,15 @@ static const AGIGameDescription gameDescriptions[] = {
 	FANMADE("Al Pond 1 - Al Lives Forever (v1.0)", "e8921c3043b749b056ff51f56d1b451b"),
 	FANMADE("Al Pond 1 - Al Lives Forever (v1.3)", "fb4699474054962e0dbfb4cf12ca52f6"),
 	FANMADE("Apocalyptic Quest (v0.03 Teaser)", "42ced528b67965d3bc3b52c635f94a57"),
-	FANMADE_F("Apocalyptic Quest (v4.00 Alpha 1)", "e15581628d84949b8d352d224ec3184b", GF_AGIMOUSE),
-	FANMADE_F("Apocalyptic Quest (v4.00 Alpha 2)", "0eee850005860e46345b38fea093d194", GF_AGIMOUSE),
-	FANMADE_F("Band Quest (Demo)", "7326abefd793571cc17ed0db647bdf34", GF_AGIMOUSE),
-	FANMADE_F("Band Quest (Early Demo)", "de4758dd34676b248c8301b32d93bc6f", GF_AGIMOUSE),
+	FANMADE_FO("Apocalyptic Quest (v4.00 Alpha 1)", "e15581628d84949b8d352d224ec3184b", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_FO("Apocalyptic Quest (v4.00 Alpha 2)", "0eee850005860e46345b38fea093d194", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_FO("Band Quest (Demo)", "7326abefd793571cc17ed0db647bdf34", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_FO("Band Quest (Early Demo)", "de4758dd34676b248c8301b32d93bc6f", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Beyond the Titanic 2", "9b8de38dc64ffb3f52b7877ea3ebcef9"),
 	FANMADE("Biri Quest 1", "1b08f34f2c43e626c775c9d6649e2f17"),
 	FANMADE("Bob The Farmboy", "e4b7df9d0830addee5af946d380e66d7"),
-	FANMADE_F("Boring Man 1: The Toad to Robinland", "d74481cbd227f67ace37ce6a5493039f", GF_AGIMOUSE),
-	FANMADE_F("Boring Man 2: Ho Man! This Game Sucks!", "250032ba105bdf7c1bc4fed767c2d37e", GF_AGIMOUSE),
+	FANMADE_FO("Boring Man 1: The Toad to Robinland", "d74481cbd227f67ace37ce6a5493039f", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_FO("Boring Man 2: Ho Man! This Game Sucks!", "250032ba105bdf7c1bc4fed767c2d37e", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Botz", "a8fabe4e807adfe5ec02bfec6d983695"),
 	FANMADE("Brian's Quest (v1.0)", "0964aa79b9cdcff7f33a12b1d7e04b9c"),
 	FANMADE("CPU-21 (v1.0)", "35b7cdb4d17e890e4c52018d96e9cbf4"),
@@ -676,12 +694,12 @@ static const AGIGameDescription gameDescriptions[] = {
 	FANMADE("Coco Coq (English) - Coco Coq In Grostesteing's Base (v.1.0.3)", "97631f8e710544a58bd6da9e780f9320"),
 	FANMADE_L("Coco Coq (French) - Coco Coq Dans la Base de Grostesteing (v1.0.2)", "ef579ebccfe5e356f9a557eb3b2d8649", Common::FR_FRA),
 	FANMADE("Corby's Murder Mystery (v1.0)", "4ebe62ac24c5a8c7b7898c8eb070efe5"),
-	FANMADE_F("DG: The AGIMouse Adventure (English v1.1)", "efe453b92bc1487ea69fbebede4d5f26", GF_AGIMOUSE|GF_AGIPAL),
-	FANMADE_LF("DG: The AGIMouse Adventure (French v1.1)", "eb3d17ca466d672cbb95947e8d6e846a", Common::FR_FRA, GF_AGIMOUSE|GF_AGIPAL),
+	FANMADE_FO("DG: The AGIMouse Adventure (English v1.1)", "efe453b92bc1487ea69fbebede4d5f26", GF_AGIMOUSE|GF_AGIPAL, GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_LFO("DG: The AGIMouse Adventure (French v1.1)", "eb3d17ca466d672cbb95947e8d6e846a", Common::FR_FRA, GF_AGIMOUSE|GF_AGIPAL, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("DG: The Adventure Game (English v1.1)", "0d6376d493fa7a21ec4da1a063e12b25"),
 	FANMADE_L("DG: The Adventure Game (French v1.1)", "258bdb3bb8e61c92b71f2f456cc69e23", Common::FR_FRA),
 	FANMADE("Dashiki (16 Colors)", "9b2c7b9b0283ab9f12bedc0cb6770a07"),
-	FANMADE_F("Dashiki (256 Colors)", "c68052bb209e23b39b55ff3d759958e6", GF_AGIMOUSE|GF_AGI256),
+	FANMADE_FO("Dashiki (256 Colors)", "c68052bb209e23b39b55ff3d759958e6", GF_AGIMOUSE|GF_AGI256, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Date Quest 1 (v1.0)", "ba3dcb2600645be53a13170aa1a12e69"),
 	FANMADE("Date Quest 2 (v1.0 Demo)", "1602d6a2874856e928d9a8c8d2d166e9"),
 	FANMADE("Date Quest 2 (v1.0)", "f13f6fc85aa3e6e02b0c20408fb63b47"),
@@ -708,20 +726,20 @@ static const AGIGameDescription gameDescriptions[] = {
 	FANMADE("Good Man (demo v3.41)", "3facd8a8f856b7b6e0f6c3200274d88c"),
 
 	GAME_LVFPNF("agi-fanmade", "Groza (russian) [AGDS sample]", "logdir", "421da3a18004122a966d64ab6bd86d2e", -1,
-		Common::RU_RUS, 0x2440, GF_AGDS, GID_FANMADE, Common::kPlatformDOS,GType_V2),
+		Common::RU_RUS, 0x2440, GF_AGDS, GID_FANMADE, Common::kPlatformDOS,GType_V2,GAMEOPTIONS_DEFAULT),
 
 	GAME_LVFPNF("agi-fanmade", "Get Outta Space Quest", "logdir", "aaea5b4a348acb669d13b0e6f22d4dc9", -1,
-		Common::EN_ANY, 0x2440, GF_FANMADE, GID_GETOUTTASQ, Common::kPlatformDOS,GType_V2),
+		Common::EN_ANY, 0x2440, GF_FANMADE, GID_GETOUTTASQ, Common::kPlatformDOS,GType_V2,GAMEOPTIONS_DEFAULT),
 
-	FANMADE_F("Half-Death - Terror At White-Mesa", "b62c05d0ace878261392073f57ae788c", GF_AGIMOUSE),
+	FANMADE_FO("Half-Death - Terror At White-Mesa", "b62c05d0ace878261392073f57ae788c", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Hank's Quest (v1.0 English) - Victim of Society", "64c15b3d0483d17888129100dc5af213"),
 	FANMADE("Hank's Quest (v1.1 English) - Victim of Society", "86d1f1dd9b0c4858d096e2a60cca8a14"),
 	FANMADE_L("Hank's Quest (v1.81 Dutch) - Slachtoffer Van Het Gebeuren", "41e53972d55ff3dff9e90d15fe1b659f", Common::NL_NLD),
 	FANMADE("Hank's Quest (v1.81 English) - Victim of Society", "7a776383282f62a57c3a960dafca62d1"),
 	FANMADE("Herbao (v0.2)", "6a5186fc8383a9060517403e85214fc2"),
-	FANMADE_F("Hitler's Legacy (v.0004q)", "a412881269ba34584bd0a3268e5a9863", GF_AGIMOUSE),
+	FANMADE_FO("Hitler's Legacy (v.0004q)", "a412881269ba34584bd0a3268e5a9863", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Hobbits", "4a1c1ef3a7901baf0ab45fde0cfadd89"),
-	FANMADE_F("Isabella Coq - A Present For My Dad", "55c6819f2330c4d5d6459874c9f123d9", GF_AGIMOUSE),
+	FANMADE_FO("Isabella Coq - A Present For My Dad", "55c6819f2330c4d5d6459874c9f123d9", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Jack & Julia - VAMPYR", "8aa0b9a26f8d5a4421067ab8cc3706f6"),
 	FANMADE("Jeff's Quest (v.5 alpha Jun 1)", "10f1720eed40c12b02a0f32df3e72ded"),
 	FANMADE("Jeff's Quest (v.5 alpha May 31)", "51ff71c0ed90db4e987a488ed3bf0551"),
@@ -730,8 +748,8 @@ static const AGIGameDescription gameDescriptions[] = {
 	FANMADE("Jiggy Jiggy Uh! Uh!", "bc331588a71e7a1c8840f6cc9b9487e4"),
 	FANMADE("Jimmy In: The Alien Attack (v0.1)", "a4e9db0564a494728de7873684a4307c"),
 	FANMADE("Joe McMuffin In \"What's Cooking, Doc\" (v1.0)", "8a3de7e61a99cb605fa6d233dd91c8e1"),
-	FANMADE_LVF("Jolimie, le Village Maudit (v0.5)", "21818501636b3cb8ad5de5c1a66de5c2", Common::FR_FRA, 0x2936, GF_AGIMOUSE|GF_AGIPAL),
-	FANMADE_LVF("Jolimie, le Village Maudit (v1.1)", "68d7aef1161bb5972fe03efdf29ccb7f", Common::FR_FRA, 0x2936, GF_AGIMOUSE|GF_AGIPAL),
+	FANMADE_LVFO("Jolimie, le Village Maudit (v0.5)", "21818501636b3cb8ad5de5c1a66de5c2", Common::FR_FRA, 0x2936, GF_AGIMOUSE|GF_AGIPAL, GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_LVFO("Jolimie, le Village Maudit (v1.1)", "68d7aef1161bb5972fe03efdf29ccb7f", Common::FR_FRA, 0x2936, GF_AGIMOUSE|GF_AGIPAL, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Journey Of Chef", "aa0a0b5a6364801ae65fdb96d6741df5"),
 	FANMADE("Jukebox (v1.0)", "c4b9c5528cc67f6ba777033830de7751"),
 	FANMADE("Justin Quest (v1.0 in development)", "103050989da7e0ffdc1c5e1793a4e1ec"),
@@ -747,18 +765,18 @@ static const AGIGameDescription gameDescriptions[] = {
 	FANMADE("MD Quest - The Search for Michiel (v0.10)", "2a6fcb21d2b5e4144c38ed817fabe8ee"),
 	FANMADE("Maale Adummin Quest", "ddfbeb33feb7cf78504fe4dba14ec63b"),
 	FANMADE("Monkey Man", "2322d03f997e8cc235d4578efff69cfa"),
-	FANMADE_F("Napalm Quest (v0.5)", "b659afb491d967bb34810d1c6ce22093", GF_AGIMOUSE),
+	FANMADE_FO("Napalm Quest (v0.5)", "b659afb491d967bb34810d1c6ce22093", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Naturette 1 (English v1.2)", "0a75884e7f010974a230bdf269651117"),
 	FANMADE("Naturette 1 (English v1.3)", "f15bbf999ac55ebd404aa1eb84f7c1d9"),
 	FANMADE_L("Naturette 1 (French v1.2)", "d3665622cc41aeb9c7ecf4fa43f20e53", Common::FR_FRA),
-	FANMADE_F("Naturette 2: Daughter of the Moon (v1.0)", "bdf76a45621c7f56d1c9d40292c6137a", GF_AGIMOUSE|GF_AGIPAL),
-	FANMADE_F("Naturette 3: Adventure in Treeworld (v1.0a)", "6dbb0e7fc75fec442e6d9e5a06f1530e", GF_AGIMOUSE|GF_AGIPAL),
-	FANMADE_F("Naturette 4: From a Planet to Another Planet (Not Finished)", "13be8cd9cf35aeff0a39b8757057fbc8", GF_AGIMOUSE),
+	FANMADE_FO("Naturette 2: Daughter of the Moon (v1.0)", "bdf76a45621c7f56d1c9d40292c6137a", GF_AGIMOUSE|GF_AGIPAL, GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_FO("Naturette 3: Adventure in Treeworld (v1.0a)", "6dbb0e7fc75fec442e6d9e5a06f1530e", GF_AGIMOUSE|GF_AGIPAL, GAMEOPTIONS_FANMADE_MOUSE),
+	FANMADE_FO("Naturette 4: From a Planet to Another Planet (Not Finished)", "13be8cd9cf35aeff0a39b8757057fbc8", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
 	// FIXME: Actually Naturette 4 has both English and French language support built into it. How to add that information?
-	FANMADE_F("Naturette 4: From a Planet to Another Planet (2007-10-05)", "8253706b6ef5423a79413b216760297c", GF_AGIMOUSE|GF_AGIPAL),
+	FANMADE_FO("Naturette 4: From a Planet to Another Planet (2007-10-05)", "8253706b6ef5423a79413b216760297c", GF_AGIMOUSE|GF_AGIPAL, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("New AGI Hangman Test", "d69c0e9050ccc29fd662b74d9fc73a15"),
 	FANMADE("Nick's Quest - In Pursuit of QuakeMovie (v2.1 Gold)", "e29cbf9222551aee40397fabc83eeca0"),
-	FANMADE_F("Open Mic Night (v0.1)", "70000a2f67aac27d1133d019df70246d", GF_AGIMOUSE|GF_AGIPAL),
+	FANMADE_FO("Open Mic Night (v0.1)", "70000a2f67aac27d1133d019df70246d", GF_AGIMOUSE|GF_AGIPAL, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Operation: Recon", "0679ce8405411866ccffc8a6743370d0"),
 	FANMADE("Patrick's Quest (Demo v1.0)", "f254f5b894b98fec5f92acc07fb62841"),
 	FANMADE("Phantasmagoria", "87d20c1c11aee99a4baad3797b63146b"),
@@ -802,14 +820,14 @@ static const AGIGameDescription gameDescriptions[] = {
 	FANMADE("Save Santa (v1.3)", "f8afdb6efc5af5e7c0228b44633066af"),
 	FANMADE("Schiller (preview 1)", "ade39dea968c959cfebe1cf935d653e9"),
 	FANMADE("Schiller (preview 2)", "62cd1f8fc758bf6b4aa334e553624cef"),
-	GAME_F("serguei1", "v1.0", "b86725f067e456e10cdbdf5f58e01dec", 0x2917, GF_FANMADE|GF_AGIMOUSE|GF_AGIPAL, GID_FANMADE),
+	GAME_FO("serguei1", "v1.0", "b86725f067e456e10cdbdf5f58e01dec", 0x2917, GF_FANMADE|GF_AGIMOUSE|GF_AGIPAL, GID_FANMADE, GAMEOPTIONS_FANMADE_MOUSE),
 	// FIXME: The following two entries have identical MD5 checksums?
-	GAME_F("serguei1", "v1.1 2002 Sep 5", "91975c1fb4b13b0f9a8e9ff74731030d", 0x2917, GF_FANMADE|GF_AGIMOUSE|GF_AGIPAL, GID_FANMADE),
-	GAME_F("serguei1", "v1.1 2003 Apr 10", "91975c1fb4b13b0f9a8e9ff74731030d", 0x2917, GF_FANMADE|GF_AGIMOUSE|GF_AGIPAL, GID_FANMADE),
-	GAME_F("serguei2", "v0.1.1 Demo", "906ccbc2ddedb29b63141acc6d10cd28", 0x2917, GF_FANMADE|GF_AGIMOUSE, GID_FANMADE),
-	GAME_F("serguei2", "v1.3.1 Demo (March 22nd 2008)", "ad1308fcb8f48723cd388e012ebf5e20", 0x2917, GF_FANMADE|GF_AGIMOUSE|GF_AGIPAL, GID_FANMADE),
+	GAME_FO("serguei1", "v1.1 2002 Sep 5", "91975c1fb4b13b0f9a8e9ff74731030d", 0x2917, GF_FANMADE|GF_AGIMOUSE|GF_AGIPAL, GID_FANMADE, GAMEOPTIONS_FANMADE_MOUSE),
+	GAME_FO("serguei1", "v1.1 2003 Apr 10", "91975c1fb4b13b0f9a8e9ff74731030d", 0x2917, GF_FANMADE|GF_AGIMOUSE|GF_AGIPAL, GID_FANMADE, GAMEOPTIONS_FANMADE_MOUSE),
+	GAME_FO("serguei2", "v0.1.1 Demo", "906ccbc2ddedb29b63141acc6d10cd28", 0x2917, GF_FANMADE|GF_AGIMOUSE, GID_FANMADE, GAMEOPTIONS_FANMADE_MOUSE),
+	GAME_FO("serguei2", "v1.3.1 Demo (March 22nd 2008)", "ad1308fcb8f48723cd388e012ebf5e20", 0x2917, GF_FANMADE|GF_AGIMOUSE|GF_AGIPAL, GID_FANMADE, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Shifty (v1.0)", "2a07984d27b938364bf6bd243ac75080"),
-	FANMADE_F("Sliding Tile Game (v1.00)", "949bfff5d8a81c3139152eed4d84ca75", GF_AGIMOUSE),
+	FANMADE_FO("Sliding Tile Game (v1.00)", "949bfff5d8a81c3139152eed4d84ca75", GF_AGIMOUSE, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE("Snowboarding Demo (v1.0)", "24bb8f29f1eddb5c0a099705267c86e4"),
 	FANMADE("Solar System Tour", "b5a3d0f392dfd76a6aa63f3d5f578403"),
 	FANMADE("Sorceror's Appraisal", "fe62615557b3cb7b08dd60c9d35efef1"),
@@ -819,7 +837,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	GAME("sqx", "v10.0 Feb 05", "c992ae2f8ab18360404efdf16fa9edd1", 0x2917, GID_FANMADE),
 	GAME("sqx", "v10.0 Jul 18", "812edec45cefad559d190ffde2f9c910", 0x2917, GID_FANMADE),
 	GAME_PS("sqx", "", "f0a59044475a5fa37c055d8c3eb4d1a7", 768, 0x2440, GID_FANMADE, Common::kPlatformCoCo3),
-	FANMADE_F("Space Quest 3.5", "c077bc28d7b36213dd99dc9ecb0147fc", GF_AGIMOUSE|GF_AGIPAL),
+	FANMADE_FO("Space Quest 3.5", "c077bc28d7b36213dd99dc9ecb0147fc", GF_AGIMOUSE|GF_AGIPAL, GAMEOPTIONS_FANMADE_MOUSE),
 	FANMADE_F("Space Trek (v1.0)", "807a1aeadb2ace6968831d36ab5ea37a", GF_CLIPCOORDS),
 	FANMADE("Special Delivery", "88764dfe61126b8e73612c851b510a33"),
 	FANMADE("Speeder Bike Challenge (v1.0)", "2deb25bab379285ca955df398d96c1e7"),
@@ -832,6 +850,7 @@ static const AGIGameDescription gameDescriptions[] = {
 	FANMADE("Tex McPhilip 3 - A Destiny of Sin (Demo v0.25)", "992d12031a486ad84e592ff5d7c9d782"),
 	FANMADE("The 13th Disciple (v1.00)", "887719ad59afce9a41ec057dbb73ad73"),
 	FANMADE("The Adventures of a Crazed Hermit", "6e3086cbb794d3299a9c5a9792295511"),
+	FANMADE("The Gourd of the Beans", "246f4d94946afb547482d44a53616d06"),
 	FANMADE("The Grateful Dead", "c2146631afacf8cb455ce24f3d2d46e7"),
 	FANMADE("The Legend of Shay-Larah 1 - The Lost Prince", "04e720c8e30c9cf12db22ea14a24a3dd"),
 	FANMADE("The Legend of Zelda: The Fungus of Time (Demo v1.00)", "dcaf8166ceb62a3d9b9aea7f3b197c09"),
@@ -862,7 +881,7 @@ static const AGIGameDescription gameDescriptions[] = {
 			Common::EN_ANY,
 			Common::kPlatformDOS,
 			ADGF_USEEXTRAASTITLE,
-			GUIO0()
+			GAMEOPTIONS_DEFAULT
 		},
 		GID_FANMADE,
 		GType_V3,
@@ -890,7 +909,7 @@ static AGIGameDescription g_fallbackDesc = {
 		Common::UNK_LANG,
 		Common::kPlatformDOS,
 		ADGF_NO_FLAGS,
-		GUIO0()
+		GAMEOPTIONS_DEFAULT
 	},
 	GID_FANMADE,
 	GType_V2,
diff --git a/engines/agi/font.h b/engines/agi/font.h
index c77d8cf0c3..0e6b15f06b 100644
--- a/engines/agi/font.h
+++ b/engines/agi/font.h
@@ -26,7 +26,7 @@
 namespace Agi {
 
 // 8x8 font patterns
-static const uint8 curFont[] = {
+static const uint8 fontData_Sierra[] = {
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x7E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E,	// cursor hollow
 	0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E,	// cursor solid
@@ -59,6 +59,267 @@ static const uint8 curFont[] = {
 	0x00, 0x24, 0x42, 0xFF, 0x42, 0x24, 0x00, 0x00,
 	0x00, 0x10, 0x38, 0x7C, 0xFE, 0xFE, 0x00, 0x00,
 	0x00, 0xFE, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0x00,
+	// original sierra font starts here
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 Space
+	0x30, 0x78, 0x78, 0x30, 0x30, 0x00, 0x30, 0x00,
+	0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x6C, 0x6C, 0xFE, 0x6C, 0xFE, 0x6C, 0x6C, 0x00,
+	0x30, 0x7C, 0xC0, 0x78, 0x0C, 0xF8, 0x30, 0x00,
+	0x00, 0xC6, 0xCC, 0x18, 0x30, 0x66, 0xC6, 0x00,
+	0x38, 0x6C, 0x38, 0x76, 0xDC, 0xCC, 0x76, 0x00,
+	0x60, 0x60, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x18, 0x30, 0x60, 0x60, 0x60, 0x30, 0x18, 0x00,
+	0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00,
+	0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00,
+	0x00, 0x30, 0x30, 0xFC, 0x30, 0x30, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x60,
+	0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00,
+	0x06, 0x0C, 0x18, 0x30, 0x60, 0xC0, 0x80, 0x00,
+	0x7C, 0xC6, 0xCE, 0xDE, 0xF6, 0xE6, 0x7C, 0x00, // 0x30
+	0x30, 0x70, 0x30, 0x30, 0x30, 0x30, 0xFC, 0x00,
+	0x78, 0xCC, 0x0C, 0x38, 0x60, 0xCC, 0xFC, 0x00,
+	0x78, 0xCC, 0x0C, 0x38, 0x0C, 0xCC, 0x78, 0x00,
+	0x1C, 0x3C, 0x6C, 0xCC, 0xFE, 0x0C, 0x1E, 0x00,
+	0xFC, 0xC0, 0xF8, 0x0C, 0x0C, 0xCC, 0x78, 0x00,
+	0x38, 0x60, 0xC0, 0xF8, 0xCC, 0xCC, 0x78, 0x00,
+	0xFC, 0xCC, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x00,
+	0x78, 0xCC, 0xCC, 0x78, 0xCC, 0xCC, 0x78, 0x00,
+	0x78, 0xCC, 0xCC, 0x7C, 0x0C, 0x18, 0x70, 0x00,
+	0x00, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x00,
+	0x00, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x60,
+	0x18, 0x30, 0x60, 0xC0, 0x60, 0x30, 0x18, 0x00,
+	0x00, 0x00, 0xFC, 0x00, 0x00, 0xFC, 0x00, 0x00,
+	0x60, 0x30, 0x18, 0x0C, 0x18, 0x30, 0x60, 0x00,
+	0x78, 0xCC, 0x0C, 0x18, 0x30, 0x00, 0x30, 0x00,
+	0x7C, 0xC6, 0xDE, 0xDE, 0xDE, 0xC0, 0x78, 0x00, // 0x40
+	0x30, 0x78, 0xCC, 0xCC, 0xFC, 0xCC, 0xCC, 0x00,
+	0xFC, 0x66, 0x66, 0x7C, 0x66, 0x66, 0xFC, 0x00,
+	0x3C, 0x66, 0xC0, 0xC0, 0xC0, 0x66, 0x3C, 0x00,
+	0xF8, 0x6C, 0x66, 0x66, 0x66, 0x6C, 0xF8, 0x00,
+	0xFE, 0x62, 0x68, 0x78, 0x68, 0x62, 0xFE, 0x00,
+	0xFE, 0x62, 0x68, 0x78, 0x68, 0x60, 0xF0, 0x00,
+	0x3C, 0x66, 0xC0, 0xC0, 0xCE, 0x66, 0x3E, 0x00,
+	0xCC, 0xCC, 0xCC, 0xFC, 0xCC, 0xCC, 0xCC, 0x00,
+	0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00,
+	0x1E, 0x0C, 0x0C, 0x0C, 0xCC, 0xCC, 0x78, 0x00,
+	0xE6, 0x66, 0x6C, 0x78, 0x6C, 0x66, 0xE6, 0x00,
+	0xF0, 0x60, 0x60, 0x60, 0x62, 0x66, 0xFE, 0x00,
+	0xC6, 0xEE, 0xFE, 0xFE, 0xD6, 0xC6, 0xC6, 0x00,
+	0xC6, 0xE6, 0xF6, 0xDE, 0xCE, 0xC6, 0xC6, 0x00,
+	0x38, 0x6C, 0xC6, 0xC6, 0xC6, 0x6C, 0x38, 0x00,
+	0xFC, 0x66, 0x66, 0x7C, 0x60, 0x60, 0xF0, 0x00, // 0x50
+	0x78, 0xCC, 0xCC, 0xCC, 0xDC, 0x78, 0x1C, 0x00,
+	0xFC, 0x66, 0x66, 0x7C, 0x6C, 0x66, 0xE6, 0x00,
+	0x78, 0xCC, 0xE0, 0x70, 0x1C, 0xCC, 0x78, 0x00,
+	0xFC, 0xB4, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00,
+	0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xFC, 0x00,
+	0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x78, 0x30, 0x00,
+	0xC6, 0xC6, 0xC6, 0xD6, 0xFE, 0xEE, 0xC6, 0x00,
+	0xC6, 0xC6, 0x6C, 0x38, 0x38, 0x6C, 0xC6, 0x00,
+	0xCC, 0xCC, 0xCC, 0x78, 0x30, 0x30, 0x78, 0x00,
+	0xFE, 0xC6, 0x8C, 0x18, 0x32, 0x66, 0xFE, 0x00,
+	0x78, 0x60, 0x60, 0x60, 0x60, 0x60, 0x78, 0x00,
+	0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x02, 0x00,
+	0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00,
+	0x10, 0x38, 0x6C, 0xC6, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+	0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x60
+	0x00, 0x00, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00,
+	0xE0, 0x60, 0x60, 0x7C, 0x66, 0x66, 0xDC, 0x00,
+	0x00, 0x00, 0x78, 0xCC, 0xC0, 0xCC, 0x78, 0x00,
+	0x1C, 0x0C, 0x0C, 0x7C, 0xCC, 0xCC, 0x76, 0x00,
+	0x00, 0x00, 0x78, 0xCC, 0xFC, 0xC0, 0x78, 0x00,
+	0x38, 0x6C, 0x60, 0xF0, 0x60, 0x60, 0xF0, 0x00,
+	0x00, 0x00, 0x76, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8,
+	0xE0, 0x60, 0x6C, 0x76, 0x66, 0x66, 0xE6, 0x00,
+	0x30, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00,
+	0x0C, 0x00, 0x0C, 0x0C, 0x0C, 0xCC, 0xCC, 0x78,
+	0xE0, 0x60, 0x66, 0x6C, 0x78, 0x6C, 0xE6, 0x00,
+	0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00,
+	0x00, 0x00, 0xCC, 0xFE, 0xFE, 0xD6, 0xC6, 0x00,
+	0x00, 0x00, 0xF8, 0xCC, 0xCC, 0xCC, 0xCC, 0x00,
+	0x00, 0x00, 0x78, 0xCC, 0xCC, 0xCC, 0x78, 0x00,
+	0x00, 0x00, 0xDC, 0x66, 0x66, 0x7C, 0x60, 0xF0, // 0x70
+	0x00, 0x00, 0x76, 0xCC, 0xCC, 0x7C, 0x0C, 0x1E,
+	0x00, 0x00, 0xDC, 0x76, 0x66, 0x60, 0xF0, 0x00,
+	0x00, 0x00, 0x7C, 0xC0, 0x78, 0x0C, 0xF8, 0x00,
+	0x10, 0x30, 0x7C, 0x30, 0x30, 0x34, 0x18, 0x00,
+	0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00,
+	0x00, 0x00, 0xCC, 0xCC, 0xCC, 0x78, 0x30, 0x00,
+	0x00, 0x00, 0xC6, 0xD6, 0xFE, 0xFE, 0x6C, 0x00,
+	0x00, 0x00, 0xC6, 0x6C, 0x38, 0x6C, 0xC6, 0x00,
+	0x00, 0x00, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8,
+	0x00, 0x00, 0xFC, 0x98, 0x30, 0x64, 0xFC, 0x00,
+	0x1C, 0x30, 0x30, 0xE0, 0x30, 0x30, 0x1C, 0x00,
+	0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00,
+	0xE0, 0x30, 0x30, 0x1C, 0x30, 0x30, 0xE0, 0x00,
+	0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	// custom font starting here at 0x80
+	0x1E, 0x36, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x00, // 0x80
+	0x7C, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C, 0x00,
+	0x7C, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x7C, 0x00,
+	0x7E, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00,
+	0x38, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0xFE, 0xC6,
+	0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x7E, 0x00,
+	0xDB, 0xDB, 0x7E, 0x3C, 0x7E, 0xDB, 0xDB, 0x00,
+	0x3C, 0x66, 0x06, 0x1C, 0x06, 0x66, 0x3C, 0x00,
+	0x66, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x66, 0x00,
+	0x3C, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x66, 0x00,
+	0x66, 0x6C, 0x78, 0x70, 0x78, 0x6C, 0x66, 0x00,
+	0x1E, 0x36, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00,
+	0xC6, 0xEE, 0xFE, 0xFE, 0xD6, 0xC6, 0xC6, 0x00,
+	0x66, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00,
+	0x3C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00,
+	0x7E, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00,
+	0x7C, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x00,
+	0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C, 0x00,
+	0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00,
+	0x66, 0x66, 0x66, 0x3E, 0x06, 0x66, 0x3C, 0x00,
+	0x7E, 0xDB, 0xDB, 0xDB, 0x7E, 0x18, 0x18, 0x00,
+	0x66, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x66, 0x00,
+	0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7F, 0x03,
+	0x66, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x06, 0x00,
+	0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xFF, 0x00,
+	0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xFF, 0x03,
+	0xE0, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C, 0x00,
+	0xC6, 0xC6, 0xC6, 0xF6, 0xDE, 0xDE, 0xF6, 0x00,
+	0x60, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C, 0x00,
+	0x78, 0x8C, 0x06, 0x3E, 0x06, 0x8C, 0x78, 0x00,
+	0xCE, 0xDB, 0xDB, 0xFB, 0xDB, 0xDB, 0xCE, 0x00,
+	0x3E, 0x66, 0x66, 0x66, 0x3E, 0x36, 0x66, 0x00,
+	0x00, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x3A, 0x00,
+	0x00, 0x3C, 0x60, 0x3C, 0x66, 0x66, 0x3C, 0x00,
+	0x00, 0x00, 0x7C, 0x66, 0x7C, 0x66, 0x7C, 0x00,
+	0x00, 0x00, 0x7E, 0x60, 0x60, 0x60, 0x60, 0x00,
+	0x00, 0x00, 0x3C, 0x6C, 0x6C, 0x6C, 0xFE, 0xC6,
+	0x00, 0x00, 0x3C, 0x66, 0x7E, 0x60, 0x3C, 0x00,
+	0x00, 0x00, 0xDB, 0x7E, 0x3C, 0x7E, 0xDB, 0x00,
+	0x00, 0x00, 0x3C, 0x66, 0x0C, 0x66, 0x3C, 0x00,
+	0x00, 0x00, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x00,
+	0x00, 0x18, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x00,
+	0x00, 0x00, 0x66, 0x6C, 0x78, 0x6C, 0x66, 0x00,
+	0x00, 0x00, 0x1E, 0x36, 0x66, 0x66, 0x66, 0x00,
+	0x00, 0x00, 0xC6, 0xFE, 0xFE, 0xD6, 0xC6, 0x00,
+	0x00, 0x00, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x00,
+	0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00,
+	0x00, 0x00, 0x7E, 0x66, 0x66, 0x66, 0x66, 0x00,
+	0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44,
+	0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA,
+	0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77, 0xDD, 0x77,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0x18, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18,
+	0x36, 0x36, 0x36, 0xF6, 0x36, 0x36, 0x36, 0x36,
+	0x00, 0x00, 0x00, 0xFE, 0x36, 0x36, 0x36, 0x36,
+	0x00, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, 0x18,
+	0x36, 0xF6, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+	0x00, 0xFE, 0x06, 0xF6, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0xF6, 0x06, 0xFE, 0x00, 0x00, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0xFE, 0x00, 0x00, 0x00, 0x00,
+	0x18, 0xF8, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0xF8, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0x18, 0x18, 0x1F, 0x00, 0x00, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0xFF, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0x18, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18,
+	0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18,
+	0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0x37, 0x30, 0x3F, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x3F, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0xFF, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36,
+	0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x36, 0xF7, 0x00, 0xF7, 0x36, 0x36, 0x36, 0x36,
+	0x18, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x36, 0x36, 0x36, 0xFF, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0xFF, 0x00, 0xFF, 0x18, 0x18, 0x18, 0x18,
+	0x00, 0x00, 0x00, 0xFF, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0x36, 0x36, 0x3F, 0x00, 0x00, 0x00, 0x00,
+	0x18, 0x1F, 0x18, 0x1F, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, 0x18,
+	0x00, 0x00, 0x00, 0x3F, 0x36, 0x36, 0x36, 0x36,
+	0x36, 0x36, 0x36, 0xFF, 0x36, 0x36, 0x36, 0x36,
+	0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0x18, 0x18, 0xF8, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x1F, 0x18, 0x18, 0x18, 0x18,
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+	0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
+	0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
+	0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x00,
+	0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C, 0x00,
+	0x00, 0x00, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x00,
+	0x00, 0x00, 0x66, 0x66, 0x3E, 0x06, 0x7C, 0x00,
+	0x00, 0x00, 0x7E, 0xDB, 0xDB, 0x7E, 0x18, 0x00,
+	0x00, 0x00, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x00,
+	0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x7F, 0x03,
+	0x00, 0x00, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x00,
+	0x00, 0x00, 0xDB, 0xDB, 0xDB, 0xDB, 0xFF, 0x00,
+	0x00, 0x00, 0xDB, 0xDB, 0xDB, 0xDB, 0xFF, 0x03,
+	0x00, 0x00, 0xE0, 0x60, 0x7C, 0x66, 0x7C, 0x00,
+	0x00, 0x00, 0xC6, 0xC6, 0xF6, 0xDE, 0xF6, 0x00,
+	0x00, 0x00, 0x60, 0x60, 0x7C, 0x66, 0x7C, 0x00,
+	0x00, 0x00, 0x7C, 0x06, 0x3E, 0x06, 0x7C, 0x00,
+	0x00, 0x00, 0xCE, 0xDB, 0xFB, 0xDB, 0xCE, 0x00,
+	0x00, 0x00, 0x3E, 0x66, 0x3E, 0x36, 0x66, 0x00,
+	0x00, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00,
+	0x10, 0x10, 0x7C, 0x10, 0x10, 0x00, 0x7C, 0x00,
+	0x00, 0x30, 0x18, 0x0C, 0x06, 0x0C, 0x18, 0x30,
+	0x00, 0x0C, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0C,
+	0x0E, 0x1B, 0x1B, 0x18, 0x18, 0x18, 0x18, 0x18,
+	0x18, 0x18, 0x18, 0x18, 0x18, 0xD8, 0xD8, 0x70,
+	0x00, 0x18, 0x18, 0x00, 0x7E, 0x00, 0x18, 0x18,
+	0x00, 0x76, 0xDC, 0x00, 0x76, 0xDC, 0x00, 0x00,
+	0x00, 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x00,
+	0x03, 0x02, 0x06, 0x04, 0xCC, 0x68, 0x38, 0x10,
+	0x3C, 0x42, 0x99, 0xA1, 0xA1, 0x99, 0x42, 0x3C,
+	0x30, 0x48, 0x10, 0x20, 0x78, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x7C, 0x7C, 0x7C, 0x7C, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x7E, 0x00
+};
+
+static const uint8 fontData_FanGames[] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x7E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E,	/* cursor hollow */
+	0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E,	/* cursor solid */
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* cursor empty */
+	0x10, 0x38, 0x7C, 0xFE, 0x7C, 0x38, 0x10, 0x00,
+	0x3C, 0x3C, 0x18, 0xFF, 0xE7, 0x18, 0x3C, 0x00,
+	0x10, 0x38, 0x7C, 0xFE, 0xEE, 0x10, 0x38, 0x00,
+	0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00,
+	0xFF, 0xFF, 0xE7, 0xC3, 0xC3, 0xE7, 0xFF, 0xFF,
+	0x00, 0x3C, 0x66, 0x42, 0x42, 0x66, 0x3C, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* \n */
+	0x0F, 0x07, 0x0F, 0x7D, 0xCC, 0xCC, 0xCC, 0x78,
+	0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x7E, 0x18,
+	0x08, 0x0C, 0x0A, 0x0A, 0x08, 0x78, 0xF0, 0x00,
+	0x18, 0x14, 0x1A, 0x16, 0x72, 0xE2, 0x0E, 0x1C,
+	0x10, 0x54, 0x38, 0xEE, 0x38, 0x54, 0x10, 0x00,
+	0x80, 0xE0, 0xF8, 0xFE, 0xF8, 0xE0, 0x80, 0x00,
+	0x02, 0x0E, 0x3E, 0xFE, 0x3E, 0x0E, 0x02, 0x00,
+	0x18, 0x3C, 0x5A, 0x18, 0x5A, 0x3C, 0x18, 0x00,
+	0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00,
+	0x7F, 0xDB, 0xDB, 0xDB, 0x7B, 0x1B, 0x1B, 0x00,
+	0x1C, 0x22, 0x38, 0x44, 0x44, 0x38, 0x88, 0x70,
+	0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0x7E, 0x00,
+	0x18, 0x3C, 0x5A, 0x18, 0x5A, 0x3C, 0x18, 0x7E,
+	0x18, 0x3C, 0x5A, 0x18, 0x18, 0x18, 0x18, 0x00,
+	0x18, 0x18, 0x18, 0x18, 0x5A, 0x3C, 0x18, 0x00,
+	0x00, 0x18, 0x0C, 0xFE, 0x0C, 0x18, 0x00, 0x00,
+	0x00, 0x30, 0x60, 0xFE, 0x60, 0x30, 0x00, 0x00,
+	0x00, 0x00, 0xC0, 0xC0, 0xC0, 0xFE, 0x00, 0x00,
+	0x00, 0x24, 0x42, 0xFF, 0x42, 0x24, 0x00, 0x00,
+	0x00, 0x10, 0x38, 0x7C, 0xFE, 0xFE, 0x00, 0x00,
+	0x00, 0xFE, 0xFE, 0x7C, 0x38, 0x10, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x18, 0x3C, 0x3C, 0x18, 0x18, 0x00, 0x18, 0x00,
 	0x6C, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -154,9 +415,7 @@ static const uint8 curFont[] = {
 	0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00,
 	0xE0, 0x30, 0x30, 0x18, 0x30, 0x30, 0xE0, 0x00,
 	0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	//0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00,
-	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	//replacement 0x7F
-
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	/*replacement 0x7F */
 	0x1E, 0x36, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x00,
 	0x7C, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C, 0x00,
 	0x7C, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x7C, 0x00,
@@ -287,7 +546,7 @@ static const uint8 curFont[] = {
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x7E, 0x00
 };
 
-static const uint8 mickey_fontdata[] = {
+static const uint8 fontData_Mickey[] = {
 	0x00, 0x36, 0x7F, 0x7F, 0x3E, 0x1C, 0x08, 0x00,
 	0x00, 0x00, 0x3F, 0x20, 0x2F, 0x28, 0x28, 0x28,
 	0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
@@ -546,7 +805,7 @@ static const uint8 mickey_fontdata[] = {
 	0x10, 0x18, 0x1C, 0x1E, 0x1C, 0x18, 0x10, 0x00,
 };
 
-static const uint8 ibm_fontdata[] = {
+static const uint8 fontData_IBM[] = {
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x7E, 0x81, 0xA5, 0x81, 0xBD, 0x99, 0x81, 0x7E,
 	0x7E, 0xFF, 0xDB, 0xFF, 0xC3, 0xE7, 0xFF, 0x7E,
diff --git a/engines/agi/graphics.cpp b/engines/agi/graphics.cpp
index 2b1bd8c829..c5cede71ef 100644
--- a/engines/agi/graphics.cpp
+++ b/engines/agi/graphics.cpp
@@ -72,6 +72,7 @@ static const uint8 egaPalette[16 * 3] = {
  * from Donald Duck's Playground (1986) to Manhunter II (1989).
  * 16 RGB colors. 3 bits per color component.
  */
+#if 0
 static const uint8 atariStAgiPalette[16 * 3] = {
 	0x0, 0x0, 0x0,
 	0x0, 0x0, 0x7,
@@ -90,6 +91,7 @@ static const uint8 atariStAgiPalette[16 * 3] = {
 	0x7, 0x7, 0x4,
 	0x7, 0x7, 0x7
 };
+#endif
 
 /**
  * Second generation Apple IIGS AGI palette.
@@ -109,6 +111,8 @@ static const uint8 atariStAgiPalette[16 * 3] = {
  * 3.001 (Black Cauldron        v1.0O 1989-02-24 (CE))
  * 3.003 (Gold Rush!            v1.0M 1989-02-28 (CE))
  */
+#if 0
+// FIXME: Identical to amigaAgiPaletteV2
 static const uint8 appleIIgsAgiPaletteV2[16 * 3] = {
 	0x0, 0x0, 0x0,
 	0x0, 0x0, 0xF,
@@ -127,6 +131,7 @@ static const uint8 appleIIgsAgiPaletteV2[16 * 3] = {
 	0xE, 0xE, 0x0,
 	0xF, 0xF, 0xF
 };
+#endif
 
 /**
  * First generation Amiga & Apple IIGS AGI palette.
@@ -616,6 +621,8 @@ void GfxMgr::putTextCharacter(int l, int x, int y, unsigned char c, int fg, int
 	int x1, y1, xx, yy, cc;
 	const uint8 *p;
 
+	assert(font);
+
 	p = font + ((unsigned int)c * CHAR_LINES);
 	for (y1 = 0; y1 < CHAR_LINES; y1++) {
 		for (x1 = 0; x1 < CHAR_COLS; x1++) {
@@ -699,7 +706,7 @@ void GfxMgr::printCharacter(int x, int y, char c, int fg, int bg) {
 	x *= CHAR_COLS;
 	y *= CHAR_LINES;
 
-	putTextCharacter(0, x, y, c, fg, bg);
+	putTextCharacter(0, x, y, c, fg, bg, false, _vm->getFontData());
 	// redundant! already inside put_text_character!
 	// flush_block (x, y, x + CHAR_COLS - 1, y + CHAR_LINES - 1);
 }
@@ -754,7 +761,7 @@ void GfxMgr::rawDrawButton(int x, int y, const char *s, int fgcolor, int bgcolor
 	drawRectangle(x1, y1, x2, y2, border ? BUTTON_BORDER : MSG_BOX_COLOR);
 
 	while (*s) {
-		putTextCharacter(0, x + textOffset, y + textOffset, *s++, fgcolor, bgcolor);
+		putTextCharacter(0, x + textOffset, y + textOffset, *s++, fgcolor, bgcolor, false, _vm->getFontData());
 		x += CHAR_COLS;
 	}
 
diff --git a/engines/agi/graphics.h b/engines/agi/graphics.h
index 15668fbed3..506a9d93d6 100644
--- a/engines/agi/graphics.h
+++ b/engines/agi/graphics.h
@@ -56,7 +56,7 @@ public:
 
 	void gfxPutBlock(int x1, int y1, int x2, int y2);
 
-	void putTextCharacter(int, int, int, unsigned char, int, int, bool checkerboard = false, const uint8 *font = curFont);
+	void putTextCharacter(int, int, int, unsigned char, int, int, bool checkerboard = false, const uint8 *font = fontData_Sierra);
 	void shakeScreen(int);
 	void shakeStart();
 	void shakeEnd();
diff --git a/engines/agi/preagi.cpp b/engines/agi/preagi.cpp
index daadb5ffef..c368c7b195 100644
--- a/engines/agi/preagi.cpp
+++ b/engines/agi/preagi.cpp
@@ -59,6 +59,12 @@ void PreAgiEngine::initialize() {
 	_gfx = new GfxMgr(this);
 	_picture = new PictureMgr(this, _gfx);
 
+	if (getGameID() == GID_MICKEY) {
+		_fontData = fontData_Mickey;
+	} else {
+		_fontData = fontData_IBM;
+	}
+
 	_gfx->initMachine();
 
 	_game.gameFlags = 0;
@@ -137,7 +143,7 @@ void PreAgiEngine::drawStr(int row, int col, int attr, const char *buffer) {
 			break;
 
 		default:
-			_gfx->putTextCharacter(1, col * 8 , row * 8, static_cast<char>(code), attr & 0x0f, (attr & 0xf0) / 0x10, false, getGameID() == GID_MICKEY ? mickey_fontdata : ibm_fontdata);
+			_gfx->putTextCharacter(1, col * 8 , row * 8, static_cast<char>(code), attr & 0x0f, (attr & 0xf0) / 0x10, false, _fontData);
 
 			if (++col == 320 / 8) {
 				col = 0;
diff --git a/engines/agi/preagi_mickey.cpp b/engines/agi/preagi_mickey.cpp
index a1572d7f1f..883107a957 100644
--- a/engines/agi/preagi_mickey.cpp
+++ b/engines/agi/preagi_mickey.cpp
@@ -2299,6 +2299,8 @@ void MickeyEngine::init() {
 	_gameStateMickey.fItemUsed[IDI_MSA_ITEM_LETTER] = true;
 
 #endif
+
+	setflag(fSoundOn, true); // enable sound
 }
 
 Common::Error MickeyEngine::go() {
diff --git a/engines/agi/sound_pcjr.cpp b/engines/agi/sound_pcjr.cpp
index 51b2d067a4..ea7a2789e0 100644
--- a/engines/agi/sound_pcjr.cpp
+++ b/engines/agi/sound_pcjr.cpp
@@ -120,8 +120,6 @@ SoundGenPCJr::SoundGenPCJr(AgiBase *vm, Audio::Mixer *pMixer) : SoundGen(vm, pMi
 	else
 		_dissolveMethod = 0;
 
-	_dissolveMethod = 3;
-
 	memset(_channel, 0, sizeof(_channel));
 	memset(_tchannel, 0, sizeof(_tchannel));
 
@@ -207,9 +205,6 @@ int SoundGenPCJr::volumeCalc(SndGenChan *chan) {
 				chan->attenuationCopy = attenuation;
 
 				attenuation &= 0x0F;
-				attenuation += _mixer->getVolumeForSoundType(Audio::Mixer::kSFXSoundType) / 17;
-				if (attenuation > 0x0F)
-					attenuation = 0x0F;
 			}
 		}
 		//if (computer_type == 2) && (attenuation < 8)
@@ -411,7 +406,7 @@ int SoundGenPCJr::chanGen(int chan, int16 *stream, int len) {
 		if (tpcm->noteCount <= 0) {
 			// get new tone data
 			if ((tpcm->avail) && (getNextNote(chan) == 0)) {
-				tpcm->atten = _channel[chan].attenuation;
+				tpcm->atten = volumeCalc(&_channel[chan]);
 				tpcm->freqCount = _channel[chan].freqCount;
 				tpcm->genType = _channel[chan].genType;
 
@@ -477,8 +472,9 @@ int SoundGenPCJr::fillSquare(ToneChan *t, int16 *buf, int len) {
 
 	count = len;
 
+	int16 amp = (int16)(volTable[t->atten] * _mixer->getVolumeForSoundType(Audio::Mixer::kMusicSoundType) / Audio::Mixer::kMaxMixerVolume);
 	while (count > 0) {
-		*(buf++) = t->sign ? volTable[t->atten] : -volTable[t->atten];
+		*(buf++) = t->sign ? amp : -amp;
 		count--;
 
 		// get next sample
@@ -515,8 +511,9 @@ int SoundGenPCJr::fillNoise(ToneChan *t, int16 *buf, int len) {
 
 	count = len;
 
+	int16 amp = (int16)(volTable[t->atten] * _mixer->getVolumeForSoundType(Audio::Mixer::kMusicSoundType) / Audio::Mixer::kMaxMixerVolume);
 	while (count > 0) {
-		*(buf++) = t->sign ? volTable[t->atten] : -volTable[t->atten];
+		*(buf++) = t->sign ? amp : -amp;
 		count--;
 
 		// get next sample
diff --git a/engines/agi/text.cpp b/engines/agi/text.cpp
index eb48857bf2..16c8284ce0 100644
--- a/engines/agi/text.cpp
+++ b/engines/agi/text.cpp
@@ -50,7 +50,7 @@ void AgiEngine::printText2(int l, const char *msg, int foff, int xoff, int yoff,
 
 	// FR: strings with len == 1 were not printed
 	if (len == 1) {
-		_gfx->putTextCharacter(l, xoff + foff, yoff, *msg, fg, bg, checkerboard);
+		_gfx->putTextCharacter(l, xoff + foff, yoff, *msg, fg, bg, checkerboard, _fontData);
 		maxx = 1;
 		minx = 0;
 		ofoff = foff;
@@ -74,7 +74,7 @@ void AgiEngine::printText2(int l, const char *msg, int foff, int xoff, int yoff,
 					if (xpos >= GFX_WIDTH)
 						continue;
 
-					_gfx->putTextCharacter(l, xpos, ypos, *m, fg, bg, checkerboard);
+					_gfx->putTextCharacter(l, xpos, ypos, *m, fg, bg, checkerboard, _fontData);
 
 					if (x1 > maxx)
 						maxx = x1;
diff --git a/engines/agos/agos.cpp b/engines/agos/agos.cpp
index 6eda2eb9aa..8952e649fd 100644
--- a/engines/agos/agos.cpp
+++ b/engines/agos/agos.cpp
@@ -585,7 +585,9 @@ Common::Error AGOSEngine::init() {
 		((getFeatures() & GF_TALKIE) && getPlatform() == Common::kPlatformAcorn) ||
 		(getPlatform() == Common::kPlatformDOS)) {
 
-		int ret = _midi->open(getGameType());
+		bool isDemo = (getFeatures() & GF_DEMO) ? true : false;
+
+		int ret = _midi->open(getGameType(), isDemo);
 		if (ret)
 			warning("MIDI Player init failed: \"%s\"", MidiDriver::getErrorName(ret));
 
diff --git a/engines/agos/detection_tables.h b/engines/agos/detection_tables.h
index 2f4709c49e..793d4081cf 100644
--- a/engines/agos/detection_tables.h
+++ b/engines/agos/detection_tables.h
@@ -1385,7 +1385,7 @@ static const AGOSGameDescription gameDescriptions[] = {
 	{
 		{
 			"simon1",
-			"Floppy",
+			"Infocom Floppy",
 
 			{
 	{ "gamepc",		GAME_BASEFILE,	"9f93d27432ce44a787eef10adb640870", 37070},
@@ -1409,7 +1409,7 @@ static const AGOSGameDescription gameDescriptions[] = {
 	{
 		{
 			"simon1",
-			"Floppy",
+			"Infocom Floppy",
 
 			{
 	{ "gamepc",		GAME_BASEFILE,	"62de24fc579b94fac7d3d23201b65b14", -1},
@@ -1599,11 +1599,11 @@ static const AGOSGameDescription gameDescriptions[] = {
 		GF_TALKIE
 	},
 
-	// Simon the Sorcerer 1 - English DOS CD alternate?
+	// Simon the Sorcerer 1 - English DOS CD  (Infocom)
 	{
 		{
 			"simon1",
-			"CD",
+			"Infocom CD",
 
 			{
 	{ "gamepc",		GAME_BASEFILE,	"c0b948b6821d2140f8b977144f21027a", -1},
diff --git a/engines/agos/drivers/accolade/adlib.cpp b/engines/agos/drivers/accolade/adlib.cpp
new file mode 100644
index 0000000000..294be2b8a7
--- /dev/null
+++ b/engines/agos/drivers/accolade/adlib.cpp
@@ -0,0 +1,883 @@
+/* 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 "agos/agos.h"
+#include "agos/drivers/accolade/mididriver.h"
+
+#include "common/file.h"
+#include "common/mutex.h"
+#include "common/system.h"
+#include "common/textconsole.h"
+
+#include "audio/fmopl.h"
+#include "audio/softsynth/emumidi.h"
+
+namespace AGOS {
+
+#define AGOS_ADLIB_VOICES_COUNT 11
+#define AGOS_ADLIB_VOICES_MELODIC_COUNT 6
+#define AGOS_ADLIB_VOICES_PERCUSSION_START 6
+#define AGOS_ADLIB_VOICES_PERCUSSION_COUNT 5
+#define AGOS_ADLIB_VOICES_PERCUSSION_CYMBAL 9
+
+// 5 instruments on top of the regular MIDI ones
+// used by the MUSIC.DRV variant for percussion instruments
+#define AGOS_ADLIB_EXTRA_INSTRUMENT_COUNT 5
+
+const byte operator1Register[AGOS_ADLIB_VOICES_COUNT] = {
+	0x00, 0x01, 0x02, 0x08, 0x09, 0x0A, 0x10, 0x14, 0x12, 0x15, 0x11
+};
+
+const byte operator2Register[AGOS_ADLIB_VOICES_COUNT] = {
+	0x03, 0x04, 0x05, 0x0B, 0x0C, 0x0D, 0x13, 0xFF, 0xFF, 0xFF, 0xFF
+};
+
+// percussion:
+//  voice  6 - base drum - also uses operator 13h
+//  voice  7 - snare drum
+//  voice  8 - tom tom
+//  voice  9 - cymbal
+//  voice 10 - hi hat
+const byte percussionBits[AGOS_ADLIB_VOICES_PERCUSSION_COUNT] = {
+	0x10, 0x08, 0x04, 0x02, 0x01
+};
+
+// hardcoded, dumped from Accolade music system
+// same for INSTR.DAT + MUSIC.DRV, except that MUSIC.DRV does the lookup differently
+const byte percussionKeyNoteChannelTable[] = {
+	0x06, 0x07, 0x07, 0x07, 0x07, 0x08, 0x0A, 0x08, 0x0A, 0x08,
+	0x0A, 0x08, 0x08, 0x09, 0x08, 0x09, 0x0F, 0x0F, 0x0A, 0x0F,
+	0x0A, 0x0F, 0x0F, 0x0F, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+	0x08, 0x08, 0x08, 0x08, 0x0A, 0x0F, 0x0F, 0x08, 0x0F, 0x08
+};
+
+struct InstrumentEntry {
+	byte reg20op1; // Amplitude Modulation / Vibrato / Envelope Generator Type / Keyboard Scaling Rate / Modulator Frequency Multiple
+	byte reg40op1; // Level Key Scaling / Total Level
+	byte reg60op1; // Attack Rate / Decay Rate
+	byte reg80op1; // Sustain Level / Release Rate
+	byte reg20op2; // Amplitude Modulation / Vibrato / Envelope Generator Type / Keyboard Scaling Rate / Modulator Frequency Multiple
+	byte reg40op2; // Level Key Scaling / Total Level
+	byte reg60op2; // Attack Rate / Decay Rate
+	byte reg80op2; // Sustain Level / Release Rate
+	byte regC0;    // Feedback / Algorithm, bit 0 - set -> both operators in use
+};
+
+// hardcoded, dumped from Accolade music system (INSTR.DAT variant)
+const uint16 frequencyLookUpTable[12] = {
+	0x02B2, 0x02DB, 0x0306, 0x0334, 0x0365, 0x0399, 0x03CF,
+	0xFE05, 0xFE23, 0xFE44, 0xFE67, 0xFE8B
+};
+
+// hardcoded, dumped from Accolade music system (MUSIC.DRV variant)
+const uint16 frequencyLookUpTableMusicDrv[12] = {
+	0x0205, 0x0223, 0x0244, 0x0267, 0x028B, 0x02B2, 0x02DB,
+	0x0306, 0x0334, 0x0365, 0x0399, 0x03CF
+};
+
+//
+// Accolade adlib music driver
+//
+// Remarks:
+//
+// There are at least 2 variants of this sound system.
+// One for the games Elvira 1 + Elvira 2
+// It seems it was also used for the game "Altered Destiny"
+// Another one for the games Waxworks + Simon, the Sorcerer 1 Demo
+//
+// First one uses the file INSTR.DAT for instrument data, channel mapping etc.
+// Second one uses the file MUSIC.DRV, which actually contains driver code + instrument data + channel mapping, etc.
+//
+// The second variant supported dynamic channel allocation for the FM voice channels, but this
+// feature was at least definitely disabled for Simon, the Sorcerer 1 demo and for the Waxworks demo too.
+//
+// I have currently not implemented dynamic channel allocation.
+
+class MidiDriver_Accolade_AdLib : public MidiDriver {
+public:
+	MidiDriver_Accolade_AdLib();
+	virtual ~MidiDriver_Accolade_AdLib();
+
+	// MidiDriver
+	int open();
+	void close();
+	void send(uint32 b);
+	MidiChannel *allocateChannel() { return NULL; }
+	MidiChannel *getPercussionChannel() { return NULL; }
+
+	bool isOpen() const { return _isOpen; }
+	uint32 getBaseTempo() { return 1000000 / OPL::OPL::kDefaultCallbackFrequency; }
+
+	void setVolume(byte volume);
+	virtual uint32 property(int prop, uint32 param);
+
+	bool setupInstruments(byte *instrumentData, uint16 instrumentDataSize, bool useMusicDrvFile);
+
+	void setTimerCallback(void *timerParam, Common::TimerManager::TimerProc timerProc);
+
+private:
+	bool _musicDrvMode;
+
+	// from INSTR.DAT/MUSIC.DRV - simple mapping between MIDI channel and MT32 channel
+	byte _channelMapping[AGOS_MIDI_CHANNEL_COUNT];
+	// from INSTR.DAT/MUSIC.DRV - simple mapping between MIDI instruments and MT32 instruments
+	byte _instrumentMapping[AGOS_MIDI_INSTRUMENT_COUNT];
+	// from INSTR.DAT/MUSIC.DRV - volume adjustment per instrument
+	signed char _instrumentVolumeAdjust[AGOS_MIDI_INSTRUMENT_COUNT];
+	// simple mapping between MIDI key notes and MT32 key notes
+	byte _percussionKeyNoteMapping[AGOS_MIDI_KEYNOTE_COUNT];
+
+	// from INSTR.DAT/MUSIC.DRV - adlib instrument data
+	InstrumentEntry *_instrumentTable;
+	byte            _instrumentCount;
+
+	struct ChannelEntry {
+		const  InstrumentEntry *currentInstrumentPtr;
+		byte   currentNote;
+		byte   currentA0hReg;
+		byte   currentB0hReg;
+		int16  volumeAdjust;
+
+		ChannelEntry() : currentInstrumentPtr(NULL), currentNote(0),
+						currentA0hReg(0), currentB0hReg(0), volumeAdjust(0) { }
+	};
+
+	byte _percussionReg;
+
+	OPL::OPL *_opl;
+	int _masterVolume;
+
+	Common::TimerManager::TimerProc _adlibTimerProc;
+	void *_adlibTimerParam;
+
+	bool _isOpen;
+
+	// stores information about all FM voice channels
+	ChannelEntry _channels[AGOS_ADLIB_VOICES_COUNT];
+
+	void onTimer();
+
+	void resetAdLib();
+	void resetAdLibOperatorRegisters(byte baseRegister, byte value);
+	void resetAdLibFMVoiceChannelRegisters(byte baseRegister, byte value);
+
+	void programChange(byte FMvoiceChannel, byte mappedInstrumentNr, byte MIDIinstrumentNr);
+	void programChangeSetInstrument(byte FMvoiceChannel, byte mappedInstrumentNr, byte MIDIinstrumentNr);
+	void setRegister(int reg, int value);
+	void noteOn(byte FMvoiceChannel, byte note, byte velocity);
+	void noteOnSetVolume(byte FMvoiceChannel, byte operatorReg, byte adjustedVelocity);
+	void noteOff(byte FMvoiceChannel, byte note, bool dontCheckNote);
+};
+
+MidiDriver_Accolade_AdLib::MidiDriver_Accolade_AdLib()
+		: _masterVolume(15), _opl(0),
+		  _adlibTimerProc(0), _adlibTimerParam(0), _isOpen(false) {
+	memset(_channelMapping, 0, sizeof(_channelMapping));
+	memset(_instrumentMapping, 0, sizeof(_instrumentMapping));
+	memset(_instrumentVolumeAdjust, 0, sizeof(_instrumentVolumeAdjust));
+	memset(_percussionKeyNoteMapping, 0, sizeof(_percussionKeyNoteMapping));
+
+	_instrumentTable = NULL;
+	_instrumentCount = 0;
+	_musicDrvMode = false;
+	_percussionReg = 0x20;
+}
+
+MidiDriver_Accolade_AdLib::~MidiDriver_Accolade_AdLib() {
+	if (_instrumentTable) {
+		delete[] _instrumentTable;
+		_instrumentCount = 0;
+	}
+}
+
+int MidiDriver_Accolade_AdLib::open() {
+//	debugC(kDebugLevelAdLibDriver, "AdLib: starting driver");
+
+	_opl = OPL::Config::create(OPL::Config::kOpl2);
+
+	if (!_opl)
+		return -1;
+
+	_opl->init();
+
+	_isOpen = true;
+
+	_opl->start(new Common::Functor0Mem<void, MidiDriver_Accolade_AdLib>(this, &MidiDriver_Accolade_AdLib::onTimer));
+
+	resetAdLib();
+
+	// Finally set up default instruments
+	for (byte FMvoiceNr = 0; FMvoiceNr < AGOS_ADLIB_VOICES_COUNT; FMvoiceNr++) {
+		if (FMvoiceNr < AGOS_ADLIB_VOICES_PERCUSSION_START) {
+			// Regular FM voices with instrument 0
+			programChangeSetInstrument(FMvoiceNr, 0, 0);
+		} else {
+			byte percussionInstrument;
+			if (!_musicDrvMode) {
+				// INSTR.DAT: percussion voices with instrument 1, 2, 3, 4 and 5
+				percussionInstrument = FMvoiceNr - AGOS_ADLIB_VOICES_PERCUSSION_START + 1;
+			} else {
+				// MUSIC.DRV: percussion voices with instrument 0x80, 0x81, 0x82, 0x83 and 0x84
+				percussionInstrument = FMvoiceNr - AGOS_ADLIB_VOICES_PERCUSSION_START + 0x80;
+			}
+			programChangeSetInstrument(FMvoiceNr, percussionInstrument, percussionInstrument);
+		}
+	}
+
+	// driver initialization does this here:
+	// INSTR.DAT
+	// noteOn(9, 0x29, 0);
+	// noteOff(9, 0x26, false);
+	// MUSIC.DRV
+	// noteOn(9, 0x26, 0);
+	// noteOff(9, 0x26, false);
+
+	return 0;
+}
+
+void MidiDriver_Accolade_AdLib::close() {
+	delete _opl;
+	_isOpen = false;
+}
+
+void MidiDriver_Accolade_AdLib::setVolume(byte volume) {
+	_masterVolume = volume;
+	//renewNotes(-1, true);
+}
+
+void MidiDriver_Accolade_AdLib::onTimer() {
+	if (_adlibTimerProc)
+		(*_adlibTimerProc)(_adlibTimerParam);
+}
+
+void MidiDriver_Accolade_AdLib::resetAdLib() {
+	// The original driver sent 0x00 to register 0x00 up to 0xF5
+	setRegister(0xBD, 0x00); // Disable rhythm
+
+	// reset FM voice instrument data
+	resetAdLibOperatorRegisters(0x20, 0);
+	resetAdLibOperatorRegisters(0x60, 0);
+	resetAdLibOperatorRegisters(0x80, 0);
+	resetAdLibFMVoiceChannelRegisters(0xA0, 0);
+	resetAdLibFMVoiceChannelRegisters(0xB0, 0);
+	resetAdLibFMVoiceChannelRegisters(0xC0, 0);
+	resetAdLibOperatorRegisters(0xE0, 0);
+	resetAdLibOperatorRegisters(0x40, 0x3F); // original driver sent 0x00
+
+	setRegister(0x01, 0x20); // enable waveform control on both operators
+	setRegister(0x04, 0x60); // Timer control
+
+	setRegister(0x08, 0);    // select FM music mode
+	setRegister(0xBD, 0x20); // Enable rhythm
+
+	// reset our percussion register
+	_percussionReg = 0x20;
+}
+
+void MidiDriver_Accolade_AdLib::resetAdLibOperatorRegisters(byte baseRegister, byte value) {
+	byte operatorIndex;
+
+	for (operatorIndex = 0; operatorIndex < 0x16; operatorIndex++) {
+		switch (operatorIndex) {
+		case 0x06:
+		case 0x07:
+		case 0x0E:
+		case 0x0F:
+			break;
+		default:
+			setRegister(baseRegister + operatorIndex, value);
+		}
+	}
+}
+
+void MidiDriver_Accolade_AdLib::resetAdLibFMVoiceChannelRegisters(byte baseRegister, byte value) {
+	byte FMvoiceChannel;
+
+	for (FMvoiceChannel = 0; FMvoiceChannel < AGOS_ADLIB_VOICES_COUNT; FMvoiceChannel++) {
+		setRegister(baseRegister + FMvoiceChannel, value);
+	}
+}
+
+// MIDI messages can be found at http://www.midi.org/techspecs/midimessages.php
+void MidiDriver_Accolade_AdLib::send(uint32 b) {
+	byte command = b & 0xf0;
+	byte channel = b & 0xf;
+	byte op1 = (b >> 8) & 0xff;
+	byte op2 = (b >> 16) & 0xff;
+
+	byte mappedChannel    = _channelMapping[channel];
+	byte mappedInstrument = 0;
+
+	// Ignore everything that is outside of our channel range
+	if (mappedChannel >= AGOS_ADLIB_VOICES_COUNT)
+		return;
+
+	switch (command) {
+	case 0x80:
+		noteOff(mappedChannel, op1, false);
+		break;
+	case 0x90:
+		// Convert noteOn with velocity 0 to a noteOff
+		if (op2 == 0)
+			return noteOff(mappedChannel, op1, false);
+
+		noteOn(mappedChannel, op1, op2);
+		break;
+	case 0xb0: // Control change
+		// Doesn't seem to be implemented
+		break;
+	case 0xc0: // Program Change
+		mappedInstrument = _instrumentMapping[op1];
+		programChange(mappedChannel, mappedInstrument, op1);
+		break;
+	case 0xa0: // Polyphonic key pressure (aftertouch)
+	case 0xd0: // Channel pressure (aftertouch)
+		// Aftertouch doesn't seem to be implemented
+		break;
+	case 0xe0:
+		// No pitch bend change
+		break;
+	case 0xf0: // SysEx
+		warning("ADLIB: SysEx: %x", b);
+		break;
+	default:
+		warning("ADLIB: Unknown event %02x", command);
+	}
+}
+
+void MidiDriver_Accolade_AdLib::setTimerCallback(void *timerParam, Common::TimerManager::TimerProc timerProc) {
+	_adlibTimerProc = timerProc;
+	_adlibTimerParam = timerParam;
+}
+
+void MidiDriver_Accolade_AdLib::noteOn(byte FMvoiceChannel, byte note, byte velocity) {
+	byte adjustedNote     = note;
+	byte adjustedVelocity = velocity;
+	byte regValueA0h      = 0;
+	byte regValueB0h      = 0;
+
+	// adjust velocity
+	int16 channelVolumeAdjust = _channels[FMvoiceChannel].volumeAdjust;
+	channelVolumeAdjust += adjustedVelocity;
+	channelVolumeAdjust = CLIP<int16>(channelVolumeAdjust, 0, 0x7F);
+
+	// TODO: adjust to global volume
+	// original drivers had a global volume variable, which was 0 for full volume, -64 for half volume
+	// and -128 for mute
+
+	adjustedVelocity = channelVolumeAdjust;
+
+	if (!_musicDrvMode) {
+		// INSTR.DAT
+		// force note-off
+		noteOff(FMvoiceChannel, note, true);
+
+	} else {
+		// MUSIC.DRV
+		if (FMvoiceChannel < AGOS_ADLIB_VOICES_PERCUSSION_START) {
+			// force note-off, but only for actual FM voice channels
+			noteOff(FMvoiceChannel, note, true);
+		}
+	}
+
+	if (FMvoiceChannel != 9) {
+		// regular FM voice
+
+		if (!_musicDrvMode) {
+			// INSTR.DAT: adjust key note
+			while (adjustedNote < 24)
+				adjustedNote += 12;
+			adjustedNote -= 12;
+		}
+
+	} else {
+		// percussion channel
+		// MUSIC.DRV variant didn't do this adjustment, it directly used a pointer
+		adjustedNote -= 36;
+		if (adjustedNote > 40) { // Security check
+			warning("ADLIB: bad percussion channel note");
+			return;
+		}
+
+		byte percussionChannel = percussionKeyNoteChannelTable[adjustedNote];
+		if (percussionChannel >= AGOS_ADLIB_VOICES_COUNT)
+			return; // INSTR.DAT variant checked for ">" instead of ">=", which seems to have been a bug
+
+		// Map the keynote accordingly
+		adjustedNote = _percussionKeyNoteMapping[adjustedNote];
+		// Now overwrite the FM voice channel
+		FMvoiceChannel = percussionChannel;
+	}
+
+	if (!_musicDrvMode) {
+		// INSTR.DAT
+
+		// Save this key note
+		_channels[FMvoiceChannel].currentNote = adjustedNote;
+
+		adjustedVelocity += 24;
+		if (adjustedVelocity > 120)
+			adjustedVelocity = 120;
+		adjustedVelocity = adjustedVelocity >> 1; // divide by 2
+
+	} else {
+		// MUSIC.DRV
+		adjustedVelocity = adjustedVelocity >> 1; // divide by 2
+	}
+
+	// Set volume of voice channel
+	noteOnSetVolume(FMvoiceChannel, 1, adjustedVelocity);
+	if (FMvoiceChannel <= AGOS_ADLIB_VOICES_PERCUSSION_START) {
+		// Set second operator for FM voices + first percussion
+		noteOnSetVolume(FMvoiceChannel, 2, adjustedVelocity);
+	}
+
+	if (FMvoiceChannel >= AGOS_ADLIB_VOICES_PERCUSSION_START) {
+		// Percussion
+		byte percussionIdx = FMvoiceChannel - AGOS_ADLIB_VOICES_PERCUSSION_START;
+
+		// Enable bit of the requested percussion type
+		assert(percussionIdx < AGOS_ADLIB_VOICES_PERCUSSION_COUNT);
+		_percussionReg |= percussionBits[percussionIdx];
+		setRegister(0xBD, _percussionReg);
+	}
+
+	if (FMvoiceChannel < AGOS_ADLIB_VOICES_PERCUSSION_CYMBAL) {
+		// FM voice, Base Drum, Snare Drum + Tom Tom
+		byte adlibNote = adjustedNote;
+		byte adlibOctave = 0;
+		byte adlibFrequencyIdx = 0;
+		uint16 adlibFrequency = 0;
+
+		if (!_musicDrvMode) {
+			// INSTR.DAT
+			if (adlibNote >= 0x60)
+				adlibNote = 0x5F;
+
+			adlibOctave = (adlibNote / 12) - 1;
+			adlibFrequencyIdx = adlibNote % 12;
+			adlibFrequency = frequencyLookUpTable[adlibFrequencyIdx];
+
+			if (adlibFrequency & 0x8000)
+				adlibOctave++;
+			if (adlibOctave & 0x80) {
+				adlibOctave++;
+				adlibFrequency = adlibFrequency >> 1;
+			}
+
+		} else {
+			// MUSIC.DRV variant
+			if (adlibNote >= 19)
+				adlibNote -= 19;
+
+			adlibOctave = (adlibNote / 12);
+			adlibFrequencyIdx = adlibNote % 12;
+			// additional code, that will lookup octave and do a multiplication with it
+			// noteOn however calls the frequency calculation in a way that it multiplies with 0
+			adlibFrequency = frequencyLookUpTableMusicDrv[adlibFrequencyIdx];
+		}
+
+		regValueA0h = adlibFrequency & 0xFF;
+		regValueB0h = ((adlibFrequency & 0x300) >> 8) | (adlibOctave << 2);
+		if (FMvoiceChannel < AGOS_ADLIB_VOICES_PERCUSSION_START) {
+			// set Key-On flag for regular FM voices, but not for percussion
+			regValueB0h |= 0x20;
+		}
+
+		setRegister(0xA0 + FMvoiceChannel, regValueA0h);
+		setRegister(0xB0 + FMvoiceChannel, regValueB0h);
+		_channels[FMvoiceChannel].currentA0hReg = regValueA0h;
+		_channels[FMvoiceChannel].currentB0hReg = regValueB0h;
+
+		if (_musicDrvMode) {
+			// MUSIC.DRV
+			if (FMvoiceChannel < AGOS_ADLIB_VOICES_MELODIC_COUNT) {
+				_channels[FMvoiceChannel].currentNote = adjustedNote;
+			}
+		}
+	}
+}
+
+// 100% the same for INSTR.DAT and MUSIC.DRV variants
+// except for a bug, that was introduced for MUSIC.DRV
+void MidiDriver_Accolade_AdLib::noteOnSetVolume(byte FMvoiceChannel, byte operatorNr, byte adjustedVelocity) {
+	byte operatorReg = 0;
+	byte regValue40h = 0;
+	const InstrumentEntry *curInstrument = NULL;
+
+	regValue40h = (63 - adjustedVelocity) & 0x3F;
+
+	if ((operatorNr == 1) && (FMvoiceChannel <= AGOS_ADLIB_VOICES_PERCUSSION_START)) {
+		// first operator of FM voice channels or first percussion channel
+		curInstrument = _channels[FMvoiceChannel].currentInstrumentPtr;
+		if (!(curInstrument->regC0 & 0x01)) { // check, if both operators produce sound
+			// only one does, instrument wants fixed volume
+			if (operatorNr == 1) {
+				regValue40h = curInstrument->reg40op1;
+			} else {
+				regValue40h = curInstrument->reg40op2;
+			}
+
+			// not sure, if we are supposed to implement these bugs, or not
+#if 0
+			if (!_musicDrvMode) {
+				// Table is 16 bytes instead of 18 bytes
+				if ((FMvoiceChannel == 7) || (FMvoiceChannel == 9)) {
+					regValue40h = 0;
+					warning("volume set bug (original)");
+				}
+			}
+			if (_musicDrvMode) {
+				// MUSIC.DRV variant has a bug, which will overwrite these registers
+				// for all operators above 11 / 0Bh, which means percussion will always
+				// get a value of 0 (the table holding those bytes was 12 bytes instead of 18
+				if (FMvoiceChannel >= AGOS_ADLIB_VOICES_PERCUSSION_START) {
+					regValue40h = 0;
+					warning("volume set bug (original)");
+				}
+			}
+#endif
+		}
+	}
+
+	if (operatorNr == 1) {
+		operatorReg = operator1Register[FMvoiceChannel];
+	} else {
+		operatorReg = operator2Register[FMvoiceChannel];
+	}
+	assert(operatorReg != 0xFF); // Security check
+	setRegister(0x40 + operatorReg, regValue40h);
+}
+
+void MidiDriver_Accolade_AdLib::noteOff(byte FMvoiceChannel, byte note, bool dontCheckNote) {
+	byte adjustedNote = note;
+	byte regValueB0h = 0;
+
+	if (FMvoiceChannel < AGOS_ADLIB_VOICES_PERCUSSION_START) {
+		// regular FM voice
+
+		if (!_musicDrvMode) {
+			// INSTR.DAT: adjust key note
+			while (adjustedNote < 24)
+				adjustedNote += 12;
+			adjustedNote -= 12;
+		}
+
+		if (!dontCheckNote) {
+			// check, if current note is also the current actually playing channel note
+			if (_channels[FMvoiceChannel].currentNote != adjustedNote)
+				return; // not the same -> ignore this note off command
+		}
+
+		regValueB0h = _channels[FMvoiceChannel].currentB0hReg & 0xDF; // Remove "key on" bit
+		setRegister(0xB0 + FMvoiceChannel, regValueB0h);
+
+	} else {
+		// percussion
+		adjustedNote -= 36;
+		if (adjustedNote > 40) { // Security check
+			warning("ADLIB: bad percussion channel note");
+			return;
+		}
+
+		byte percussionChannel = percussionKeyNoteChannelTable[adjustedNote];
+		if (percussionChannel > AGOS_ADLIB_VOICES_COUNT)
+			return;
+
+		byte percussionIdx = percussionChannel - AGOS_ADLIB_VOICES_PERCUSSION_START;
+
+		// Disable bit of the requested percussion type
+		assert(percussionIdx < AGOS_ADLIB_VOICES_PERCUSSION_COUNT);
+		_percussionReg &= ~percussionBits[percussionIdx];
+		setRegister(0xBD, _percussionReg);
+	}
+}
+
+void MidiDriver_Accolade_AdLib::programChange(byte FMvoiceChannel, byte mappedInstrumentNr, byte MIDIinstrumentNr) {
+	if (mappedInstrumentNr >= _instrumentCount) {
+		warning("ADLIB: tried to set non-existent instrument");
+		return; // out of range
+	}
+
+	// setup instrument
+	//warning("ADLIB: program change for FM voice channel %d, instrument id %d", FMvoiceChannel, mappedInstrumentNr);
+
+	if (FMvoiceChannel < AGOS_ADLIB_VOICES_PERCUSSION_START) {
+		// Regular FM voice
+		programChangeSetInstrument(FMvoiceChannel, mappedInstrumentNr, MIDIinstrumentNr);
+
+	} else {
+		// Percussion
+		// set default instrument (again)
+		byte percussionInstrumentNr = 0;
+		const InstrumentEntry *instrumentPtr;
+
+		if (!_musicDrvMode) {
+			// INSTR.DAT: percussion default instruments start at instrument 1
+			percussionInstrumentNr = FMvoiceChannel - AGOS_ADLIB_VOICES_PERCUSSION_START + 1;
+		} else {
+			// MUSIC.DRV: percussion default instruments start at instrument 0x80
+			percussionInstrumentNr = FMvoiceChannel - AGOS_ADLIB_VOICES_PERCUSSION_START + 0x80;
+		}
+		if (percussionInstrumentNr >= _instrumentCount) {
+			warning("ADLIB: tried to set non-existent instrument");
+			return;
+		}
+		instrumentPtr = &_instrumentTable[percussionInstrumentNr];
+		_channels[FMvoiceChannel].currentInstrumentPtr = instrumentPtr;
+		_channels[FMvoiceChannel].volumeAdjust         = _instrumentVolumeAdjust[percussionInstrumentNr];
+	}
+}
+
+void MidiDriver_Accolade_AdLib::programChangeSetInstrument(byte FMvoiceChannel, byte mappedInstrumentNr, byte MIDIinstrumentNr) {
+	const InstrumentEntry *instrumentPtr;
+	byte op1Reg = 0;
+	byte op2Reg = 0;
+
+	if (mappedInstrumentNr >= _instrumentCount) {
+		warning("ADLIB: tried to set non-existent instrument");
+		return; // out of range
+	}
+
+	// setup instrument
+	instrumentPtr = &_instrumentTable[mappedInstrumentNr];
+	//warning("set instrument for FM voice channel %d, instrument id %d", FMvoiceChannel, mappedInstrumentNr);
+
+	op1Reg = operator1Register[FMvoiceChannel];
+	op2Reg = operator2Register[FMvoiceChannel];
+
+	setRegister(0x20 + op1Reg, instrumentPtr->reg20op1);
+	setRegister(0x40 + op1Reg, instrumentPtr->reg40op1);
+	setRegister(0x60 + op1Reg, instrumentPtr->reg60op1);
+	setRegister(0x80 + op1Reg, instrumentPtr->reg80op1);
+
+	if (FMvoiceChannel <= AGOS_ADLIB_VOICES_PERCUSSION_START) {
+		// set 2nd operator as well for FM voices and first percussion voice
+		setRegister(0x20 + op2Reg, instrumentPtr->reg20op2);
+		setRegister(0x40 + op2Reg, instrumentPtr->reg40op2);
+		setRegister(0x60 + op2Reg, instrumentPtr->reg60op2);
+		setRegister(0x80 + op2Reg, instrumentPtr->reg80op2);
+
+		if (!_musicDrvMode) {
+			// set Feedback / Algorithm as well
+			setRegister(0xC0 + FMvoiceChannel, instrumentPtr->regC0);
+		} else {
+			if (FMvoiceChannel < AGOS_ADLIB_VOICES_PERCUSSION_START) {
+				// set Feedback / Algorithm as well for regular FM voices only
+				setRegister(0xC0 + FMvoiceChannel, instrumentPtr->regC0);
+			}
+		}
+	}
+
+	// Remember instrument
+	_channels[FMvoiceChannel].currentInstrumentPtr = instrumentPtr;
+	_channels[FMvoiceChannel].volumeAdjust         = _instrumentVolumeAdjust[MIDIinstrumentNr];
+}
+
+void MidiDriver_Accolade_AdLib::setRegister(int reg, int value) {
+	_opl->writeReg(reg, value);
+	//warning("OPL %x %x (%d)", reg, value, value);
+}
+
+uint32 MidiDriver_Accolade_AdLib::property(int prop, uint32 param) {
+	return 0;
+}
+
+// Called right at the start, we get an INSTR.DAT entry
+bool MidiDriver_Accolade_AdLib::setupInstruments(byte *driverData, uint16 driverDataSize, bool useMusicDrvFile) {
+	uint16 channelMappingOffset         = 0;
+	uint16 channelMappingSize           = 0;
+	uint16 instrumentMappingOffset      = 0;
+	uint16 instrumentMappingSize        = 0;
+	uint16 instrumentVolumeAdjustOffset = 0;
+	uint16 instrumentVolumeAdjustSize   = 0;
+	uint16 keyNoteMappingOffset         = 0;
+	uint16 keyNoteMappingSize           = 0;
+	uint16 instrumentCount              = 0;
+	uint16 instrumentDataOffset         = 0;
+	uint16 instrumentDataSize           = 0;
+	uint16 instrumentEntrySize          = 0;
+
+	if (!useMusicDrvFile) {
+		// INSTR.DAT: we expect at least 354 bytes
+		if (driverDataSize < 354)
+			return false;
+
+		// Data is like this:
+		// 128 bytes  instrument mapping
+		// 128 bytes  instrument volume adjust (signed!)
+		//  16 bytes  unknown
+		//  16 bytes  channel mapping
+		//  64 bytes  key note mapping (not used for MT32)
+		//   1 byte   instrument count
+		//   1 byte   bytes per instrument
+		//   x bytes  no instruments used for MT32
+
+		channelMappingOffset         = 256 + 16;
+		channelMappingSize           = 16;
+		instrumentMappingOffset      = 0;
+		instrumentMappingSize        = 128;
+		instrumentVolumeAdjustOffset = 128;
+		instrumentVolumeAdjustSize   = 128;
+		keyNoteMappingOffset         = 256 + 16 + 16;
+		keyNoteMappingSize           = 64;
+
+		byte instrDatInstrumentCount    = driverData[256 + 16 + 16 + 64];
+		byte instrDatBytesPerInstrument = driverData[256 + 16 + 16 + 64 + 1];
+
+		// We expect 9 bytes per instrument
+		if (instrDatBytesPerInstrument != 9)
+			return false;
+		// And we also expect at least one adlib instrument
+		if (!instrDatInstrumentCount)
+			return false;
+
+		instrumentCount      = instrDatInstrumentCount;
+		instrumentDataOffset = 256 + 16 + 16 + 64 + 2;
+		instrumentDataSize   = instrDatBytesPerInstrument * instrDatInstrumentCount;
+		instrumentEntrySize  = instrDatBytesPerInstrument;
+
+	} else {
+		// MUSIC.DRV: we expect at least 468 bytes
+		if (driverDataSize < 468)
+			return false;
+
+		// music.drv is basically a driver, but with a few fixed locations for certain data
+
+		channelMappingOffset         = 396;
+		channelMappingSize           = 16;
+		instrumentMappingOffset      = 140;
+		instrumentMappingSize        = 128;
+		instrumentVolumeAdjustOffset = 140 + 128;
+		instrumentVolumeAdjustSize   = 128;
+		keyNoteMappingOffset         = 376 + 36; // adjust by 36, because we adjust keyNote before mapping (see noteOn)
+		keyNoteMappingSize           = 64;
+
+		// seems to have used 128 + 5 instruments
+		// 128 regular ones and an additional 5 for percussion
+		instrumentCount         = 128 + AGOS_ADLIB_EXTRA_INSTRUMENT_COUNT;
+		instrumentDataOffset    = 722;
+		instrumentEntrySize     = 9;
+		instrumentDataSize      = instrumentCount * instrumentEntrySize;
+	}
+
+	// Channel mapping
+	if (channelMappingSize) {
+		// Get these 16 bytes for MIDI channel mapping
+		if (channelMappingSize != sizeof(_channelMapping))
+			return false;
+
+		memcpy(_channelMapping, driverData + channelMappingOffset, sizeof(_channelMapping));
+	} else {
+		// Set up straight mapping
+		for (uint16 channelNr = 0; channelNr < sizeof(_channelMapping); channelNr++) {
+			_channelMapping[channelNr] = channelNr;
+		}
+	}
+
+	if (instrumentMappingSize) {
+		// And these for instrument mapping
+		if (instrumentMappingSize > sizeof(_instrumentMapping))
+			return false;
+
+		memcpy(_instrumentMapping, driverData + instrumentMappingOffset, instrumentMappingSize);
+	}
+	// Set up straight mapping for the remaining data
+	for (uint16 instrumentNr = instrumentMappingSize; instrumentNr < sizeof(_instrumentMapping); instrumentNr++) {
+		_instrumentMapping[instrumentNr] = instrumentNr;
+	}
+
+	if (instrumentVolumeAdjustSize) {
+		if (instrumentVolumeAdjustSize != sizeof(_instrumentVolumeAdjust))
+			return false;
+
+		memcpy(_instrumentVolumeAdjust, driverData + instrumentVolumeAdjustOffset, instrumentVolumeAdjustSize);
+	}
+
+	// Get key note mapping, if available
+	if (keyNoteMappingSize) {
+		if (keyNoteMappingSize != sizeof(_percussionKeyNoteMapping))
+			return false;
+
+		memcpy(_percussionKeyNoteMapping, driverData + keyNoteMappingOffset, keyNoteMappingSize);
+	}
+
+	// Check, if there are enough bytes left to hold all instrument data
+	if (driverDataSize < (instrumentDataOffset + instrumentDataSize))
+		return false;
+
+	// We release previous instrument data, just in case
+	if (_instrumentTable)
+		delete[] _instrumentTable;
+
+	_instrumentTable = new InstrumentEntry[instrumentCount];
+	_instrumentCount = instrumentCount;
+
+	byte            *instrDATReadPtr    = driverData + instrumentDataOffset;
+	InstrumentEntry *instrumentWritePtr = _instrumentTable;
+
+	for (uint16 instrumentNr = 0; instrumentNr < _instrumentCount; instrumentNr++) {
+		memcpy(instrumentWritePtr, instrDATReadPtr, sizeof(InstrumentEntry));
+		instrDATReadPtr += instrumentEntrySize;
+		instrumentWritePtr++;
+	}
+
+	// Enable MUSIC.DRV-Mode (slightly different behaviour)
+	if (useMusicDrvFile)
+		_musicDrvMode = true;
+
+	if (_musicDrvMode) {
+		// Extra code for MUSIC.DRV
+
+		// This was done during "programChange" in the original driver
+		instrumentWritePtr = _instrumentTable;
+		for (uint16 instrumentNr = 0; instrumentNr < _instrumentCount; instrumentNr++) {
+			instrumentWritePtr->reg80op1 |= 0x03; // set release rate
+			instrumentWritePtr->reg80op2 |= 0x03;
+			instrumentWritePtr++;
+		}
+	}
+	return true;
+}
+
+MidiDriver *MidiDriver_Accolade_AdLib_create(Common::String driverFilename) {
+	byte  *driverData = NULL;
+	uint16 driverDataSize = 0;
+	bool   isMusicDrvFile = false;
+
+	MidiDriver_Accolade_readDriver(driverFilename, MT_ADLIB, driverData, driverDataSize, isMusicDrvFile);
+	if (!driverData)
+		error("ACCOLADE-ADLIB: error during readDriver()");
+
+	MidiDriver_Accolade_AdLib *driver = new MidiDriver_Accolade_AdLib();
+	if (driver) {
+		if (!driver->setupInstruments(driverData, driverDataSize, isMusicDrvFile)) {
+			delete driver;
+			driver = nullptr;
+		}
+	}
+
+	delete[] driverData;
+	return driver;
+}
+
+} // End of namespace AGOS
diff --git a/engines/agos/drivers/accolade/driverfile.cpp b/engines/agos/drivers/accolade/driverfile.cpp
new file mode 100644
index 0000000000..4ff2fd550f
--- /dev/null
+++ b/engines/agos/drivers/accolade/driverfile.cpp
@@ -0,0 +1,166 @@
+/* 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 "agos/agos.h"
+#include "audio/mididrv.h"
+#include "common/error.h"
+#include "common/file.h"
+
+namespace AGOS {
+
+// this reads and gets Accolade driver data
+// we need it for channel mapping, instrument mapping and other things
+// this driver data chunk gets passed to the actual music driver (MT32 / AdLib)
+void MidiDriver_Accolade_readDriver(Common::String filename, MusicType requestedDriverType, byte *&driverData, uint16 &driverDataSize, bool &isMusicDrvFile) {
+	Common::File *driverStream = new Common::File();
+
+	isMusicDrvFile = false;
+
+	if (!driverStream->open(filename)) {
+		error("%s: unable to open file", filename.c_str());
+	}
+
+	if (filename == "INSTR.DAT") {
+		// INSTR.DAT: used by Elvira 1
+		uint32 streamSize = driverStream->size();
+		uint32 streamLeft = streamSize;
+		uint16 skipChunks = 0; // 1 for MT32, 0 for AdLib
+		uint16 chunkSize  = 0;
+
+		switch (requestedDriverType) {
+		case MT_ADLIB:
+			skipChunks = 0;
+			break;
+		case MT_MT32:
+			skipChunks = 1; // Skip one entry for MT32
+			break;
+		default:
+			assert(0);
+			break;
+		}
+
+		do {
+			if (streamLeft < 2)
+				error("%s: unexpected EOF", filename.c_str());
+
+			chunkSize = driverStream->readUint16LE();
+			streamLeft -= 2;
+
+			if (streamLeft < chunkSize)
+				error("%s: unexpected EOF", filename.c_str());
+
+			if (skipChunks) {
+				// Skip the chunk
+				driverStream->skip(chunkSize);
+				streamLeft -= chunkSize;
+
+				skipChunks--;
+			}
+		} while (skipChunks);
+
+		// Seek over the ASCII string until there is a NUL terminator
+		byte curByte = 0;
+
+		do {
+			if (chunkSize == 0)
+				error("%s: no actual instrument data found", filename.c_str());
+
+			curByte = driverStream->readByte();
+			chunkSize--;
+		} while (curByte);
+
+		driverDataSize = chunkSize;
+
+		// Read the requested instrument data entry
+		driverData = new byte[driverDataSize];
+		driverStream->read(driverData, driverDataSize);
+
+	} else if (filename == "MUSIC.DRV") {
+		// MUSIC.DRV / used by Elvira 2 / Waxworks / Simon 1 demo
+		uint32 streamSize = driverStream->size();
+		uint32 streamLeft = streamSize;
+		uint16 getChunk   = 0; // 4 for MT32, 2 for AdLib
+
+		switch (requestedDriverType) {
+		case MT_ADLIB:
+			getChunk = 2;
+			break;
+		case MT_MT32:
+			getChunk = 4;
+			break;
+		default:
+			assert(0);
+			break;
+		}
+
+		if (streamLeft < 2)
+			error("%s: unexpected EOF", filename.c_str());
+
+		uint16 chunkCount = driverStream->readUint16LE();
+		streamLeft -= 2;
+
+		if (getChunk >= chunkCount)
+			error("%s: required chunk not available", filename.c_str());
+
+		uint16 headerOffset = 2 + (28 * getChunk);
+		streamLeft -= (28 * getChunk);
+
+		if (streamLeft < 28)
+			error("%s: unexpected EOF", filename.c_str());
+
+		// Seek to required chunk
+		driverStream->seek(headerOffset);
+		driverStream->skip(20); // skip over name
+		streamLeft -= 20;
+
+		uint16 musicDrvSignature = driverStream->readUint16LE();
+		uint16 musicDrvType = driverStream->readUint16LE();
+		uint16 chunkOffset = driverStream->readUint16LE();
+		uint16 chunkSize   = driverStream->readUint16LE();
+
+		// Security checks
+		if (musicDrvSignature != 0xFEDC)
+			error("%s: chunk signature mismatch", filename.c_str());
+		if (musicDrvType != 1)
+			error("%s: not a music driver", filename.c_str());
+		if (chunkOffset >= streamSize)
+			error("%s: driver chunk points outside of file", filename.c_str());
+
+		streamLeft = streamSize - chunkOffset;
+		if (streamLeft < chunkSize)
+			error("%s: driver chunk is larger than file", filename.c_str());
+
+		driverDataSize = chunkSize;
+
+		// Read the requested instrument data entry
+		driverData = new byte[driverDataSize];
+
+		driverStream->seek(chunkOffset);
+		driverStream->read(driverData, driverDataSize);
+		isMusicDrvFile = true;
+	}
+
+	driverStream->close();
+	delete driverStream;
+}
+
+} // End of namespace AGOS
diff --git a/engines/agos/drivers/accolade/mididriver.h b/engines/agos/drivers/accolade/mididriver.h
new file mode 100644
index 0000000000..253fb6b736
--- /dev/null
+++ b/engines/agos/drivers/accolade/mididriver.h
@@ -0,0 +1,44 @@
+/* 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 AGOS_DRIVERS_ACCOLADE_MIDIDRIVER_H
+#define AGOS_DRIVERS_ACCOLADE_MIDIDRIVER_H
+
+#include "agos/agos.h"
+#include "audio/mididrv.h"
+#include "common/error.h"
+
+namespace AGOS {
+
+#define AGOS_MIDI_CHANNEL_COUNT 16
+#define AGOS_MIDI_INSTRUMENT_COUNT 128
+
+#define AGOS_MIDI_KEYNOTE_COUNT 64
+
+extern void MidiDriver_Accolade_readDriver(Common::String filename, MusicType requestedDriverType, byte *&driverData, uint16 &driverDataSize, bool &isMusicDrvFile);
+
+extern MidiDriver *MidiDriver_Accolade_AdLib_create(Common::String driverFilename);
+extern MidiDriver *MidiDriver_Accolade_MT32_create(Common::String driverFilename);
+
+} // End of namespace AGOS
+
+#endif // AGOS_DRIVERS_ACCOLADE_MIDIDRIVER_H
diff --git a/engines/agos/drivers/accolade/mt32.cpp b/engines/agos/drivers/accolade/mt32.cpp
new file mode 100644
index 0000000000..319e0ebf56
--- /dev/null
+++ b/engines/agos/drivers/accolade/mt32.cpp
@@ -0,0 +1,278 @@
+/* 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 "agos/agos.h"
+#include "agos/drivers/accolade/mididriver.h"
+
+#include "audio/mididrv.h"
+
+#include "common/config-manager.h"
+#include "common/file.h"
+#include "common/mutex.h"
+#include "common/system.h"
+#include "common/textconsole.h"
+
+namespace AGOS {
+
+class MidiDriver_Accolade_MT32 : public MidiDriver {
+public:
+	MidiDriver_Accolade_MT32();
+	virtual ~MidiDriver_Accolade_MT32();
+
+	// MidiDriver
+	int open();
+	void close();
+	bool isOpen() const { return _isOpen; }
+
+	void send(uint32 b);
+
+	MidiChannel *allocateChannel() {
+		if (_driver)
+			return _driver->allocateChannel();
+		return NULL;
+	}
+	MidiChannel *getPercussionChannel() {
+		if (_driver)
+			return _driver->getPercussionChannel();
+		return NULL;
+	}
+
+	void setTimerCallback(void *timer_param, Common::TimerManager::TimerProc timer_proc) {
+		if (_driver)
+			_driver->setTimerCallback(timer_param, timer_proc);
+	}
+
+	uint32 getBaseTempo() {
+		if (_driver) {
+			return _driver->getBaseTempo();
+		}
+		return 1000000 / _baseFreq;
+	}
+
+protected:
+	Common::Mutex _mutex;
+	MidiDriver *_driver;
+	bool _nativeMT32; // native MT32, may also be our MUNT, or MUNT over MIDI
+
+	bool _isOpen;
+	int _baseFreq;
+
+private:
+	// simple mapping between MIDI channel and MT32 channel
+	byte _channelMapping[AGOS_MIDI_CHANNEL_COUNT];
+	// simple mapping between MIDI instruments and MT32 instruments
+	byte _instrumentMapping[AGOS_MIDI_INSTRUMENT_COUNT];
+
+public:
+	bool setupInstruments(byte *instrumentData, uint16 instrumentDataSize, bool useMusicDrvFile);
+};
+
+MidiDriver_Accolade_MT32::MidiDriver_Accolade_MT32() {
+	_driver = NULL;
+	_isOpen = false;
+	_nativeMT32 = false;
+	_baseFreq = 250;
+
+	memset(_channelMapping, 0, sizeof(_channelMapping));
+	memset(_instrumentMapping, 0, sizeof(_instrumentMapping));
+}
+
+MidiDriver_Accolade_MT32::~MidiDriver_Accolade_MT32() {
+	Common::StackLock lock(_mutex);
+	if (_driver) {
+		_driver->setTimerCallback(0, 0);
+		_driver->close();
+		delete _driver;
+	}
+	_driver = NULL;
+}
+
+int MidiDriver_Accolade_MT32::open() {
+	assert(!_driver);
+
+//	debugC(kDebugLevelMT32Driver, "MT32: starting driver");
+
+	// Setup midi driver
+	MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_PREFER_MT32);
+	MusicType musicType = MidiDriver::getMusicType(dev);
+
+	// check, if we got a real MT32 (or MUNT, or MUNT over MIDI)
+	switch (musicType) {
+	case MT_MT32:
+		_nativeMT32 = true;
+		break;
+	case MT_GM:
+		if (ConfMan.getBool("native_mt32")) {
+			_nativeMT32 = true;
+		}
+		break;
+	default:
+		break;
+	}
+
+	_driver = MidiDriver::createMidi(dev);
+	if (!_driver)
+		return 255;
+
+	int ret = _driver->open();
+	if (ret)
+		return ret;
+
+	if (_nativeMT32)
+		_driver->sendMT32Reset();
+	else
+		_driver->sendGMReset();
+
+	return 0;
+}
+
+void MidiDriver_Accolade_MT32::close() {
+	if (_driver) {
+		_driver->close();
+	}
+}
+
+// MIDI messages can be found at http://www.midi.org/techspecs/midimessages.php
+void MidiDriver_Accolade_MT32::send(uint32 b) {
+	byte command = b & 0xf0;
+	byte channel = b & 0xf;
+
+	if (command == 0xF0) {
+		if (_driver) {
+			_driver->send(b);
+		}
+		return;
+	}
+
+	byte mappedChannel = _channelMapping[channel];
+
+	if (mappedChannel < AGOS_MIDI_CHANNEL_COUNT) {
+		// channel mapped to an actual MIDI channel, so use that one
+		b = (b & 0xFFFFFFF0) | mappedChannel;
+		if (command == 0xC0) {
+			// Program change
+			// Figure out the requested instrument
+			byte midiInstrument = (b >> 8) & 0xFF;
+			byte mappedInstrument = _instrumentMapping[midiInstrument];
+
+			// If there is no actual MT32 (or MUNT), we make a second mapping to General MIDI instruments
+			if (!_nativeMT32) {
+				mappedInstrument = (MidiDriver::_mt32ToGm[mappedInstrument]);
+			}
+			// And replace it
+			b = (b & 0xFFFF00FF) | (mappedInstrument << 8);
+		}
+
+		if (_driver) {
+			_driver->send(b);
+		}
+	}
+}
+
+// Called right at the start, we get an INSTR.DAT entry
+bool MidiDriver_Accolade_MT32::setupInstruments(byte *driverData, uint16 driverDataSize, bool useMusicDrvFile) {
+	uint16 channelMappingOffset = 0;
+	uint16 channelMappingSize = 0;
+	uint16 instrumentMappingOffset = 0;
+	uint16 instrumentMappingSize = 0;
+
+	if (!useMusicDrvFile) {
+		// INSTR.DAT: we expect at least 354 bytes
+		if (driverDataSize < 354)
+			return false;
+
+		// Data is like this:
+		// 128 bytes  instrument mapping
+		// 128 bytes  instrument volume adjust (signed!) (not used for MT32)
+		//  16 bytes  unknown
+		//  16 bytes  channel mapping
+		//  64 bytes  key note mapping (not really used for MT32)
+		//   1 byte   instrument count
+		//   1 byte   bytes per instrument
+		//   x bytes  no instruments used for MT32
+
+		channelMappingOffset    = 256 + 16;
+		channelMappingSize      = 16;
+		instrumentMappingOffset = 0;
+		instrumentMappingSize   = 128;
+
+	} else {
+		// MUSIC.DRV: we expect at least 468 bytes
+		if (driverDataSize < 468)
+			return false;
+
+		channelMappingOffset    = 396;
+		channelMappingSize      = 16;
+		instrumentMappingOffset = 140;
+		instrumentMappingSize   = 128;
+	}
+
+	// Channel mapping
+	if (channelMappingSize) {
+		// Get these 16 bytes for MIDI channel mapping
+		if (channelMappingSize != sizeof(_channelMapping))
+			return false;
+
+		memcpy(_channelMapping, driverData + channelMappingOffset, sizeof(_channelMapping));
+	} else {
+		// Set up straight mapping
+		for (uint16 channelNr = 0; channelNr < sizeof(_channelMapping); channelNr++) {
+			_channelMapping[channelNr] = channelNr;
+		}
+	}
+
+	if (instrumentMappingSize) {
+		// And these for instrument mapping
+		if (instrumentMappingSize > sizeof(_instrumentMapping))
+			return false;
+
+		memcpy(_instrumentMapping, driverData + instrumentMappingOffset, instrumentMappingSize);
+	}
+	// Set up straight mapping for the remaining data
+	for (uint16 instrumentNr = instrumentMappingSize; instrumentNr < sizeof(_instrumentMapping); instrumentNr++) {
+		_instrumentMapping[instrumentNr] = instrumentNr;
+	}
+	return true;
+}
+
+MidiDriver *MidiDriver_Accolade_MT32_create(Common::String driverFilename) {
+	byte  *driverData = NULL;
+	uint16 driverDataSize = 0;
+	bool   isMusicDrvFile = false;
+
+	MidiDriver_Accolade_readDriver(driverFilename, MT_MT32, driverData, driverDataSize, isMusicDrvFile);
+	if (!driverData)
+		error("ACCOLADE-ADLIB: error during readDriver()");
+
+	MidiDriver_Accolade_MT32 *driver = new MidiDriver_Accolade_MT32();
+	if (driver) {
+		if (!driver->setupInstruments(driverData, driverDataSize, isMusicDrvFile)) {
+			delete driver;
+			driver = nullptr;
+		}
+	}
+
+	delete[] driverData;
+	return driver;
+}
+
+} // End of namespace AGOS
diff --git a/engines/agos/drivers/simon1/adlib.cpp b/engines/agos/drivers/simon1/adlib.cpp
new file mode 100644
index 0000000000..7f1370e8bd
--- /dev/null
+++ b/engines/agos/drivers/simon1/adlib.cpp
@@ -0,0 +1,516 @@
+/* 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 "agos/drivers/simon1/adlib.h"
+
+#include "common/textconsole.h"
+#include "common/util.h"
+#include "common/file.h"
+
+namespace AGOS {
+
+enum {
+	kChannelUnused       = 0xFF,
+	kChannelOrphanedFlag = 0x80,
+
+	kOPLVoicesCount = 9
+};
+
+MidiDriver_Simon1_AdLib::Voice::Voice()
+    : channel(kChannelUnused), note(0), instrTotalLevel(0), instrScalingLevel(0), frequency(0) {
+}
+
+MidiDriver_Simon1_AdLib::MidiDriver_Simon1_AdLib(const byte *instrumentData)
+    : _isOpen(false), _opl(nullptr), _timerProc(nullptr), _timerParam(nullptr),
+      _melodyVoices(0), _amvdrBits(0), _rhythmEnabled(false), _voices(), _midiPrograms(),
+      _instruments(instrumentData) {
+}
+
+MidiDriver_Simon1_AdLib::~MidiDriver_Simon1_AdLib() {
+	close();
+	delete[] _instruments;
+}
+
+int MidiDriver_Simon1_AdLib::open() {
+	if (_isOpen) {
+		return MERR_ALREADY_OPEN;
+	}
+
+	_opl = OPL::Config::create();
+	if (!_opl) {
+		return MERR_DEVICE_NOT_AVAILABLE;
+	}
+
+	if (!_opl->init()) {
+		delete _opl;
+		_opl = nullptr;
+
+		return MERR_CANNOT_CONNECT;
+	}
+
+	_opl->start(new Common::Functor0Mem<void, MidiDriver_Simon1_AdLib>(this, &MidiDriver_Simon1_AdLib::onTimer));
+
+	_opl->writeReg(0x01, 0x20);
+	_opl->writeReg(0x08, 0x40);
+	_opl->writeReg(0xBD, 0xC0);
+	reset();
+
+	_isOpen = true;
+	return 0;
+}
+
+bool MidiDriver_Simon1_AdLib::isOpen() const {
+	return _isOpen;
+}
+
+void MidiDriver_Simon1_AdLib::close() {
+	setTimerCallback(nullptr, nullptr);
+
+	if (_isOpen) {
+		_opl->stop();
+		delete _opl;
+		_opl = nullptr;
+
+		_isOpen = false;
+	}
+}
+
+void MidiDriver_Simon1_AdLib::send(uint32 b) {
+	int channel = b & 0x0F;
+	int command = b & 0xF0;
+	int param1  = (b >>  8) & 0xFF;
+	int param2  = (b >> 16) & 0xFF;
+
+	// The percussion channel is handled specially. The AdLib output uses
+	// channels 11 to 15 for percussions. For this, the original converted
+	// note on on the percussion channel to note on channels 11 to 15 before
+	// giving it to the AdLib output. We do this in here for simplicity.
+	if (command == 0x90 && channel == 9) {
+		param1 -= 36;
+		if (param1 < 0 || param1 >= ARRAYSIZE(_rhythmMap)) {
+			return;
+		}
+
+		channel = _rhythmMap[param1].channel;
+		MidiDriver::send(0xC0 | channel, _rhythmMap[param1].program, 0);
+
+		param1 = _rhythmMap[param1].note;
+		MidiDriver::send(0x80 | channel, param1, param2);
+
+		param2 >>= 1;
+	}
+
+	switch (command) {
+	case 0x80: // note OFF
+		noteOff(channel, param1);
+		break;
+
+	case 0x90: // note ON
+		if (param2 == 0) {
+			noteOff(channel, param1);
+		} else {
+			noteOn(channel, param1, param2);
+		}
+		break;
+
+	case 0xB0: // control change
+		controlChange(channel, param1, param2);
+		break;
+
+	case 0xC0: // program change
+		programChange(channel, param1);
+		break;
+
+	default:
+		break;
+	}
+}
+
+void MidiDriver_Simon1_AdLib::setTimerCallback(void *timer_param, Common::TimerManager::TimerProc timer_proc) {
+	_timerParam = timer_param;
+	_timerProc = timer_proc;
+}
+
+uint32 MidiDriver_Simon1_AdLib::getBaseTempo() {
+	return 1000000 / OPL::OPL::kDefaultCallbackFrequency;
+}
+
+void MidiDriver_Simon1_AdLib::onTimer() {
+	if (_timerProc) {
+		(*_timerProc)(_timerParam);
+	}
+}
+
+void MidiDriver_Simon1_AdLib::reset() {
+	resetOPLVoices();
+	resetRhythm();
+	for (int i = 0; i < kNumberOfVoices; ++i) {
+		_voices[i].channel = kChannelUnused;
+	}
+	resetVoices();
+}
+
+void MidiDriver_Simon1_AdLib::resetOPLVoices() {
+	_amvdrBits &= 0xE0;
+	_opl->writeReg(0xBD, _amvdrBits);
+	for (int i = 8; i >= 0; --i) {
+		_opl->writeReg(0xB0 + i, 0);
+	}
+}
+
+void MidiDriver_Simon1_AdLib::resetRhythm() {
+	_melodyVoices = 9;
+	_amvdrBits = 0xC0;
+	_opl->writeReg(0xBD, _amvdrBits);
+}
+
+void MidiDriver_Simon1_AdLib::resetVoices() {
+	memset(_midiPrograms, 0, sizeof(_midiPrograms));
+	for (int i = 0; i < kNumberOfVoices; ++i) {
+		_voices[i].channel = kChannelUnused;
+	}
+
+	for (int i = 0; i < kOPLVoicesCount; ++i) {
+		resetRhythm();
+		_opl->writeReg(0x08, 0x00);
+
+		int oplRegister = _operatorMap[i];
+		for (int j = 0; j < 4; ++j) {
+			oplRegister += 0x20;
+
+			_opl->writeReg(oplRegister + 0, _operatorDefaults[2 * j + 0]);
+			_opl->writeReg(oplRegister + 3, _operatorDefaults[2 * j + 1]);
+		}
+
+		_opl->writeReg(oplRegister + 0x60, 0x00);
+		_opl->writeReg(oplRegister + 0x63, 0x00);
+
+		// This seems to be serious bug but the original does it the same way.
+		_opl->writeReg(_operatorMap[i] + i, 0x08);
+	}
+}
+
+int MidiDriver_Simon1_AdLib::allocateVoice(uint channel) {
+	for (int i = 0; i < _melodyVoices; ++i) {
+		if (_voices[i].channel == (channel | kChannelOrphanedFlag)) {
+			return i;
+		}
+	}
+
+	for (int i = 0; i < _melodyVoices; ++i) {
+		if (_voices[i].channel == kChannelUnused) {
+			return i;
+		}
+	}
+
+	for (int i = 0; i < _melodyVoices; ++i) {
+		if (_voices[i].channel > 0x7F) {
+			return i;
+		}
+	}
+
+	// The original had some logic for a priority based reuse of channels.
+	// However, the priority value is always 0, which causes the first channel
+	// to be picked all the time.
+	const int voice = 0;
+	_opl->writeReg(0xA0 + voice, (_voices[voice].frequency     ) & 0xFF);
+	_opl->writeReg(0xB0 + voice, (_voices[voice].frequency >> 8) & 0xFF);
+	return voice;
+}
+
+void MidiDriver_Simon1_AdLib::noteOff(uint channel, uint note) {
+	if (_melodyVoices <= 6 && channel >= 11) {
+		_amvdrBits &= ~(_rhythmInstrumentMask[channel - 11]);
+		_opl->writeReg(0xBD, _amvdrBits);
+	} else {
+		for (int i = 0; i < _melodyVoices; ++i) {
+			if (_voices[i].note == note && _voices[i].channel == channel) {
+				_voices[i].channel |= kChannelOrphanedFlag;
+				_opl->writeReg(0xA0 + i, (_voices[i].frequency     ) & 0xFF);
+				_opl->writeReg(0xB0 + i, (_voices[i].frequency >> 8) & 0xFF);
+				return;
+			}
+		}
+	}
+}
+
+void MidiDriver_Simon1_AdLib::noteOn(uint channel, uint note, uint velocity) {
+	if (_rhythmEnabled && channel >= 11) {
+		noteOnRhythm(channel, note, velocity);
+		return;
+	}
+
+	const int voiceNum = allocateVoice(channel);
+	Voice &voice = _voices[voiceNum];
+
+	if ((voice.channel & 0x7F) != channel) {
+		setupInstrument(voiceNum, _midiPrograms[channel]);
+	}
+	voice.channel = channel;
+
+	_opl->writeReg(0x43 + _operatorMap[voiceNum], (0x3F - (((velocity | 0x80) * voice.instrTotalLevel) >> 8)) | voice.instrScalingLevel);
+
+	voice.note = note;
+	if (note >= 0x80) {
+		note = 0;
+	}
+
+	const int frequencyAndOctave = _frequencyIndexAndOctaveTable[note];
+	const uint frequency = _frequencyTable[frequencyAndOctave & 0x0F];
+
+	uint highByte = ((frequency & 0xFF00) >> 8) | ((frequencyAndOctave & 0x70) >> 2);
+	uint lowByte  = frequency & 0x00FF;
+	voice.frequency = (highByte << 8) | lowByte;
+
+	_opl->writeReg(0xA0 + voiceNum, lowByte);
+	_opl->writeReg(0xB0 + voiceNum, highByte | 0x20);
+}
+
+void MidiDriver_Simon1_AdLib::noteOnRhythm(uint channel, uint note, uint velocity) {
+	const uint voiceNum = channel - 5;
+	Voice &voice = _voices[voiceNum];
+
+	_amvdrBits |= _rhythmInstrumentMask[voiceNum - 6];
+
+	const uint level = (0x3F - (((velocity | 0x80) * voice.instrTotalLevel) >> 8)) | voice.instrScalingLevel;
+	if (voiceNum == 6) {
+		_opl->writeReg(0x43 + _rhythmOperatorMap[voiceNum - 6], level);
+	} else {
+		_opl->writeReg(0x40 + _rhythmOperatorMap[voiceNum - 6], level);
+	}
+
+	voice.note = note;
+	if (note >= 0x80) {
+		note = 0;
+	}
+
+	const int frequencyAndOctave = _frequencyIndexAndOctaveTable[note];
+	const uint frequency = _frequencyTable[frequencyAndOctave & 0x0F];
+
+	uint highByte = ((frequency & 0xFF00) >> 8) | ((frequencyAndOctave & 0x70) >> 2);
+	uint lowByte  = frequency & 0x00FF;
+	voice.frequency = (highByte << 8) | lowByte;
+
+	const uint oplOperator = _rhythmVoiceMap[voiceNum - 6];
+	_opl->writeReg(0xA0 + oplOperator, lowByte);
+	_opl->writeReg(0xB0 + oplOperator, highByte);
+
+	_opl->writeReg(0xBD, _amvdrBits);
+}
+
+void MidiDriver_Simon1_AdLib::controlChange(uint channel, uint controller, uint value) {
+	// Enable/Disable Rhythm Section
+	if (controller == 0x67) {
+		resetVoices();
+		_rhythmEnabled = (value != 0);
+
+		if (_rhythmEnabled) {
+			_melodyVoices = 6;
+			_amvdrBits = 0xE0;
+		} else {
+			_melodyVoices = 9;
+			_amvdrBits = 0xC0;
+		}
+
+		_voices[6].channel = kChannelUnused;
+		_voices[7].channel = kChannelUnused;
+		_voices[8].channel = kChannelUnused;
+
+		_opl->writeReg(0xBD, _amvdrBits);
+	}
+}
+
+void MidiDriver_Simon1_AdLib::programChange(uint channel, uint program) {
+	_midiPrograms[channel] = program;
+
+	if (_rhythmEnabled && channel >= 11) {
+		setupInstrument(channel - 5, program);
+	} else {
+		// Fully unallocate all previously allocated but now unused voices for
+		// this MIDI channel.
+		for (uint i = 0; i < kOPLVoicesCount; ++i) {
+			if (_voices[i].channel == (channel | kChannelOrphanedFlag)) {
+				_voices[i].channel = kChannelUnused;
+			}
+		}
+
+		// Set the program for all voices allocted for this MIDI channel.
+		for (uint i = 0; i < kOPLVoicesCount; ++i) {
+			if (_voices[i].channel == channel) {
+				setupInstrument(i, program);
+			}
+		}
+	}
+}
+
+void MidiDriver_Simon1_AdLib::setupInstrument(uint voice, uint instrument) {
+	const byte *instrumentData = _instruments + instrument * 16;
+
+	int scaling = instrumentData[3];
+	if (_rhythmEnabled && voice >= 7) {
+		scaling = instrumentData[2];
+	}
+
+	const int scalingLevel = scaling & 0xC0;
+	const int totalLevel   = scaling & 0x3F;
+
+	_voices[voice].instrScalingLevel = scalingLevel;
+	_voices[voice].instrTotalLevel   = (-(totalLevel - 0x3F)) & 0xFF;
+
+	if (!_rhythmEnabled || voice <= 6) {
+		int oplRegister = _operatorMap[voice];
+		for (int j = 0; j < 4; ++j) {
+			oplRegister += 0x20;
+			_opl->writeReg(oplRegister + 0, *instrumentData++);
+			_opl->writeReg(oplRegister + 3, *instrumentData++);
+		}
+		oplRegister += 0x60;
+		_opl->writeReg(oplRegister + 0, *instrumentData++);
+		_opl->writeReg(oplRegister + 3, *instrumentData++);
+
+		_opl->writeReg(0xC0 + voice, *instrumentData++);
+	} else {
+		voice -= 7;
+
+		int oplRegister = _rhythmOperatorMap[voice + 1];
+		for (int j = 0; j < 4; ++j) {
+			oplRegister += 0x20;
+			_opl->writeReg(oplRegister + 0, *instrumentData++);
+			++instrumentData;
+		}
+		oplRegister += 0x60;
+		_opl->writeReg(oplRegister + 0, *instrumentData++);
+		++instrumentData;
+
+		_opl->writeReg(0xC0 + _rhythmVoiceMap[voice + 1], *instrumentData++);
+	}
+}
+
+const int MidiDriver_Simon1_AdLib::_operatorMap[9] = {
+	0x00, 0x01, 0x02, 0x08, 0x09, 0x0A, 0x10, 0x11,
+	0x12
+};
+
+const int MidiDriver_Simon1_AdLib::_operatorDefaults[8] = {
+	0x01, 0x11, 0x4F, 0x00, 0xF1, 0xF2, 0x53, 0x74
+};
+
+const int MidiDriver_Simon1_AdLib::_rhythmOperatorMap[5] = {
+	0x10, 0x14, 0x12, 0x15, 0x11
+};
+
+const uint MidiDriver_Simon1_AdLib::_rhythmInstrumentMask[5] = {
+	0x10, 0x08, 0x04, 0x02, 0x01
+};
+
+const int MidiDriver_Simon1_AdLib::_rhythmVoiceMap[5] = {
+	6, 7, 8, 8, 7
+};
+
+const int MidiDriver_Simon1_AdLib::_frequencyIndexAndOctaveTable[128] = {
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+	0x08, 0x09, 0x0A, 0x0B, 0x00, 0x01, 0x02, 0x03,
+	0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
+	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+	0x18, 0x19, 0x1A, 0x1B, 0x20, 0x21, 0x22, 0x23,
+	0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B,
+	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+	0x38, 0x39, 0x3A, 0x3B, 0x40, 0x41, 0x42, 0x43,
+	0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
+	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+	0x58, 0x59, 0x5A, 0x5B, 0x60, 0x61, 0x62, 0x63,
+	0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B,
+	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+	0x78, 0x79, 0x7A, 0x7B, 0x70, 0x71, 0x72, 0x73,
+	0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B,
+	0x7B, 0x7B, 0x7B, 0x7B, 0x7B, 0x7B, 0x7B, 0x7B
+};
+
+const int MidiDriver_Simon1_AdLib::_frequencyTable[16] = {
+	0x0157, 0x016B, 0x0181, 0x0198, 0x01B0, 0x01CA, 0x01E5, 0x0202,
+	0x0220, 0x0241, 0x0263, 0x0287, 0x2100, 0xD121, 0xA307, 0x46A4
+};
+
+const MidiDriver_Simon1_AdLib::RhythmMap MidiDriver_Simon1_AdLib::_rhythmMap[39] = {
+	{ 11, 123,  40 },
+	{ 12, 127,  50 },
+	{ 12, 124,   1 },
+	{ 12, 124,  90 },
+	{ 13, 125,  50 },
+	{ 13, 125,  25 },
+	{ 15, 127,  80 },
+	{ 13, 125,  25 },
+	{ 15, 127,  40 },
+	{ 13, 125,  35 },
+	{ 15, 127,  90 },
+	{ 13, 125,  35 },
+	{ 13, 125,  45 },
+	{ 14, 126,  90 },
+	{ 13, 125,  45 },
+	{ 15, 127,  90 },
+	{  0,   0,   0 },
+	{ 15, 127,  60 },
+	{  0,   0,   0 },
+	{ 13, 125,  60 },
+	{  0,   0,   0 },
+	{  0,   0,   0 },
+	{  0,   0,   0 },
+	{ 13, 125,  45 },
+	{ 13, 125,  40 },
+	{ 13, 125,  35 },
+	{ 13, 125,  30 },
+	{ 13, 125,  25 },
+	{ 13, 125,  80 },
+	{ 13, 125,  40 },
+	{ 13, 125,  80 },
+	{ 13, 125,  40 },
+	{ 14, 126,  40 },
+	{ 15, 127,  60 },
+	{  0,   0,   0 },
+	{  0,   0,   0 },
+	{ 14, 126,  80 },
+	{  0,   0,   0 },
+	{ 13, 125, 100 }
+};
+
+MidiDriver *createMidiDriverSimon1AdLib(const char *instrumentFilename) {
+	// Load instrument data.
+	Common::File ibk;
+
+	if (!ibk.open(instrumentFilename)) {
+		return nullptr;
+	}
+
+	if (ibk.readUint32BE() != 0x49424b1a) {
+		return nullptr;
+	}
+
+	byte *instrumentData = new byte[128 * 16];
+	if (ibk.read(instrumentData, 128 * 16) != 128 * 16) {
+		delete[] instrumentData;
+		return nullptr;
+	}
+
+	return new MidiDriver_Simon1_AdLib(instrumentData);
+}
+
+} // End of namespace AGOS
diff --git a/engines/agos/drivers/simon1/adlib.h b/engines/agos/drivers/simon1/adlib.h
new file mode 100644
index 0000000000..6057bf1b16
--- /dev/null
+++ b/engines/agos/drivers/simon1/adlib.h
@@ -0,0 +1,118 @@
+/* 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 AGOS_SIMON1_ADLIB_H
+#define AGOS_SIMON1_ADLIB_H
+
+#include "audio/mididrv.h"
+#include "audio/fmopl.h"
+
+namespace AGOS {
+
+class MidiDriver_Simon1_AdLib : public MidiDriver {
+public:
+	MidiDriver_Simon1_AdLib(const byte *instrumentData);
+	virtual ~MidiDriver_Simon1_AdLib();
+
+	// MidiDriver API
+	virtual int open();
+	virtual bool isOpen() const;
+	virtual void close();
+
+	virtual void send(uint32 b);
+
+	virtual void setTimerCallback(void *timer_param, Common::TimerManager::TimerProc timer_proc);
+	virtual uint32 getBaseTempo();
+
+	virtual MidiChannel *allocateChannel() { return 0; }
+	virtual MidiChannel *getPercussionChannel() { return 0; }
+private:
+	bool _isOpen;
+
+	OPL::OPL *_opl;
+
+	Common::TimerManager::TimerProc _timerProc;
+	void *_timerParam;
+	void onTimer();
+
+	void reset();
+	void resetOPLVoices();
+
+	void resetRhythm();
+	int _melodyVoices;
+	uint8 _amvdrBits;
+	bool _rhythmEnabled;
+
+	enum {
+		kNumberOfVoices = 11,
+		kNumberOfMidiChannels = 16
+	};
+
+	struct Voice {
+		Voice();
+
+		uint channel;
+		uint note;
+		uint instrTotalLevel;
+		uint instrScalingLevel;
+		uint frequency;
+	};
+
+	void resetVoices();
+	int allocateVoice(uint channel);
+
+	Voice _voices[kNumberOfVoices];
+	uint _midiPrograms[kNumberOfMidiChannels];
+
+	void noteOff(uint channel, uint note);
+	void noteOn(uint channel, uint note, uint velocity);
+	void noteOnRhythm(uint channel, uint note, uint velocity);
+	void controlChange(uint channel, uint controller, uint value);
+	void programChange(uint channel, uint program);
+
+	void setupInstrument(uint voice, uint instrument);
+	const byte *_instruments;
+
+	static const int _operatorMap[9];
+	static const int _operatorDefaults[8];
+
+	static const int _rhythmOperatorMap[5];
+	static const uint _rhythmInstrumentMask[5];
+	static const int _rhythmVoiceMap[5];
+
+	static const int _frequencyIndexAndOctaveTable[128];
+	static const int _frequencyTable[16];
+
+	struct RhythmMap {
+		int channel;
+		int program;
+		int note;
+	};
+
+	static const RhythmMap _rhythmMap[39];
+};
+
+MidiDriver *createMidiDriverSimon1AdLib(const char *instrumentFilename);
+
+} // End of namespace AGOS
+
+#endif
diff --git a/engines/agos/gfx.cpp b/engines/agos/gfx.cpp
index 5a1f9f1917..867842276a 100644
--- a/engines/agos/gfx.cpp
+++ b/engines/agos/gfx.cpp
@@ -1303,6 +1303,13 @@ void AGOSEngine::setWindowImageEx(uint16 mode, uint16 vgaSpriteId) {
 	} else {
 		setWindowImage(mode, vgaSpriteId);
 	}
+
+	// Amiga versions wait for verb area to be displayed.
+	if (getGameType() == GType_SIMON1 && getPlatform() == Common::kPlatformAmiga && vgaSpriteId == 1) {
+		_copyScnFlag = 5;
+		while (_copyScnFlag && !shouldQuit())
+			delay(1);
+	}
 }
 
 void AGOSEngine::setWindowImage(uint16 mode, uint16 vgaSpriteId, bool specialCase) {
diff --git a/engines/agos/input.cpp b/engines/agos/input.cpp
index 687a8ef1cf..686b1c35b2 100644
--- a/engines/agos/input.cpp
+++ b/engines/agos/input.cpp
@@ -707,6 +707,7 @@ bool AGOSEngine::processSpecialKeys() {
 		if (_midiEnabled) {
 			_midi->pause(_musicPaused);
 		}
+		_mixer->pauseHandle(_modHandle, _musicPaused);
 		syncSoundSettings();
 		break;
 	case 's':
diff --git a/engines/agos/midi.cpp b/engines/agos/midi.cpp
index 045fd9dac5..d11ff201ea 100644
--- a/engines/agos/midi.cpp
+++ b/engines/agos/midi.cpp
@@ -23,10 +23,21 @@
 #include "common/config-manager.h"
 #include "common/file.h"
 #include "common/textconsole.h"
+#include "common/memstream.h"
 
 #include "agos/agos.h"
 #include "agos/midi.h"
 
+#include "agos/drivers/accolade/mididriver.h"
+#include "agos/drivers/simon1/adlib.h"
+// Miles Audio for Simon 2
+#include "audio/miles.h"
+
+// PKWARE data compression library decompressor required for Simon 2
+#include "common/dcl.h"
+
+#include "gui/message.h"
+
 namespace AGOS {
 
 
@@ -42,6 +53,7 @@ MidiPlayer::MidiPlayer() {
 	_driver = 0;
 	_map_mt32_to_gm = false;
 
+	_adLibMusic = false;
 	_enable_sfx = true;
 	_current = 0;
 
@@ -52,9 +64,11 @@ MidiPlayer::MidiPlayer() {
 	_paused = false;
 
 	_currentTrack = 255;
-	_loopTrackDefault = false;
+	_loopTrack = 0;
 	_queuedTrack = 255;
 	_loopQueuedTrack = 0;
+
+	_musicMode = kMusicModeDisabled;
 }
 
 MidiPlayer::~MidiPlayer() {
@@ -70,12 +84,181 @@ MidiPlayer::~MidiPlayer() {
 	clearConstructs();
 }
 
-int MidiPlayer::open(int gameType) {
+int MidiPlayer::open(int gameType, bool isDemo) {
 	// Don't call open() twice!
 	assert(!_driver);
 
-	// Setup midi driver
-	MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_ADLIB | MDT_MIDI | (gameType == GType_SIMON1 ? MDT_PREFER_MT32 : MDT_PREFER_GM));
+	Common::String accoladeDriverFilename;
+	MusicType musicType = MT_INVALID;
+
+	switch (gameType) {
+	case GType_ELVIRA1:
+		_musicMode = kMusicModeAccolade;
+		accoladeDriverFilename = "INSTR.DAT";
+		break;
+	case GType_ELVIRA2:
+	case GType_WW:
+		// Attention: Elvira 2 shipped with INSTR.DAT and MUSIC.DRV
+		// MUSIC.DRV is the correct one. INSTR.DAT seems to be a left-over
+		_musicMode = kMusicModeAccolade;
+		accoladeDriverFilename = "MUSIC.DRV";
+		break;
+	case GType_SIMON1:
+		if (isDemo) {
+			_musicMode = kMusicModeAccolade;
+			accoladeDriverFilename = "MUSIC.DRV";
+		} else if (Common::File::exists("MT_FM.IBK")) {
+			_musicMode = kMusicModeSimon1;
+		}
+		break;
+	case GType_SIMON2:
+		//_musicMode = kMusicModeMilesAudio;
+		// currently disabled, because there are a few issues
+		// MT32 seems to work fine now, AdLib seems to use bad instruments and is also outputting music on
+		// the right speaker only. The original driver did initialize the panning to 0 and the Simon2 XMIDI
+		// tracks don't set panning at all. We can reset panning to be centered, which would solve this
+		// issue, but we still don't know who's setting it in the original interpreter.
+		break;
+	default:
+		break;
+	}
+
+	MidiDriver::DeviceHandle dev;
+	int ret = 0;
+
+	if (_musicMode != kMusicModeDisabled) {
+		dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_MT32);
+		musicType = MidiDriver::getMusicType(dev);
+
+		switch (musicType) {
+		case MT_ADLIB:
+		case MT_MT32:
+			break;
+		case MT_GM:
+			if (!ConfMan.getBool("native_mt32")) {
+				// Not a real MT32 / no MUNT
+				::GUI::MessageDialog dialog(("You appear to be using a General MIDI device,\n"
+											"but your game only supports Roland MT32 MIDI.\n"
+											"We try to map the Roland MT32 instruments to\n"
+											"General MIDI ones. It is still possible that\n"
+											"some tracks sound incorrect."));
+				dialog.runModal();
+			}
+			// Switch to MT32 driver in any case
+			musicType = MT_MT32;
+			break;
+		default:
+			_musicMode = kMusicModeDisabled;
+			break;
+		}
+	}
+
+	switch (_musicMode) {
+	case kMusicModeAccolade: {
+		// Setup midi driver
+		switch (musicType) {
+		case MT_ADLIB:
+			_driver = MidiDriver_Accolade_AdLib_create(accoladeDriverFilename);
+			break;
+		case MT_MT32:
+			_driver = MidiDriver_Accolade_MT32_create(accoladeDriverFilename);
+			break;
+		default:
+			assert(0);
+			break;
+		}
+		if (!_driver)
+			return 255;
+
+		ret = _driver->open();
+		if (ret == 0) {
+			// Reset is done inside our MIDI driver
+			_driver->setTimerCallback(this, &onTimer);
+		}
+
+		//setTimerRate(_driver->getBaseTempo());
+		return 0;
+	}
+	
+	case kMusicModeMilesAudio: {
+		switch (musicType) {
+		case MT_ADLIB: {
+			Common::File instrumentDataFile;
+			if (instrumentDataFile.exists("MIDPAK.AD")) {
+				// if there is a file called MIDPAK.AD, use it directly
+				warning("SIMON 2: using MIDPAK.AD");
+				_driver = Audio::MidiDriver_Miles_AdLib_create("MIDPAK.AD", "MIDPAK.AD");
+			} else {
+				// if there is no file called MIDPAK.AD, try to extract it from the file SETUP.SHR
+				// if we didn't do this, the user would be forced to "install" the game instead of simply
+				// copying all files from CD-ROM.
+				Common::SeekableReadStream *midpakAdLibStream;
+				midpakAdLibStream = simon2SetupExtractFile("MIDPAK.AD");
+				if (!midpakAdLibStream)
+					error("MidiPlayer: could not extract MIDPAK.AD from SETUP.SHR");
+
+				// Pass this extracted data to the driver
+				warning("SIMON 2: using MIDPAK.AD extracted from SETUP.SHR");
+				_driver = Audio::MidiDriver_Miles_AdLib_create("", "", midpakAdLibStream);
+				delete midpakAdLibStream;
+			}
+			// TODO: not sure what's going wrong with AdLib
+			// it doesn't seem to matter if we use the regular XMIDI tracks or the 2nd set meant for MT32
+			break;
+		}
+		case MT_MT32:
+			_driver = Audio::MidiDriver_Miles_MT32_create("");
+			_nativeMT32 = true; // use 2nd set of XMIDI tracks
+			break;
+		case MT_GM:
+			if (ConfMan.getBool("native_mt32")) {
+				_driver = Audio::MidiDriver_Miles_MT32_create("");
+				_nativeMT32 = true; // use 2nd set of XMIDI tracks
+			}
+			break;
+
+		default:
+			break;
+		}
+		if (!_driver)
+			return 255;
+
+		ret = _driver->open();
+		if (ret == 0) {
+			// Reset is done inside our MIDI driver
+			_driver->setTimerCallback(this, &onTimer);
+		}
+		return 0;
+	}
+
+	case kMusicModeSimon1: {
+		// This only handles the original AdLib driver of Simon1.
+		if (musicType == MT_ADLIB) {
+			_adLibMusic = true;
+			_map_mt32_to_gm = false;
+			_nativeMT32 = false;
+
+			_driver = createMidiDriverSimon1AdLib("MT_FM.IBK");
+			if (_driver && _driver->open() == 0) {
+				_driver->setTimerCallback(this, &onTimer);
+				// Like the original, we enable the rhythm support by default.
+				_driver->send(0xB0, 0x67, 0x01);
+				return 0;
+			}
+
+			delete _driver;
+			_driver = nullptr;
+		}
+
+		_musicMode = kMusicModeDisabled;
+	}
+
+	default:
+		break;
+	}
+
+	dev = MidiDriver::detectDevice(MDT_ADLIB | MDT_MIDI | (gameType == GType_SIMON1 ? MDT_PREFER_MT32 : MDT_PREFER_GM));
+	_adLibMusic = (MidiDriver::getMusicType(dev) == MT_ADLIB);
 	_nativeMT32 = ((MidiDriver::getMusicType(dev) == MT_MT32) || ConfMan.getBool("native_mt32"));
 
 	_driver = MidiDriver::createMidi(dev);
@@ -87,7 +270,7 @@ int MidiPlayer::open(int gameType) {
 
 	_map_mt32_to_gm = (gameType != GType_SIMON2 && !_nativeMT32);
 
-	int ret = _driver->open();
+	ret = _driver->open();
 	if (ret)
 		return ret;
 	_driver->setTimerCallback(this, &onTimer);
@@ -104,6 +287,33 @@ void MidiPlayer::send(uint32 b) {
 	if (!_current)
 		return;
 
+	if (_musicMode != kMusicModeDisabled) {
+		// Handle volume control for Simon1 output.
+		if (_musicMode == kMusicModeSimon1) {
+			// The driver does not support any volume control, thus we simply
+			// scale the velocities on note on for now.
+			// TODO: We should probably handle this at output level at some
+			// point. Then we can allow volume changes to affect already
+			// playing notes too. For now this simple change allows us to
+			// have some simple volume control though.
+			if ((b & 0xF0) == 0x90) {
+				byte volume = (b >> 16) & 0x7F;
+
+				if (_current == &_sfx) {
+					volume = volume * _sfxVolume / 255;
+				} else if (_current == &_music) {
+					volume = volume * _musicVolume / 255;
+				}
+
+				b = (b & 0xFF00FFFF) | (volume << 16);
+			}
+		}
+
+		// Send directly to Accolade/Miles/Simon1 Audio driver
+		_driver->send(b);
+		return;
+	}
+
 	byte channel = (byte)(b & 0x0F);
 	if ((b & 0xFFF0) == 0x07B0) {
 		// Adjust volume changes by master music and master sfx volume.
@@ -135,8 +345,10 @@ void MidiPlayer::send(uint32 b) {
 		_current->volume[channel] = 127;
 	}
 
+	// Allocate channels if needed
 	if (!_current->channel[channel])
 		_current->channel[channel] = (channel == 9) ? _driver->getPercussionChannel() : _driver->allocateChannel();
+
 	if (_current->channel[channel]) {
 		if (channel == 9) {
 			if (_current == &_sfx)
@@ -166,13 +378,13 @@ void MidiPlayer::metaEvent(byte type, byte *data, uint16 length) {
 		return;
 	} else if (_current == &_sfx) {
 		clearConstructs(_sfx);
-	} else if (_current->loopTrack) {
+	} else if (_loopTrack) {
 		_current->parser->jumpToTick(0);
 	} else if (_queuedTrack != 255) {
 		_currentTrack = 255;
 		byte destination = _queuedTrack;
 		_queuedTrack = 255;
-		_current->loopTrack = _loopQueuedTrack;
+		_loopTrack = _loopQueuedTrack;
 		_loopQueuedTrack = false;
 
 		// Remember, we're still inside the locked mutex.
@@ -300,7 +512,7 @@ void MidiPlayer::setVolume(int musicVol, int sfxVol) {
 void MidiPlayer::setLoop(bool loop) {
 	Common::StackLock lock(_mutex);
 
-	_loopTrackDefault = loop;
+	_loopTrack = loop;
 }
 
 void MidiPlayer::queueTrack(int track, bool loop) {
@@ -411,24 +623,27 @@ void MidiPlayer::loadSMF(Common::File *in, int song, bool sfx) {
 		// 1 BYTE : Major version
 		// 1 BYTE : Minor version
 		// 1 BYTE : Ticks (Ranges from 2 - 8, always 2 for SFX)
-		// 1 BYTE : Loop control. 0 = no loop, 1 = loop
-
-		// In the original, the ticks value indicated how many
-		// times the music timer was called before it actually
-		// did something. The larger the value the slower the
-		// music.
-		//
-		// We, on the other hand, have a timer rate which is
-		// used to control by how much the music advances on
-		// each onTimer() call. The larger the value, the
-		// faster the music.
-		//
-		// It seems that 4 corresponds to our base tempo, so
-		// this should be the right way to calculate it.
-		timerRate = (4 * _driver->getBaseTempo()) / p->data[5];
-		p->loopTrack = (p->data[6] != 0);
-	} else {
-		p->loopTrack = _loopTrackDefault;
+		// 1 BYTE : Loop control. 0 = no loop, 1 = loop (Music only)
+		if (!sfx) {
+			// In the original, the ticks value indicated how many
+			// times the music timer was called before it actually
+			// did something. The larger the value the slower the
+			// music.
+			//
+			// We, on the other hand, have a timer rate which is
+			// used to control by how much the music advances on
+			// each onTimer() call. The larger the value, the
+			// faster the music.
+			//
+			// It seems that 4 corresponds to our base tempo, so
+			// this should be the right way to calculate it.
+			timerRate = (4 * _driver->getBaseTempo()) / p->data[5];
+
+			// According to bug #1004919 calling setLoop() from
+			// within a lock causes a lockup, though I have no
+			// idea when this actually happens.
+			_loopTrack = (p->data[6] != 0);
+		}
 	}
 
 	MidiParser *parser = MidiParser::createParser_SMF();
@@ -498,8 +713,6 @@ void MidiPlayer::loadMultipleSMF(Common::File *in, bool sfx) {
 		p->song_sizes[i] = size;
 	}
 
-	p->loopTrack = _loopTrackDefault;
-
 	if (!sfx) {
 		_currentTrack = 255;
 		resetVolumeTable();
@@ -531,7 +744,6 @@ void MidiPlayer::loadXMIDI(Common::File *in, bool sfx) {
 		in->seek(pos, 0);
 		p->data = (byte *)calloc(size, 1);
 		in->read(p->data, size);
-		p->loopTrack = _loopTrackDefault;
 	} else {
 		error("Expected 'FORM' tag but found '%c%c%c%c' instead", buf[0], buf[1], buf[2], buf[3]);
 	}
@@ -576,8 +788,105 @@ void MidiPlayer::loadS1D(Common::File *in, bool sfx) {
 		_currentTrack = 255;
 		resetVolumeTable();
 	}
-	p->loopTrack = _loopTrackDefault;
 	p->parser = parser; // That plugs the power cord into the wall
 }
 
+#define MIDI_SETUP_BUNDLE_HEADER_SIZE 56
+#define MIDI_SETUP_BUNDLE_FILEHEADER_SIZE 48
+#define MIDI_SETUP_BUNDLE_FILENAME_MAX_SIZE 12
+
+// PKWARE data compression library (called "DCL" in ScummVM) was used for storing files within SETUP.SHR
+// we need it to be able to get the file MIDPAK.AD, otherwise we would have to require the user
+// to "install" the game before being able to actually play it, when using AdLib.
+//
+// SETUP.SHR file format:
+//  [bundle file header]
+//    [compressed file header] [compressed file data]
+//     * compressed file count
+Common::SeekableReadStream *MidiPlayer::simon2SetupExtractFile(const Common::String &requestedFileName) {
+	Common::File *setupBundleStream = new Common::File();
+	uint32        bundleSize = 0;
+	uint32        bundleBytesLeft = 0;
+	byte          bundleHeader[MIDI_SETUP_BUNDLE_HEADER_SIZE];
+	byte          bundleFileHeader[MIDI_SETUP_BUNDLE_FILEHEADER_SIZE];
+	uint16        bundleFileCount = 0;
+	uint16        bundleFileNr = 0;
+
+	Common::String fileName;
+	uint32         fileCompressedSize = 0;
+	byte          *fileCompressedDataPtr = nullptr;
+
+	Common::SeekableReadStream *extractedStream = nullptr;
+
+	if (!setupBundleStream->open("setup.shr"))
+		error("MidiPlayer: could not open setup.shr");
+
+	bundleSize = setupBundleStream->size();
+	bundleBytesLeft = bundleSize;
+
+	if (bundleSize < MIDI_SETUP_BUNDLE_HEADER_SIZE)
+		error("MidiPlayer: unexpected EOF in setup.shr");
+
+	if (setupBundleStream->read(bundleHeader, MIDI_SETUP_BUNDLE_HEADER_SIZE) != MIDI_SETUP_BUNDLE_HEADER_SIZE)
+		error("MidiPlayer: setup.shr read error");
+	bundleBytesLeft -= MIDI_SETUP_BUNDLE_HEADER_SIZE;
+
+	// Verify header byte
+	if (bundleHeader[13] != 't')
+		error("MidiPlayer: setup.shr bundle header data mismatch");
+
+	bundleFileCount = READ_LE_UINT16(&bundleHeader[14]);
+
+	// Search for requested file
+	while (bundleFileNr < bundleFileCount) {
+		if (bundleBytesLeft < sizeof(bundleFileHeader))
+			error("MidiPlayer: unexpected EOF in setup.shr");
+
+		if (setupBundleStream->read(bundleFileHeader, sizeof(bundleFileHeader)) != sizeof(bundleFileHeader))
+			error("MidiPlayer: setup.shr read error");
+		bundleBytesLeft -= MIDI_SETUP_BUNDLE_FILEHEADER_SIZE;
+
+		// Extract filename from file-header
+		fileName.clear();
+		for (byte curPos = 0; curPos < MIDI_SETUP_BUNDLE_FILENAME_MAX_SIZE; curPos++) {
+			if (!bundleFileHeader[curPos]) // terminating NUL
+				break;
+			fileName.insertChar(bundleFileHeader[curPos], curPos);
+		}
+
+		// Get compressed
+		fileCompressedSize = READ_LE_UINT32(&bundleFileHeader[20]);
+		if (!fileCompressedSize)
+			error("MidiPlayer: compressed file is 0 bytes, data corruption?");
+		if (bundleBytesLeft < fileCompressedSize)
+			error("MidiPlayer: unexpected EOF in setup.shr");
+
+		if (fileName == requestedFileName) {
+			// requested file found
+			fileCompressedDataPtr = new byte[fileCompressedSize];
+
+			if (setupBundleStream->read(fileCompressedDataPtr, fileCompressedSize) != fileCompressedSize)
+				error("MidiPlayer: setup.shr read error");
+
+			Common::MemoryReadStream *compressedStream = nullptr;
+
+			compressedStream = new Common::MemoryReadStream(fileCompressedDataPtr, fileCompressedSize);
+			// we don't know the unpacked size, let decompressor figure it out
+			extractedStream = Common::decompressDCL(compressedStream);
+			delete compressedStream;
+			break;
+		}
+
+		// skip compressed size
+		setupBundleStream->skip(fileCompressedSize);
+		bundleBytesLeft -= fileCompressedSize;
+
+		bundleFileNr++;
+	}
+	setupBundleStream->close();
+	delete setupBundleStream;
+
+	return extractedStream;
+}
+
 } // End of namespace AGOS
diff --git a/engines/agos/midi.h b/engines/agos/midi.h
index 398e445535..fb987fddcf 100644
--- a/engines/agos/midi.h
+++ b/engines/agos/midi.h
@@ -33,10 +33,16 @@ class File;
 
 namespace AGOS {
 
+enum kMusicMode {
+	kMusicModeDisabled = 0,
+	kMusicModeAccolade = 1,
+	kMusicModeMilesAudio = 2,
+	kMusicModeSimon1 = 3
+};
+
 struct MusicInfo {
 	MidiParser *parser;
 	byte *data;
-	bool loopTrack;
 	byte num_songs;           // For Type 1 SMF resources
 	byte *songs[16];          // For Type 1 SMF resources
 	uint32 song_sizes[16];    // For Type 1 SMF resources
@@ -47,7 +53,6 @@ struct MusicInfo {
 	MusicInfo() { clear(); }
 	void clear() {
 		parser = 0; data = 0; num_songs = 0;
-		loopTrack = false;
 		memset(songs, 0, sizeof(songs));
 		memset(song_sizes, 0, sizeof(song_sizes));
 		memset(channel, 0, sizeof(channel));
@@ -73,7 +78,7 @@ protected:
 
 	// These are only used for music.
 	byte _currentTrack;
-	bool _loopTrackDefault;
+	bool _loopTrack;
 	byte _queuedTrack;
 	bool _loopQueuedTrack;
 
@@ -84,6 +89,7 @@ protected:
 	void resetVolumeTable();
 
 public:
+	bool _adLibMusic;
 	bool _enable_sfx;
 
 public:
@@ -109,12 +115,17 @@ public:
 	void setVolume(int musicVol, int sfxVol);
 
 public:
-	int open(int gameType);
+	int open(int gameType, bool isDemo);
 
 	// MidiDriver_BASE interface implementation
 	virtual void send(uint32 b);
 	virtual void metaEvent(byte type, byte *data, uint16 length);
 
+private:
+	kMusicMode _musicMode;
+
+private:
+	Common::SeekableReadStream *simon2SetupExtractFile(const Common::String &requestedFileName);
 };
 
 } // End of namespace AGOS
diff --git a/engines/agos/midiparser_s1d.cpp b/engines/agos/midiparser_s1d.cpp
index c2c08bf451..7b9a058efc 100644
--- a/engines/agos/midiparser_s1d.cpp
+++ b/engines/agos/midiparser_s1d.cpp
@@ -179,12 +179,43 @@ void MidiParser_S1D::parseNextEvent(EventInfo &info) {
 bool MidiParser_S1D::loadMusic(byte *data, uint32 size) {
 	unloadMusic();
 
+	if (!size)
+		return false;
+
 	// The original actually just ignores the first two bytes.
 	byte *pos = data;
-	if (*(pos++) != 0xFC)
-		debug(1, "Expected 0xFC header but found 0x%02X instead", (int) *pos);
-
-	pos += 1;
+	if (*pos == 0xFC) {
+		// SysEx found right at the start
+		// this seems to happen since Elvira 2, we ignore it
+		// 3rd byte after the SysEx seems to be saved into a global
+
+		// We expect at least 4 bytes in total
+		if (size < 4)
+			return false;
+
+		byte skipOffset = pos[2]; // get second byte after the SysEx
+		// pos[1] seems to have been ignored
+		// pos[3] is saved into a global inside the original interpreters
+
+		// Waxworks + Simon 1 demo typical header is:
+		//  0xFC 0x29 0x07 0x01 [0x00/0x01]
+		// Elvira 2 typical header is:
+		//  0xFC 0x04 0x06 0x06
+
+		if (skipOffset >= 6) {
+			// should be at least 6, so that we skip over the 2 size bytes and the
+			// smallest SysEx possible
+			skipOffset -= 2; // 2 size bytes were already read by previous code outside of this method
+
+			if (size <= skipOffset) // Skip to the end of file? -> something is not correct
+				return false;
+
+			// Do skip over the bytes
+			pos += skipOffset;
+		} else {
+			warning("MidiParser_S1D: unexpected skip offset in music file");
+		}
+	}
 
 	// And now we're at the actual data. Only one track.
 	_numTracks = 1;
diff --git a/engines/agos/module.mk b/engines/agos/module.mk
index 7069d8005b..e7b773d76f 100644
--- a/engines/agos/module.mk
+++ b/engines/agos/module.mk
@@ -1,6 +1,10 @@
 MODULE := engines/agos
 
 MODULE_OBJS := \
+	drivers/accolade/adlib.o \
+	drivers/accolade/driverfile.o \
+	drivers/accolade/mt32.o \
+	drivers/simon1/adlib.o \
 	agos.o \
 	charset.o \
 	charset-fontdata.o \
diff --git a/engines/agos/res_snd.cpp b/engines/agos/res_snd.cpp
index 5d6ab60c8b..d04f1735d6 100644
--- a/engines/agos/res_snd.cpp
+++ b/engines/agos/res_snd.cpp
@@ -220,6 +220,7 @@ void AGOSEngine::playModule(uint16 music) {
 	}
 
 	_mixer->playStream(Audio::Mixer::kMusicSoundType, &_modHandle, audioStream);
+	_mixer->pauseHandle(_modHandle, _musicPaused);
 }
 
 void AGOSEngine_Simon1::playMusic(uint16 music, uint16 track) {
@@ -309,7 +310,9 @@ void AGOSEngine::stopMusic() {
 }
 
 void AGOSEngine::playSting(uint16 soundId) {
-	if (!_midi->_enable_sfx)
+	// The sound effects in floppy disk version of
+	// Simon the Sorcerer 1 are only meant for AdLib
+	if (!_midi->_adLibMusic || !_midi->_enable_sfx)
 		return;
 
 	char filename[15];
diff --git a/engines/agos/rooms.cpp b/engines/agos/rooms.cpp
index 6185653d42..d1d6f2b99d 100644
--- a/engines/agos/rooms.cpp
+++ b/engines/agos/rooms.cpp
@@ -383,7 +383,7 @@ bool AGOSEngine::loadRoomItems(uint16 room) {
 			 for (uint16 z = minNum; z <= maxNum; z++) {
 				uint16 itemNum = z + 2;
 				item = derefItem(itemNum);
-				item->parent = 0;
+				_itemArrayPtr[itemNum] = 0;
 
 				uint16 num = (itemNum - _itemArrayInited);
 				_roomStates[num].state = item->state;
@@ -453,6 +453,7 @@ bool AGOSEngine::loadRoomItems(uint16 room) {
 					item->classFlags = _roomStates[num].classFlags;
 					SubRoom *subRoom = (SubRoom *)findChildOfType(item, kRoomType);
 					subRoom->roomExitStates = _roomStates[num].roomExitStates;
+
 				}
 				in.close();
 
diff --git a/engines/agos/saveload.cpp b/engines/agos/saveload.cpp
index 5d5e2d7b03..b968ae645c 100644
--- a/engines/agos/saveload.cpp
+++ b/engines/agos/saveload.cpp
@@ -1261,7 +1261,6 @@ bool AGOSEngine_Elvira2::loadGame(const Common::String &filename, bool restartMo
 
 		uint16 room = _currentRoom;
 		_currentRoom = f->readUint16BE();
-
 		if (_roomsListPtr) {
 			byte *p = _roomsListPtr;
 			if (room == _currentRoom) {
@@ -1293,8 +1292,7 @@ bool AGOSEngine_Elvira2::loadGame(const Common::String &filename, bool restartMo
 
 					 for (uint16 z = minNum; z <= maxNum; z++) {
 						uint16 itemNum = z + 2;
-						Item *item = derefItem(itemNum);
-						item->parent = 0;
+						_itemArrayPtr[itemNum] = 0;
 					}
 				}
 			}
@@ -1318,6 +1316,9 @@ bool AGOSEngine_Elvira2::loadGame(const Common::String &filename, bool restartMo
 			uint parent = f->readUint16BE();
 			uint next = f->readUint16BE();
 
+			if (getGameType() == GType_WW && getPlatform() == Common::kPlatformDOS && derefItem(item->parent) == NULL)
+				item->parent = 0;
+						
 			parent_item = derefItem(parent);
 			setItemParent(item, parent_item);
 
diff --git a/engines/agos/sound.cpp b/engines/agos/sound.cpp
index 812f46504f..762f60bd91 100644
--- a/engines/agos/sound.cpp
+++ b/engines/agos/sound.cpp
@@ -515,7 +515,7 @@ void Sound::readSfxFile(const Common::String &filename) {
 
 // This method is only used by Simon2
 void Sound::loadSfxTable(const char *gameFilename, uint32 base) {
-	stopAll();
+	stopAllSfx();
 
 	delete _effects;
 	const bool dataIsUnsigned = true;
@@ -684,7 +684,7 @@ void Sound::playRawData(byte *soundData, uint sound, uint size, uint freq) {
 	memcpy(buffer, soundData, size);
 
 	byte flags = 0;
-	if (_vm->getPlatform() == Common::kPlatformDOS)
+	if (_vm->getPlatform() == Common::kPlatformDOS &&  _vm->getGameId() != GID_ELVIRA2)
 		flags = Audio::FLAG_UNSIGNED;
 
 	Audio::AudioStream *stream = Audio::makeRawStream(buffer, size, freq, flags);
diff --git a/engines/agos/zones.cpp b/engines/agos/zones.cpp
index 1644213579..5a753d9b4b 100644
--- a/engines/agos/zones.cpp
+++ b/engines/agos/zones.cpp
@@ -94,8 +94,7 @@ void AGOSEngine::loadZone(uint16 zoneNum, bool useError) {
 
 	vpe->sfxFile = NULL;
 
-	if ((getPlatform() == Common::kPlatformAmiga || getPlatform() == Common::kPlatformAtariST) &&
-		getGameType() == GType_ELVIRA2) {
+	if (getGameType() == GType_ELVIRA2) {
 		// A singe sound file is used for Amiga and AtariST versions
 		if (loadVGASoundFile(1, 3)) {
 			vpe->sfxFile = _block;
diff --git a/engines/bbvs/minigames/bbairguitar.cpp b/engines/bbvs/minigames/bbairguitar.cpp
index 1984dbb0fd..04175f7290 100644
--- a/engines/bbvs/minigames/bbairguitar.cpp
+++ b/engines/bbvs/minigames/bbairguitar.cpp
@@ -22,6 +22,13 @@
 
 #include "bbvs/minigames/bbairguitar.h"
 
+#include "common/savefile.h"
+#include "common/translation.h"
+
+#include "gui/dialog.h"
+#include "gui/message.h"
+#include "gui/filebrowser-dialog.h"
+
 namespace Bbvs {
 
 static const char * const kNoteSoundFilenames[] = {
@@ -805,7 +812,7 @@ void MinigameBbAirGuitar::update() {
 	}
 
 	if (_vm->_keyCode == Common::KEYCODE_ESCAPE) {
-		_gameDone = true;
+		_gameDone = querySaveModifiedTracks();
 		return;
 	}
 
@@ -925,7 +932,8 @@ void MinigameBbAirGuitar::afterButtonReleased() {
 			break;
 		case 4:
 			*_currFrameIndex = 1;
-			// TODO Run load dialog
+			loadTracks();
+			_objects[1].kind = 0;
 			break;
 		case 5:
 			_objects[3].kind = 0;
@@ -950,7 +958,8 @@ void MinigameBbAirGuitar::afterButtonReleased() {
 			break;
 		case 12:
 			*_currFrameIndex = 1;
-			// TODO Run save dialog
+			saveTracks();
+			_objects[2].kind = 0;
 			break;
 		case 13:
 			_objects[4].kind = 0;
@@ -1113,7 +1122,7 @@ void MinigameBbAirGuitar::noteOff(int noteNum) {
 		if (_actionTrackPos + _ticksDelta > 15000)
 			_ticksDelta = 15000 - _actionTrackPos;
 		_track[_trackCount].ticks = _ticksDelta;
-		if (_trackCount < 2048)
+		if (_trackCount + 1 < 2048)
 			++_trackCount;
 		_track[_trackCount].noteNum = -2;
 		_noteStartTime = _vm->_system->getMillis();
@@ -1195,4 +1204,113 @@ void MinigameBbAirGuitar::stopNote(int noteNum) {
 		stopSound(2 + _currPatchNum * kNoteSoundFilenamesCount + noteNum);
 }
 
+bool MinigameBbAirGuitar::getLoadFilename(Common::String &filename) {
+	GUI::FileBrowserDialog browser(0, "air", GUI::kFBModeLoad);
+
+	if (browser.runModal() > 0) {
+		filename = browser.getResult();
+		return true;
+	}
+
+	return false;
+}
+
+bool MinigameBbAirGuitar::getSaveFilename(Common::String &filename) {
+	GUI::FileBrowserDialog browser(0, "air", GUI::kFBModeSave);
+
+	if (browser.runModal() > 0) {
+		filename = browser.getResult();
+		return true;
+	}
+
+	return false;
+}
+
+bool MinigameBbAirGuitar::querySaveModifiedDialog() {
+	/* NOTE The original button captions don't fit so shortened variants are used
+		Original ok button caption: "Yeah, heh, heh, save it!"
+		Original discard button caption: "Who cares?  It sucked!"
+	*/
+	GUI::MessageDialog query(_("Hey Beavis - you didn't save that last Jam!"),
+		_("Save it!"),
+		_("It sucked!"));
+	return query.runModal() == GUI::kMessageOK;
+}
+
+bool MinigameBbAirGuitar::querySaveModifiedTracks() {
+	if (_modified && querySaveModifiedDialog()) {
+		if (!saveTracks())
+			return false;
+	}
+	return true;
+}
+
+bool MinigameBbAirGuitar::loadTracks() {
+	if (_playerMode != 0)
+		return false;
+
+	if (!querySaveModifiedTracks())
+		return false;
+
+	Common::String filename;
+	if (!getLoadFilename(filename))
+		return false;
+
+	Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+	Common::InSaveFile *stream = saveFileMan->openForLoading(filename);
+	if (!loadFromStream(stream)) {
+		Common::String msg = Common::String::format("%s is not a valid Air Guitar file", filename.c_str());
+		GUI::MessageDialog dialog(msg);
+		dialog.runModal();
+	}
+	delete stream;
+
+	return true;
+}
+
+bool MinigameBbAirGuitar::saveTracks() {
+	if (_playerMode != 0)
+		return false;
+
+	Common::String filename;
+	if (!getSaveFilename(filename))
+		return false;
+
+	Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+	Common::OutSaveFile *stream = saveFileMan->openForSaving(filename);
+	saveToStream(stream);
+	delete stream;
+	_modified = false;
+
+	return true;
+}
+
+bool MinigameBbAirGuitar::loadFromStream(Common::ReadStream *stream) {
+	uint32 magic = stream->readUint32BE();
+	if (magic != MKTAG('A', 'I', 'R', 'G'))
+		return false;
+	for (uint i = 0; i < kMaxTracks; ++i) {
+		_track[i].noteNum = stream->readByte();
+		_track[i].ticks = stream->readUint16LE();
+	}
+	_trackCount = 0;
+	_actionTrackPos = 0;
+	while (_track[_trackCount].noteNum != -1) {
+		_actionTrackPos += _track[_trackCount].ticks;
+		++_trackCount;
+	}
+	_totalTrackLength = _actionTrackPos;
+	_trackIndex = 0;
+	_currTrackPos = 0;
+	return true;
+}
+
+void MinigameBbAirGuitar::saveToStream(Common::WriteStream *stream) {
+	stream->writeUint32BE(MKTAG('A', 'I', 'R', 'G'));
+	for (uint i = 0; i < kMaxTracks; ++i) {
+		stream->writeByte(_track[i].noteNum);
+		stream->writeUint16LE(_track[i].ticks);
+	}
+}
+
 } // End of namespace Bbvs
diff --git a/engines/bbvs/minigames/bbairguitar.h b/engines/bbvs/minigames/bbairguitar.h
index 40b8a50a03..b8b92ef433 100644
--- a/engines/bbvs/minigames/bbairguitar.h
+++ b/engines/bbvs/minigames/bbairguitar.h
@@ -47,7 +47,7 @@ public:
 
 	enum {
 		kMaxObjectsCount = 256,
-		kMaxTracks = 2049
+		kMaxTracks = 2048
 	};
 
 	struct PianoKeyInfo {
@@ -141,6 +141,15 @@ public:
 	void playNote(int noteNum);
 	void stopNote(int noteNum);
 
+	bool getLoadFilename(Common::String &filename);
+	bool getSaveFilename(Common::String &filename);
+	bool querySaveModifiedDialog();
+	bool querySaveModifiedTracks();
+	bool loadTracks();
+	bool saveTracks();
+	bool loadFromStream(Common::ReadStream *stream);
+	void saveToStream(Common::WriteStream *stream);
+
 };
 
 } // End of namespace Bbvs
diff --git a/engines/bbvs/sound.h b/engines/bbvs/sound.h
index 4e44c2b962..4d3253c48e 100644
--- a/engines/bbvs/sound.h
+++ b/engines/bbvs/sound.h
@@ -38,7 +38,7 @@ public:
 	void stop();
 	bool isPlaying();
 protected:
-	Audio::SeekableAudioStream *_stream;
+	Audio::RewindableAudioStream *_stream;
 	Audio::SoundHandle _handle;
 	// Keep the filename for debugging purposes
 	Common::String _filename;
diff --git a/engines/cine/cine.cpp b/engines/cine/cine.cpp
index a4af8f2201..d2f088dcd8 100644
--- a/engines/cine/cine.cpp
+++ b/engines/cine/cine.cpp
@@ -22,10 +22,14 @@
 
 #include "common/config-manager.h"
 #include "common/debug-channels.h"
+#include "common/events.h"
 
 #include "engines/util.h"
 
 #include "graphics/cursorman.h"
+#include "graphics/palette.h"
+
+#include "image/iff.h"
 
 #include "cine/cine.h"
 #include "cine/bg_list.h"
@@ -89,9 +93,16 @@ void CineEngine::syncSoundSettings() {
 }
 
 Common::Error CineEngine::run() {
+	if (g_cine->getGameType() == GType_FW && (g_cine->getFeatures() & GF_CD)) {
+		showSplashScreen();
+	}
+
 	// Initialize backend
 	initGraphics(320, 200, false);
 
+	if (g_cine->getGameType() == GType_FW && (g_cine->getFeatures() & GF_CD))
+		checkCD();
+
 	if (getPlatform() == Common::kPlatformDOS) {
 		g_sound = new PCSound(_mixer, this);
 	} else {
@@ -236,4 +247,45 @@ void CineEngine::initialize() {
 	}
 }
 
+void CineEngine::showSplashScreen() {
+	Common::File file;
+	if (!file.open("sony.lbm"))
+		return;
+
+	Image::IFFDecoder decoder;
+	if (!decoder.loadStream(file))
+		return;
+
+	const Graphics::Surface *surface = decoder.getSurface();
+	if (surface->w == 640 && surface->h == 480) {
+		initGraphics(640, 480, true);
+
+		const byte *palette = decoder.getPalette();
+		int paletteColorCount = decoder.getPaletteColorCount();
+		g_system->getPaletteManager()->setPalette(palette, 0, paletteColorCount);
+
+		g_system->copyRectToScreen(surface->getPixels(), 640, 0, 0, 640, 480);
+		g_system->updateScreen();
+
+		Common::EventManager *eventMan = g_system->getEventManager();
+
+		bool done = false;
+		uint32 now = g_system->getMillis();
+
+		while (!done && g_system->getMillis() - now < 2000) {
+			Common::Event event;
+			while (eventMan->pollEvent(event)) {
+				if (event.type == Common::EVENT_KEYDOWN && event.kbd.keycode == Common::KEYCODE_ESCAPE) {
+					done = true;
+					break;
+				}
+				if (shouldQuit())
+					done = true;
+			}
+		}
+	}
+
+	decoder.destroy();
+}
+
 } // End of namespace Cine
diff --git a/engines/cine/cine.h b/engines/cine/cine.h
index e620d2ffa5..71a0c242b6 100644
--- a/engines/cine/cine.h
+++ b/engines/cine/cine.h
@@ -145,6 +145,7 @@ public:
 
 private:
 	void initialize();
+	void showSplashScreen();
 	void resetEngine();
 	bool loadPlainSaveFW(Common::SeekableReadStream &in, CineSaveGameFormat saveGameFormat);
 	bool loadTempSaveOS(Common::SeekableReadStream &in);
diff --git a/engines/cine/detection_tables.h b/engines/cine/detection_tables.h
index 6069e3a99b..1188deb1a6 100644
--- a/engines/cine/detection_tables.h
+++ b/engines/cine/detection_tables.h
@@ -379,6 +379,20 @@ static const CINEGameDescription gameDescriptions[] = {
 	{
 		{
 			"os",
+			"Demo",
+			AD_ENTRY1("demo_os", "043859e4cfe3977ad95b6efd00b21c62"),
+			Common::EN_GRB,
+			Common::kPlatformDOS,
+			ADGF_DEMO | ADGF_UNSTABLE,
+			GUIO0()
+		},
+		GType_OS,
+		GF_DEMO,
+	},
+
+	{
+		{
+			"os",
 			"",
 			AD_ENTRY1("procs0", "a9da5531ead0ebf9ad387fa588c0cbb0"),
 			Common::EN_GRB,
diff --git a/engines/cine/main_loop.cpp b/engines/cine/main_loop.cpp
index 9ce683445f..e52fc464d5 100644
--- a/engines/cine/main_loop.cpp
+++ b/engines/cine/main_loop.cpp
@@ -31,6 +31,8 @@
 #include "cine/bg_list.h"
 #include "cine/sound.h"
 
+#include "backends/audiocd/audiocd.h"
+
 namespace Cine {
 
 struct MouseStatusStruct {
@@ -219,6 +221,8 @@ void manageEvents() {
 
 	mouseData.left = mouseLeft;
 	mouseData.right = mouseRight;
+
+	g_system->getAudioCDManager()->updateCD();
 }
 
 void getMouseData(uint16 param, uint16 *pButton, uint16 *pX, uint16 *pY) {
diff --git a/engines/cine/saveload.cpp b/engines/cine/saveload.cpp
index c707c60695..907086a9a1 100644
--- a/engines/cine/saveload.cpp
+++ b/engines/cine/saveload.cpp
@@ -543,6 +543,15 @@ bool CineEngine::loadTempSaveOS(Common::SeekableReadStream &in) {
 			loadRel(currentRelName);
 		}
 
+		// Reset background music in CD version of Future Wars
+		if (getGameType() == GType_FW && (getFeatures() & GF_CD)) {
+			if (strlen(bgNames[0])) {
+				char buffer[20];
+				removeExtention(buffer, bgNames[0]);
+				g_sound->setBgMusic(atoi(buffer + 1));
+			}
+		}
+
 		// Load first background (Uses loadBg)
 		if (strlen(bgNames[0])) {
 			loadBg(bgNames[0]);
diff --git a/engines/cine/script_fw.cpp b/engines/cine/script_fw.cpp
index c0b0c1f5da..6ad38f4433 100644
--- a/engines/cine/script_fw.cpp
+++ b/engines/cine/script_fw.cpp
@@ -1380,6 +1380,12 @@ int FWScript::o1_loadBg() {
 
 	debugC(5, kCineDebugScript, "Line: %d: loadBg(\"%s\")", _line, param);
 
+	if (g_cine->getGameType() == GType_FW && (g_cine->getFeatures() & GF_CD)) {
+		char buffer[20];
+		removeExtention(buffer, param);
+		g_sound->setBgMusic(atoi(buffer + 1));
+	}
+
 	loadBg(param);
 	g_cine->_bgIncrustList.clear();
 	bgVar0 = 0;
diff --git a/engines/cine/sound.cpp b/engines/cine/sound.cpp
index 069a4787ac..7cab067371 100644
--- a/engines/cine/sound.cpp
+++ b/engines/cine/sound.cpp
@@ -32,6 +32,8 @@
 #include "cine/cine.h"
 #include "cine/sound.h"
 
+#include "backends/audiocd/audiocd.h"
+
 #include "audio/audiostream.h"
 #include "audio/fmopl.h"
 #include "audio/mididrv.h"
@@ -101,7 +103,7 @@ struct AdLibSoundInstrument {
 	byte amDepth;
 };
 
-class AdLibSoundDriver : public PCSoundDriver, Audio::AudioStream {
+class AdLibSoundDriver : public PCSoundDriver {
 public:
 	AdLibSoundDriver(Audio::Mixer *mixer);
 	virtual ~AdLibSoundDriver();
@@ -112,14 +114,8 @@ public:
 	virtual void stopChannel(int channel);
 	virtual void stopAll();
 
-	// AudioStream interface
-	virtual int readBuffer(int16 *buffer, const int numSamples);
-	virtual bool isStereo() const { return false; }
-	virtual bool endOfData() const { return false; }
-	virtual int getRate() const { return _sampleRate; }
-
 	void initCard();
-	void update(int16 *buf, int len);
+	void onTimer();
 	void setupInstrument(const byte *data, int channel);
 	void loadRegisterInstrument(const byte *data, AdLibRegisterSoundInstrument *reg);
 	virtual void loadInstrument(const byte *data, AdLibSoundInstrument *asi) = 0;
@@ -128,10 +124,8 @@ protected:
 	UpdateCallback _upCb;
 	void *_upRef;
 
-	FM_OPL *_opl;
-	int _sampleRate;
+	OPL::OPL *_opl;
 	Audio::Mixer *_mixer;
-	Audio::SoundHandle _soundHandle;
 
 	byte _vibrato;
 	int _channelsVolumeTable[4];
@@ -282,17 +276,19 @@ void PCSoundDriver::resetChannel(int channel) {
 
 AdLibSoundDriver::AdLibSoundDriver(Audio::Mixer *mixer)
 	: _upCb(0), _upRef(0), _mixer(mixer) {
-	_sampleRate = _mixer->getOutputRate();
-	_opl = makeAdLibOPL(_sampleRate);
+
+	_opl = OPL::Config::create();
+	if (!_opl || !_opl->init())
+		error("Failed to create OPL");
+
 	memset(_channelsVolumeTable, 0, sizeof(_channelsVolumeTable));
 	memset(_instrumentsTable, 0, sizeof(_instrumentsTable));
 	initCard();
-	_mixer->playStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
+	_opl->start(new Common::Functor0Mem<void, AdLibSoundDriver>(this, &AdLibSoundDriver::onTimer), 50);
 }
 
 AdLibSoundDriver::~AdLibSoundDriver() {
-	_mixer->stopHandle(_soundHandle);
-	OPLDestroy(_opl);
+	delete _opl;
 }
 
 void AdLibSoundDriver::setUpdateCallback(UpdateCallback upCb, void *ref) {
@@ -322,71 +318,52 @@ void AdLibSoundDriver::stopChannel(int channel) {
 		channel = 6;
 	}
 	if (ins->mode == 0 || channel == 6) {
-		OPLWriteReg(_opl, 0xB0 | channel, 0);
+		_opl->writeReg(0xB0 | channel, 0);
 	}
 	if (ins->mode != 0) {
 		_vibrato &= ~(1 << (10 - ins->channel));
-		OPLWriteReg(_opl, 0xBD, _vibrato);
+		_opl->writeReg(0xBD, _vibrato);
 	}
 }
 
 void AdLibSoundDriver::stopAll() {
 	int i;
 	for (i = 0; i < 18; ++i) {
-		OPLWriteReg(_opl, 0x40 | _operatorsTable[i], 63);
+		_opl->writeReg(0x40 | _operatorsTable[i], 63);
 	}
 	for (i = 0; i < 9; ++i) {
-		OPLWriteReg(_opl, 0xB0 | i, 0);
+		_opl->writeReg(0xB0 | i, 0);
 	}
-	OPLWriteReg(_opl, 0xBD, 0);
-}
-
-int AdLibSoundDriver::readBuffer(int16 *buffer, const int numSamples) {
-	update(buffer, numSamples);
-	return numSamples;
+	_opl->writeReg(0xBD, 0);
 }
 
 void AdLibSoundDriver::initCard() {
 	_vibrato = 0x20;
-	OPLWriteReg(_opl, 0xBD, _vibrato);
-	OPLWriteReg(_opl, 0x08, 0x40);
+	_opl->writeReg(0xBD, _vibrato);
+	_opl->writeReg(0x08, 0x40);
 
 	static const int oplRegs[] = { 0x40, 0x60, 0x80, 0x20, 0xE0 };
 
 	for (int i = 0; i < 9; ++i) {
-		OPLWriteReg(_opl, 0xB0 | i, 0);
+		_opl->writeReg(0xB0 | i, 0);
 	}
 	for (int i = 0; i < 9; ++i) {
-		OPLWriteReg(_opl, 0xC0 | i, 0);
+		_opl->writeReg(0xC0 | i, 0);
 	}
 
 	for (int j = 0; j < 5; j++) {
 		for (int i = 0; i < 18; ++i) {
-			OPLWriteReg(_opl, oplRegs[j] | _operatorsTable[i], 0);
+			_opl->writeReg(oplRegs[j] | _operatorsTable[i], 0);
 		}
 	}
 
-	OPLWriteReg(_opl, 1, 0x20);
-	OPLWriteReg(_opl, 1, 0);
+	_opl->writeReg(1, 0x20);
+	_opl->writeReg(1, 0);
 }
 
-void AdLibSoundDriver::update(int16 *buf, int len) {
-	static int samplesLeft = 0;
-	while (len != 0) {
-		int count = samplesLeft;
-		if (count > len) {
-			count = len;
-		}
-		samplesLeft -= count;
-		len -= count;
-		YM3812UpdateOne(_opl, buf, count);
-		if (samplesLeft == 0) {
-			if (_upCb) {
-				(*_upCb)(_upRef);
-			}
-			samplesLeft = _sampleRate / 50;
-		}
-		buf += count;
+void AdLibSoundDriver::onTimer() {
+	if (_upCb) {
+		(*_upCb)(_upRef);
 	}
 }
 
@@ -408,32 +385,32 @@ void AdLibSoundDriver::setupInstrument(const byte *data, int channel) {
 
 	if (ins->mode == 0 || ins->channel == 6) {
 		reg = &ins->regMod;
-		OPLWriteReg(_opl, 0x20 | mod, reg->vibrato);
+		_opl->writeReg(0x20 | mod, reg->vibrato);
 		if (reg->freqMod) {
 			tmp = reg->outputLevel & 0x3F;
 		} else {
 			tmp = (63 - (reg->outputLevel & 0x3F)) * _channelsVolumeTable[channel];
 			tmp = 63 - (2 * tmp + 127) / (2 * 127);
 		}
-		OPLWriteReg(_opl, 0x40 | mod, tmp | (reg->keyScaling << 6));
-		OPLWriteReg(_opl, 0x60 | mod, reg->attackDecay);
-		OPLWriteReg(_opl, 0x80 | mod, reg->sustainRelease);
+		_opl->writeReg(0x40 | mod, tmp | (reg->keyScaling << 6));
+		_opl->writeReg(0x60 | mod, reg->attackDecay);
+		_opl->writeReg(0x80 | mod, reg->sustainRelease);
 		if (ins->mode != 0) {
-			OPLWriteReg(_opl, 0xC0 | ins->channel, reg->feedbackStrength);
+			_opl->writeReg(0xC0 | ins->channel, reg->feedbackStrength);
 		} else {
-			OPLWriteReg(_opl, 0xC0 | channel, reg->feedbackStrength);
+			_opl->writeReg(0xC0 | channel, reg->feedbackStrength);
 		}
-		OPLWriteReg(_opl, 0xE0 | mod, ins->waveSelectMod);
+		_opl->writeReg(0xE0 | mod, ins->waveSelectMod);
 	}
 
 	reg = &ins->regCar;
-	OPLWriteReg(_opl, 0x20 | car, reg->vibrato);
+	_opl->writeReg(0x20 | car, reg->vibrato);
 	tmp = (63 - (reg->outputLevel & 0x3F)) * _channelsVolumeTable[channel];
 	tmp = 63 - (2 * tmp + 127) / (2 * 127);
-	OPLWriteReg(_opl, 0x40 | car, tmp | (reg->keyScaling << 6));
-	OPLWriteReg(_opl, 0x60 | car, reg->attackDecay);
-	OPLWriteReg(_opl, 0x80 | car, reg->sustainRelease);
-	OPLWriteReg(_opl, 0xE0 | car, ins->waveSelectCar);
+	_opl->writeReg(0x40 | car, tmp | (reg->keyScaling << 6));
+	_opl->writeReg(0x60 | car, reg->attackDecay);
+	_opl->writeReg(0x80 | car, reg->sustainRelease);
+	_opl->writeReg(0xE0 | car, ins->waveSelectCar);
 }
 
 void AdLibSoundDriver::loadRegisterInstrument(const byte *data, AdLibRegisterSoundInstrument *reg) {
@@ -490,16 +467,16 @@ void AdLibSoundDriverINS::setChannelFrequency(int channel, int frequency) {
 		if (channel == 6)
 			oct = 0;
 		freq = _freqTable[note % 12];
-		OPLWriteReg(_opl, 0xA0 | channel, freq);
+		_opl->writeReg(0xA0 | channel, freq);
 		freq = (oct << 2) | ((freq & 0x300) >> 8);
 		if (ins->mode == 0) {
 			freq |= 0x20;
 		}
-		OPLWriteReg(_opl, 0xB0 | channel, freq);
+		_opl->writeReg(0xB0 | channel, freq);
 	}
 	if (ins->mode != 0) {
 		_vibrato |= 1 << (10 - ins->channel);
-		OPLWriteReg(_opl, 0xBD, _vibrato);
+		_opl->writeReg(0xBD, _vibrato);
 	}
 }
 
@@ -515,16 +492,16 @@ void AdLibSoundDriverINS::playSample(const byte *data, int size, int channel, in
 	if (ins->mode == 0 || channel == 6) {
 		uint16 note = 12;
 		int freq = _freqTable[note % 12];
-		OPLWriteReg(_opl, 0xA0 | channel, freq);
+		_opl->writeReg(0xA0 | channel, freq);
 		freq = ((note / 12) << 2) | ((freq & 0x300) >> 8);
 		if (ins->mode == 0) {
 			freq |= 0x20;
 		}
-		OPLWriteReg(_opl, 0xB0 | channel, freq);
+		_opl->writeReg(0xB0 | channel, freq);
 	}
 	if (ins->mode != 0) {
 		_vibrato |= 1 << (10 - ins->channel);
-		OPLWriteReg(_opl, 0xBD, _vibrato);
+		_opl->writeReg(0xBD, _vibrato);
 	}
 }
 
@@ -562,15 +539,15 @@ void AdLibSoundDriverADL::setChannelFrequency(int channel, int frequency) {
 	}
 
 	freq = _freqTable[note % 12];
-	OPLWriteReg(_opl, 0xA0 | channel, freq);
+	_opl->writeReg(0xA0 | channel, freq);
 	freq = (oct << 2) | ((freq & 0x300) >> 8);
 	if (ins->mode == 0) {
 		freq |= 0x20;
 	}
-	OPLWriteReg(_opl, 0xB0 | channel, freq);
+	_opl->writeReg(0xB0 | channel, freq);
 	if (ins->mode != 0) {
 		_vibrato |= 1 << (10 - channel);
-		OPLWriteReg(_opl, 0xBD, _vibrato);
+		_opl->writeReg(0xBD, _vibrato);
 	}
 }
 
@@ -580,11 +557,11 @@ void AdLibSoundDriverADL::playSample(const byte *data, int size, int channel, in
 	setupInstrument(data, channel);
 	AdLibSoundInstrument *ins = &_instrumentsTable[channel];
 	if (ins->mode != 0 && ins->channel == 6) {
-		OPLWriteReg(_opl, 0xB0 | channel, 0);
+		_opl->writeReg(0xB0 | channel, 0);
 	}
 	if (ins->mode != 0) {
 		_vibrato &= ~(1 << (10 - ins->channel));
-		OPLWriteReg(_opl, 0xBD, _vibrato);
+		_opl->writeReg(0xBD, _vibrato);
 	}
 	if (ins->mode != 0) {
 		channel = ins->channel;
@@ -599,15 +576,15 @@ void AdLibSoundDriverADL::playSample(const byte *data, int size, int channel, in
 		note = ins->amDepth;
 	}
 	int freq = _freqTable[note % 12];
-	OPLWriteReg(_opl, 0xA0 | channel, freq);
+	_opl->writeReg(0xA0 | channel, freq);
 	freq = ((note / 12) << 2) | ((freq & 0x300) >> 8);
 	if (ins->mode == 0) {
 		freq |= 0x20;
 	}
-	OPLWriteReg(_opl, 0xB0 | channel, freq);
+	_opl->writeReg(0xB0 | channel, freq);
 	if (ins->mode != 0) {
 		_vibrato |= 1 << (10 - channel);
-		OPLWriteReg(_opl, 0xBD, _vibrato);
+		_opl->writeReg(0xBD, _vibrato);
 	}
 }
 
@@ -932,6 +909,10 @@ void PCSoundFxPlayer::unload() {
 PCSound::PCSound(Audio::Mixer *mixer, CineEngine *vm)
 	: Sound(mixer, vm), _soundDriver(0) {
 
+	_currentMusic = 0;
+	_currentMusicStatus = 0;
+	_currentBgSlot = 0;
+
 	const MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB);
 	const MusicType musicType = MidiDriver::getMusicType(dev);
 	if (musicType == MT_MT32 || musicType == MT_GM) {
@@ -965,23 +946,98 @@ PCSound::~PCSound() {
 	delete _soundDriver;
 }
 
+static const char *const musicFileNames[11] = {
+	"DUGGER.DAT",
+	"SUITE21.DAT",
+	"FWARS.DAT",
+	"SUITE23.DAT",
+	"SUITE22.DAT",
+	"ESCAL",
+	"MOINES.DAT",
+	"MEDIAVAL.DAT",
+	"SFUTUR",
+	"ALIENS",
+	"TELESONG.DAT",
+};
+
+static uint8 musicCDTracks[11] = {
+	20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 22,
+};
+
 void PCSound::loadMusic(const char *name) {
 	debugC(5, kCineDebugSound, "PCSound::loadMusic('%s')", name);
-	_player->load(name);
+	if (_vm->getGameType() == GType_FW && (_vm->getFeatures() & GF_CD)) {
+		_currentMusic = 0;
+		_currentMusicStatus = 0;
+		for (int i = 0; i < 11; i++) {
+			if (!strcmp((const char *)name, musicFileNames[i])) {
+				_currentMusic = musicCDTracks[i];
+				_currentMusicStatus = musicCDTracks[i];
+			}
+		}
+	} else {
+		_player->load(name);
+	}
 }
 
 void PCSound::playMusic() {
 	debugC(5, kCineDebugSound, "PCSound::playMusic()");
-	_player->play();
+	if (_vm->getGameType() == GType_FW && (_vm->getFeatures() & GF_CD)) {
+		g_system->getAudioCDManager()->stop();
+		g_system->getAudioCDManager()->play(_currentMusic - 1, -1, 0, 0);
+	} else {
+		_player->play();
+	}
+}
+
+static uint8 bgCDTracks[49] = {
+	0, 21, 21, 23, 0, 29, 0, 0, 0, 0,
+	0, 27,  0,  0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 22, 22, 23, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+void PCSound::setBgMusic(int num) {
+	debugC(5, kCineDebugSound, "PCSound::setBgMusic(%d)", num);
+	_currentBgSlot = num;
+	if (!bgCDTracks[_currentBgSlot])
+		return;
+
+	if ((_currentBgSlot == 1) || (_currentMusicStatus == 0 && _currentMusic != bgCDTracks[_currentBgSlot])) {
+		_currentMusic = bgCDTracks[_currentBgSlot];
+		g_system->getAudioCDManager()->stop();
+		g_system->getAudioCDManager()->play(bgCDTracks[_currentBgSlot] - 1, -1, 0, 0);
+	}
 }
 
 void PCSound::stopMusic() {
 	debugC(5, kCineDebugSound, "PCSound::stopMusic()");
+
+	if (_vm->getGameType() == GType_FW && (_vm->getFeatures() & GF_CD)) {
+		if (_currentBgSlot != 1)
+			g_system->getAudioCDManager()->stop();
+	}
 	_player->stop();
 }
 
 void PCSound::fadeOutMusic() {
 	debugC(5, kCineDebugSound, "PCSound::fadeOutMusic()");
+
+	if (_vm->getGameType() == GType_FW && (_vm->getFeatures() & GF_CD)) {
+		if (_currentMusicStatus) {
+			if (_currentBgSlot == 1) {
+				_currentMusicStatus = 0;
+			} else {
+				_currentMusic = 0;
+				_currentMusicStatus = 0;
+				g_system->getAudioCDManager()->stop();
+				if (bgCDTracks[_currentBgSlot]) {
+					g_system->getAudioCDManager()->play(_currentBgSlot - 1, -1, 0, 0);
+				}
+			}
+		}
+	}
 	_player->fadeOut();
 }
 
@@ -1081,6 +1137,9 @@ void PaulaSound::stopMusic() {
 	_mixer->stopHandle(_moduleHandle);
 }
 
+void PaulaSound::setBgMusic(int num) {
+}
+
 void PaulaSound::fadeOutMusic() {
 	debugC(5, kCineDebugSound, "PaulaSound::fadeOutMusic()");
 	Common::StackLock lock(_musicMutex);
diff --git a/engines/cine/sound.h b/engines/cine/sound.h
index efb3811f9a..0149071ed7 100644
--- a/engines/cine/sound.h
+++ b/engines/cine/sound.h
@@ -48,6 +48,7 @@ public:
 
 	virtual void playSound(int channel, int frequency, const uint8 *data, int size, int volumeStep, int stepCount, int volume, int repeat) = 0;
 	virtual void stopSound(int channel) = 0;
+	virtual void setBgMusic(int num) = 0;
 
 protected:
 
@@ -71,11 +72,14 @@ public:
 
 	virtual void playSound(int channel, int frequency, const uint8 *data, int size, int volumeStep, int stepCount, int volume, int repeat);
 	virtual void stopSound(int channel);
+	virtual void setBgMusic(int num);
 
 protected:
 
 	PCSoundDriver *_soundDriver;
 	PCSoundFxPlayer *_player;
+
+	uint8 _currentMusic, _currentMusicStatus, _currentBgSlot;
 };
 
 class PaulaSound : public Sound {
@@ -91,6 +95,7 @@ public:
 
 	virtual void playSound(int channel, int frequency, const uint8 *data, int size, int volumeStep, int stepCount, int volume, int repeat);
 	virtual void stopSound(int channel);
+	virtual void setBgMusic(int num);
 
 	enum {
 		PAULA_FREQ = 3579545,
diff --git a/engines/cruise/sound.cpp b/engines/cruise/sound.cpp
index 0b0fab8c4a..f57435f4f7 100644
--- a/engines/cruise/sound.cpp
+++ b/engines/cruise/sound.cpp
@@ -108,7 +108,7 @@ struct VolumeEntry {
 	int adjusted;
 };
 
-class AdLibSoundDriver : public PCSoundDriver, Audio::AudioStream {
+class AdLibSoundDriver : public PCSoundDriver {
 public:
 	AdLibSoundDriver(Audio::Mixer *mixer);
 	virtual ~AdLibSoundDriver();
@@ -118,14 +118,8 @@ public:
 	virtual void stopChannel(int channel);
 	virtual void stopAll();
 
-	// AudioStream interface
-	virtual int readBuffer(int16 *buffer, const int numSamples);
-	virtual bool isStereo() const { return false; }
-	virtual bool endOfData() const { return false; }
-	virtual int getRate() const { return _sampleRate; }
-
 	void initCard();
-	void update(int16 *buf, int len);
+	void onTimer();
 	void setupInstrument(const byte *data, int channel);
 	void setupInstrument(const AdLibSoundInstrument *ins, int channel);
 	void loadRegisterInstrument(const byte *data, AdLibRegisterSoundInstrument *reg);
@@ -135,10 +129,8 @@ public:
 	void adjustVolume(int channel, int volume);
 
 protected:
-	FM_OPL *_opl;
-	int _sampleRate;
+	OPL::OPL *_opl;
 	Audio::Mixer *_mixer;
-	Audio::SoundHandle _soundHandle;
 
 	byte _vibrato;
 	VolumeEntry _channelsVolumeTable[5];
@@ -302,8 +294,9 @@ void PCSoundDriver::syncSounds() {
 
 AdLibSoundDriver::AdLibSoundDriver(Audio::Mixer *mixer)
 	: _mixer(mixer) {
-	_sampleRate = _mixer->getOutputRate();
-	_opl = makeAdLibOPL(_sampleRate);
+	_opl = OPL::Config::create();
+	if (!_opl || !_opl->init())
+		error("Failed to create OPL");
 
 	for (int i = 0; i < 5; ++i) {
 		_channelsVolumeTable[i].original = 0;
@@ -311,15 +304,15 @@ AdLibSoundDriver::AdLibSoundDriver(Audio::Mixer *mixer)
 	}
 	memset(_instrumentsTable, 0, sizeof(_instrumentsTable));
 	initCard();
-	_mixer->playStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
 
 	_musicVolume = ConfMan.getBool("music_mute") ? 0 : MIN(255, ConfMan.getInt("music_volume"));
 	_sfxVolume = ConfMan.getBool("sfx_mute") ? 0 : MIN(255, ConfMan.getInt("sfx_volume"));
+
+	_opl->start(new Common::Functor0Mem<void, AdLibSoundDriver>(this, &AdLibSoundDriver::onTimer), 50);
 }
 
 AdLibSoundDriver::~AdLibSoundDriver() {
-	_mixer->stopHandle(_soundHandle);
-	OPLDestroy(_opl);
+	delete _opl;
 }
 
 void AdLibSoundDriver::syncSounds() {
@@ -368,70 +361,51 @@ void AdLibSoundDriver::stopChannel(int channel) {
 		channel = 6;
 	}
 	if (ins->mode == 0 || channel == 6) {
-		OPLWriteReg(_opl, 0xB0 | channel, 0);
+		_opl->writeReg(0xB0 | channel, 0);
 	}
 	if (ins->mode != 0) {
 		_vibrato &= ~(1 << (10 - ins->channel));
-		OPLWriteReg(_opl, 0xBD, _vibrato);
+		_opl->writeReg(0xBD, _vibrato);
 	}
 }
 
 void AdLibSoundDriver::stopAll() {
 	for (int i = 0; i < 18; ++i)
-		OPLWriteReg(_opl, 0x40 | _operatorsTable[i], 63);
+		_opl->writeReg(0x40 | _operatorsTable[i], 63);
 
 	for (int i = 0; i < 9; ++i)
-		OPLWriteReg(_opl, 0xB0 | i, 0);
-
-	OPLWriteReg(_opl, 0xBD, 0);
-}
+		_opl->writeReg(0xB0 | i, 0);
 
-int AdLibSoundDriver::readBuffer(int16 *buffer, const int numSamples) {
-	update(buffer, numSamples);
-	return numSamples;
+	_opl->writeReg(0xBD, 0);
 }
 
 void AdLibSoundDriver::initCard() {
 	_vibrato = 0x20;
-	OPLWriteReg(_opl, 0xBD, _vibrato);
-	OPLWriteReg(_opl, 0x08, 0x40);
+	_opl->writeReg(0xBD, _vibrato);
+	_opl->writeReg(0x08, 0x40);
 
 	static const int oplRegs[] = { 0x40, 0x60, 0x80, 0x20, 0xE0 };
 
 	for (int i = 0; i < 9; ++i) {
-		OPLWriteReg(_opl, 0xB0 | i, 0);
+		_opl->writeReg(0xB0 | i, 0);
 	}
 	for (int i = 0; i < 9; ++i) {
-		OPLWriteReg(_opl, 0xC0 | i, 0);
+		_opl->writeReg(0xC0 | i, 0);
 	}
 
 	for (int j = 0; j < 5; j++) {
 		for (int i = 0; i < 18; ++i) {
-			OPLWriteReg(_opl, oplRegs[j] | _operatorsTable[i], 0);
+			_opl->writeReg(oplRegs[j] | _operatorsTable[i], 0);
 		}
 	}
 
-	OPLWriteReg(_opl, 1, 0x20);
-	OPLWriteReg(_opl, 1, 0);
+	_opl->writeReg(1, 0x20);
+	_opl->writeReg(1, 0);
 }
 
-void AdLibSoundDriver::update(int16 *buf, int len) {
-	static int samplesLeft = 0;
-	while (len != 0) {
-		int count = samplesLeft;
-		if (count > len) {
-			count = len;
-		}
-		samplesLeft -= count;
-		len -= count;
-		YM3812UpdateOne(_opl, buf, count);
-		if (samplesLeft == 0) {
-			if (_upCb) {
-				(*_upCb)(_upRef);
-			}
-			samplesLeft = _sampleRate / 50;
-		}
-		buf += count;
+void AdLibSoundDriver::onTimer() {
+	if (_upCb) {
+		(*_upCb)(_upRef);
 	}
 }
 
@@ -457,32 +431,32 @@ void AdLibSoundDriver::setupInstrument(const AdLibSoundInstrument *ins, int chan
 
 	if (ins->mode == 0 || ins->channel == 6) {
 		reg = &ins->regMod;
-		OPLWriteReg(_opl, 0x20 | mod, reg->vibrato);
+		_opl->writeReg(0x20 | mod, reg->vibrato);
 		if (reg->freqMod) {
 			tmp = reg->outputLevel & 0x3F;
 		} else {
 			tmp = (63 - (reg->outputLevel & 0x3F)) * _channelsVolumeTable[channel].adjusted;
 			tmp = 63 - (2 * tmp + 127) / (2 * 127);
 		}
-		OPLWriteReg(_opl, 0x40 | mod, tmp | (reg->keyScaling << 6));
-		OPLWriteReg(_opl, 0x60 | mod, reg->attackDecay);
-		OPLWriteReg(_opl, 0x80 | mod, reg->sustainRelease);
+		_opl->writeReg(0x40 | mod, tmp | (reg->keyScaling << 6));
+		_opl->writeReg(0x60 | mod, reg->attackDecay);
+		_opl->writeReg(0x80 | mod, reg->sustainRelease);
 		if (ins->mode != 0) {
-			OPLWriteReg(_opl, 0xC0 | ins->channel, reg->feedbackStrength);
+			_opl->writeReg(0xC0 | ins->channel, reg->feedbackStrength);
 		} else {
-			OPLWriteReg(_opl, 0xC0 | channel, reg->feedbackStrength);
+			_opl->writeReg(0xC0 | channel, reg->feedbackStrength);
 		}
-		OPLWriteReg(_opl, 0xE0 | mod, ins->waveSelectMod);
+		_opl->writeReg(0xE0 | mod, ins->waveSelectMod);
 	}
 
 	reg = &ins->regCar;
-	OPLWriteReg(_opl, 0x20 | car, reg->vibrato);
+	_opl->writeReg(0x20 | car, reg->vibrato);
 	tmp = (63 - (reg->outputLevel & 0x3F)) * _channelsVolumeTable[channel].adjusted;
 	tmp = 63 - (2 * tmp + 127) / (2 * 127);
-	OPLWriteReg(_opl, 0x40 | car, tmp | (reg->keyScaling << 6));
-	OPLWriteReg(_opl, 0x60 | car, reg->attackDecay);
-	OPLWriteReg(_opl, 0x80 | car, reg->sustainRelease);
-	OPLWriteReg(_opl, 0xE0 | car, ins->waveSelectCar);
+	_opl->writeReg(0x40 | car, tmp | (reg->keyScaling << 6));
+	_opl->writeReg(0x60 | car, reg->attackDecay);
+	_opl->writeReg(0x80 | car, reg->sustainRelease);
+	_opl->writeReg(0xE0 | car, ins->waveSelectCar);
 }
 
 void AdLibSoundDriver::loadRegisterInstrument(const byte *data, AdLibRegisterSoundInstrument *reg) {
@@ -551,15 +525,15 @@ void AdLibSoundDriverADL::setChannelFrequency(int channel, int frequency) {
 	}
 
 	freq = _freqTable[note % 12];
-	OPLWriteReg(_opl, 0xA0 | channel, freq);
+	_opl->writeReg(0xA0 | channel, freq);
 	freq = ((note / 12) << 2) | ((freq & 0x300) >> 8);
 	if (ins->mode == 0) {
 		freq |= 0x20;
 	}
-	OPLWriteReg(_opl, 0xB0 | channel, freq);
+	_opl->writeReg(0xB0 | channel, freq);
 	if (ins->mode != 0) {
 		_vibrato |= 1 << (10 - channel);
-		OPLWriteReg(_opl, 0xBD, _vibrato);
+		_opl->writeReg(0xBD, _vibrato);
 	}
 }
 
@@ -570,11 +544,11 @@ void AdLibSoundDriverADL::playSample(const byte *data, int size, int channel, in
 	setupInstrument(data, channel);
 	AdLibSoundInstrument *ins = &_instrumentsTable[channel];
 	if (ins->mode != 0 && ins->channel == 6) {
-		OPLWriteReg(_opl, 0xB0 | channel, 0);
+		_opl->writeReg(0xB0 | channel, 0);
 	}
 	if (ins->mode != 0) {
 		_vibrato &= ~(1 << (10 - ins->channel));
-		OPLWriteReg(_opl, 0xBD, _vibrato);
+		_opl->writeReg(0xBD, _vibrato);
 	}
 	if (ins->mode != 0) {
 		channel = ins->channel;
@@ -589,15 +563,15 @@ void AdLibSoundDriverADL::playSample(const byte *data, int size, int channel, in
 		note = ins->amDepth;
 	}
 	int freq = _freqTable[note % 12];
-	OPLWriteReg(_opl, 0xA0 | channel, freq);
+	_opl->writeReg(0xA0 | channel, freq);
 	freq = ((note / 12) << 2) | ((freq & 0x300) >> 8);
 	if (ins->mode == 0) {
 		freq |= 0x20;
 	}
-	OPLWriteReg(_opl, 0xB0 | channel, freq);
+	_opl->writeReg(0xB0 | channel, freq);
 	if (ins->mode != 0) {
 		_vibrato |= 1 << (10 - channel);
-		OPLWriteReg(_opl, 0xBD, _vibrato);
+		_opl->writeReg(0xBD, _vibrato);
 	}
 }
 
diff --git a/engines/drascula/actors.cpp b/engines/drascula/actors.cpp
index 51148bbc05..849e2ccd24 100644
--- a/engines/drascula/actors.cpp
+++ b/engines/drascula/actors.cpp
@@ -396,6 +396,16 @@ void DrasculaEngine::increaseFrameNum() {
 		curHeight = (int)newHeight;
 		curWidth = (int)newWidth;
 	}
+	
+	// Fix bug #5903 DRASCULA-IT: Crash/graphic glitch at castle towers
+	// Chapter 5 Room 45 is the castle tower part
+	// Fixing the character's coordinate(0,0) in the tower section to prevent out of window coordinates and crash
+	if ((currentChapter == 5) && (_roomNumber == 45)) {
+		curY = 0;
+		curX = 0;
+		curHeight = 0;
+		curWidth = 0;
+	}
 }
 
 void DrasculaEngine::walkDown() {
diff --git a/engines/drascula/talk.cpp b/engines/drascula/talk.cpp
index ed29dc5fe4..e9fec868f8 100644
--- a/engines/drascula/talk.cpp
+++ b/engines/drascula/talk.cpp
@@ -379,6 +379,11 @@ void DrasculaEngine::talk(const char *said, const char *filename) {
 
 	int y_mask_talk = 170;
 	int face;
+	
+	// Fix bug #5903 DRASCULA-IT: Crash/graphic glitch at castle towers
+	// Chapter 5 Room 45 is the castle tower part
+	// We use this variable as a condition below because at the castle towers we don't want to draw out the head 
+	bool notTowers = !((currentChapter == 5) && (_roomNumber == 45));
 
 	if (currentChapter == 6) {
 		if (flags[0] == 0 && _roomNumber == 102) {
@@ -434,44 +439,56 @@ void DrasculaEngine::talk(const char *said, const char *filename) {
 			if (currentChapter == 2)
 				copyRect(x_talk_izq[face], y_mask_talk, curX + 8, curY - 1, TALK_WIDTH, TALK_HEIGHT,
 						extraSurface, screenSurface);
-			else
+			else if (notTowers) {
 				reduce_hare_chico(x_talk_izq[face], y_mask_talk, curX + (int)((8.0f / 100) * factor_red[MIN(201, curY + curHeight)]),
-						curY, TALK_WIDTH, TALK_HEIGHT, factor_red[MIN(201, curY + curHeight)],
-						extraSurface, screenSurface);
-
+					curY, TALK_WIDTH, TALK_HEIGHT, factor_red[MIN(201, curY + curHeight)],
+					extraSurface, screenSurface);
+			}
 			updateRefresh();
 		} else if (trackProtagonist == 1) {
 			if (currentChapter == 2)
 				copyRect(x_talk_dch[face], y_mask_talk, curX + 12, curY, TALK_WIDTH, TALK_HEIGHT,
 					extraSurface, screenSurface);
-			else
+			else if (notTowers) {
 				reduce_hare_chico(x_talk_dch[face], y_mask_talk, curX + (int)((12.0f / 100) * factor_red[MIN(201, curY + curHeight)]),
 					curY, TALK_WIDTH, TALK_HEIGHT, factor_red[MIN(201, curY + curHeight)], extraSurface, screenSurface);
+			}
 			updateRefresh();
 		} else if (trackProtagonist == 2) {
 			if (currentChapter == 2)
 				copyRect(x_talk_izq[face], y_mask_talk, curX + 12, curY, TALK_WIDTH, TALK_HEIGHT,
 					frontSurface, screenSurface);
-			else
+			else if (notTowers) {
 				reduce_hare_chico(x_talk_izq[face], y_mask_talk,
-						talkOffset + curX + (int)((12.0f / 100) * factor_red[MIN(201, curY + curHeight)]),
-						curY, TALK_WIDTH, TALK_HEIGHT, factor_red[MIN(201, curY + curHeight)],
-						frontSurface, screenSurface);
+					talkOffset + curX + (int)((12.0f / 100) * factor_red[MIN(201, curY + curHeight)]),
+					curY, TALK_WIDTH, TALK_HEIGHT, factor_red[MIN(201, curY + curHeight)],
+					frontSurface, screenSurface);
+			}
 			updateRefresh();
 		} else if (trackProtagonist == 3) {
 			if (currentChapter == 2)
 				copyRect(x_talk_dch[face], y_mask_talk, curX + 8, curY, TALK_WIDTH, TALK_HEIGHT,
 					frontSurface, screenSurface);
-			else
+			else if (notTowers) {
 				reduce_hare_chico(x_talk_dch[face], y_mask_talk,
-						talkOffset + curX + (int)((8.0f / 100) * factor_red[MIN(201, curY + curHeight)]),
-						curY, TALK_WIDTH,TALK_HEIGHT, factor_red[MIN(201, curY + curHeight)],
-						frontSurface, screenSurface);
+					talkOffset + curX + (int)((8.0f / 100) * factor_red[MIN(201, curY + curHeight)]),
+					curY, TALK_WIDTH, TALK_HEIGHT, factor_red[MIN(201, curY + curHeight)],
+					frontSurface, screenSurface);
+			}
 			updateRefresh();
 		}
 
-		if (!_subtitlesDisabled)
-			centerText(said, curX, curY);
+		// Fix bug #5903 DRASCULA-IT: Crash/graphic glitch at castle towers
+		// Without the head we have to fix the subtitle's coordinates(upper-center) at the tower section
+		if (!_subtitlesDisabled) {
+			if (notTowers) {
+				centerText(said, curX, curY);
+			}
+			else {
+				centerText(said, 160, 25);
+			}
+		}
+	
 
 		updateScreen();
 		updateEvents();
diff --git a/engines/fullpipe/gameloader.cpp b/engines/fullpipe/gameloader.cpp
index fbf96b3060..68b63d398a 100644
--- a/engines/fullpipe/gameloader.cpp
+++ b/engines/fullpipe/gameloader.cpp
@@ -323,7 +323,7 @@ bool preloadCallback(PreloadItem &pre, int flag) {
 
 		if (!g_fp->_loaderScene) {
 			g_fp->_gameLoader->loadScene(SC_LDR);
-			g_fp->_loaderScene = g_fp->accessScene(SC_LDR);;
+			g_fp->_loaderScene = g_fp->accessScene(SC_LDR);
 		}
 
 		StaticANIObject *pbar = g_fp->_loaderScene->getStaticANIObject1ById(ANI_PBAR, -1);
@@ -419,7 +419,7 @@ bool GameLoader::unloadScene(int sceneId) {
 	if (_sc2array[sceneTag]._isLoaded)
 		saveScenePicAniInfos(sceneId);
 
-	_sc2array[sceneTag]._motionController->freeItems();
+	_sc2array[sceneTag]._motionController->detachAllObjects();
 
 	delete tag->_scene;
 	tag->_scene = 0;
diff --git a/engines/fullpipe/interaction.cpp b/engines/fullpipe/interaction.cpp
index 84e9688e30..4aac3485f4 100644
--- a/engines/fullpipe/interaction.cpp
+++ b/engines/fullpipe/interaction.cpp
@@ -311,7 +311,7 @@ LABEL_38:
 
 		if (abs(xpos - subj->_ox) > 1 || abs(ypos - subj->_oy) > 1
 				|| (inter->_staticsId2 != 0 && (subj->_statics == 0 || subj->_statics->_staticsId != inter->_staticsId2))) {
-			mq = getSc2MctlCompoundBySceneId(g_fp->_currentScene->_sceneId)->method34(subj, xpos, ypos, 1, inter->_staticsId2);
+			mq = getSc2MctlCompoundBySceneId(g_fp->_currentScene->_sceneId)->startMove(subj, xpos, ypos, 1, inter->_staticsId2);
 
 			if (!mq)
 				return false;
diff --git a/engines/fullpipe/lift.cpp b/engines/fullpipe/lift.cpp
index 9a3d91540a..d066c89d4a 100644
--- a/engines/fullpipe/lift.cpp
+++ b/engines/fullpipe/lift.cpp
@@ -324,7 +324,7 @@ void FullpipeEngine::lift_walkAndGo() {
 	ExCommand *ex;
 
 	if (abs(_liftX - _aniMan->_ox) > 1 || abs(_liftY - _aniMan->_oy) > 1 || _aniMan->_movement || _aniMan->_statics->_staticsId != ST_MAN_UP) {
-		mq = getCurrSceneSc2MotionController()->method34(_aniMan, _liftX, _liftY, 1, ST_MAN_UP);
+		mq = getCurrSceneSc2MotionController()->startMove(_aniMan, _liftX, _liftY, 1, ST_MAN_UP);
 
 		if (mq) {
 			ex = new ExCommand(0, 17, MSG_LIFT_CLICKBUTTON, 0, 0, 0, 1, 0, 0, 0);
diff --git a/engines/fullpipe/messagehandlers.cpp b/engines/fullpipe/messagehandlers.cpp
index d4f79d1dd8..94754ad22a 100644
--- a/engines/fullpipe/messagehandlers.cpp
+++ b/engines/fullpipe/messagehandlers.cpp
@@ -781,7 +781,7 @@ int MovGraph_messageHandler(ExCommand *cmd) {
 		int off = (node->_field_14 >> 16) & 0xFF;
 		double off2 = ((link->_movGraphNode2->_field_14 >> 8) & 0xff) - off;
 
-		top = off + (int)(sqrt(sq) * off2 / link->_distance);
+		top = off + (int)(sqrt(sq) * off2 / link->_z);
 	} else {
 		top = (gr->calcOffset(ani->_ox, ani->_oy)->_field_14 >> 8) & 0xff;
 	}
diff --git a/engines/fullpipe/modal.cpp b/engines/fullpipe/modal.cpp
index 2fd7ef0c21..096323781f 100644
--- a/engines/fullpipe/modal.cpp
+++ b/engines/fullpipe/modal.cpp
@@ -305,7 +305,7 @@ bool ModalMap::init(int counterdiff) {
 
 	if (_flag) {
 		_rect2.left = _mouseX + _field_38 - g_fp->_mouseScreenPos.x;
-		_rect2.top = _mouseY + _field_3C - g_fp->_mouseScreenPos.y;;
+		_rect2.top = _mouseY + _field_3C - g_fp->_mouseScreenPos.y;
 		_rect2.right = _rect2.left + 800;
 		_rect2.bottom = _rect2.top + 600;
 
diff --git a/engines/fullpipe/motion.cpp b/engines/fullpipe/motion.cpp
index 9573e0517b..1a61cb742a 100644
--- a/engines/fullpipe/motion.cpp
+++ b/engines/fullpipe/motion.cpp
@@ -88,7 +88,7 @@ bool MctlCompound::load(MfcArchive &file) {
 
 	for (int i = 0; i < count; i++) {
 		debug(6, "CompoundArray[%d]", i);
-		MctlCompoundArrayItem *obj = new MctlCompoundArrayItem();
+		MctlItem *obj = new MctlItem();
 
 		obj->_motionControllerObj = (MotionController *)file.readClass();
 
@@ -114,14 +114,14 @@ bool MctlCompound::load(MfcArchive &file) {
 	return true;
 }
 
-void MctlCompound::addObject(StaticANIObject *obj) {
+void MctlCompound::attachObject(StaticANIObject *obj) {
 	for (uint i = 0; i < _motionControllers.size(); i++)
-		_motionControllers[i]->_motionControllerObj->addObject(obj);
+		_motionControllers[i]->_motionControllerObj->attachObject(obj);
 }
 
-int MctlCompound::removeObject(StaticANIObject *obj) {
+int MctlCompound::detachObject(StaticANIObject *obj) {
 	for (uint i = 0; i < _motionControllers.size(); i++)
-		_motionControllers[i]->_motionControllerObj->removeObject(obj);
+		_motionControllers[i]->_motionControllerObj->detachObject(obj);
 
 	return 1;
 }
@@ -150,12 +150,12 @@ void MctlCompound::initMovGraph2() {
 	}
 }
 
-void MctlCompound::freeItems() {
+void MctlCompound::detachAllObjects() {
 	for (uint i = 0; i < _motionControllers.size(); i++)
-		_motionControllers[i]->_motionControllerObj->freeItems();
+		_motionControllers[i]->_motionControllerObj->detachAllObjects();
 }
 
-MessageQueue *MctlCompound::method34(StaticANIObject *ani, int sourceX, int sourceY, int fuzzyMatch, int staticsId) {
+MessageQueue *MctlCompound::startMove(StaticANIObject *ani, int sourceX, int sourceY, int fuzzyMatch, int staticsId) {
 	int idx = -1;
 	int sourceIdx = -1;
 
@@ -187,7 +187,7 @@ MessageQueue *MctlCompound::method34(StaticANIObject *ani, int sourceX, int sour
 		return 0;
 
 	if (idx == sourceIdx)
-		return _motionControllers[idx]->_motionControllerObj->method34(ani, sourceX, sourceY, fuzzyMatch, staticsId);
+		return _motionControllers[idx]->_motionControllerObj->startMove(ani, sourceX, sourceY, fuzzyMatch, staticsId);
 
 	double dist;
 	MctlConnectionPoint *cp = findClosestConnectionPoint(ani->_ox, ani->_oy, idx, sourceX, sourceY, sourceIdx, &dist);
@@ -195,7 +195,7 @@ MessageQueue *MctlCompound::method34(StaticANIObject *ani, int sourceX, int sour
 	if (!cp)
 		return 0;
 
-	MessageQueue *mq = _motionControllers[idx]->_motionControllerObj->doWalkTo(ani, cp->_connectionX, cp->_connectionY, 1, cp->_field_14);
+	MessageQueue *mq = _motionControllers[idx]->_motionControllerObj->doWalkTo(ani, cp->_connectionX, cp->_connectionY, 1, cp->_mctlmirror);
 
 	if (!mq)
 		return 0;
@@ -264,7 +264,7 @@ MessageQueue *MctlCompound::doWalkTo(StaticANIObject *subj, int xpos, int ypos,
 	if (!closestP)
 		return 0;
 
-	MessageQueue *mq = _motionControllers[match1]->_motionControllerObj->doWalkTo(subj, closestP->_connectionX, closestP->_connectionY, 1, closestP->_field_14);
+	MessageQueue *mq = _motionControllers[match1]->_motionControllerObj->doWalkTo(subj, closestP->_connectionX, closestP->_connectionY, 1, closestP->_mctlmirror);
 
 	ExCommand *ex;
 
@@ -287,7 +287,7 @@ MessageQueue *MctlCompound::doWalkTo(StaticANIObject *subj, int xpos, int ypos,
 	return mq;
 }
 
-MctlCompoundArrayItem::~MctlCompoundArrayItem() {
+MctlItem::~MctlItem() {
 	delete _movGraphReactObj;
 	delete _motionControllerObj;
 }
@@ -304,7 +304,7 @@ MctlLadder::MctlLadder() {
 }
 
 MctlLadder::~MctlLadder() {
-	freeItems();
+	detachAllObjects();
 }
 
 int MctlLadder::collisionDetection(StaticANIObject *man) {
@@ -326,7 +326,7 @@ int MctlLadder::collisionDetection(StaticANIObject *man) {
 	return res;
 }
 
-void MctlLadder::addObject(StaticANIObject *obj) {
+void MctlLadder::attachObject(StaticANIObject *obj) {
 	if (findObjectPos(obj) < 0) {
 		MctlLadderMovement *movement = new MctlLadderMovement;
 
@@ -391,7 +391,7 @@ bool MctlLadder::initMovement(StaticANIObject *ani, MctlLadderMovement *movement
 	return true;
 }
 
-void MctlLadder::freeItems() {
+void MctlLadder::detachAllObjects() {
 	_mgm.clear();
 
 	for (uint i = 0; i < _ladmovements.size(); i++) {
@@ -402,7 +402,7 @@ void MctlLadder::freeItems() {
 	_ladmovements.clear();
 }
 
-MessageQueue *MctlLadder::method34(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId) {
+MessageQueue *MctlLadder::startMove(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId) {
 	MessageQueue *mq = doWalkTo(subj, xpos, ypos, fuzzyMatch, staticsId);
 
 	if (mq) {
@@ -661,7 +661,7 @@ void MctlCompound::replaceNodeX(int from, int to) {
 					node->_x = to;
 			}
 
-			gr->calcNodeDistancesAndAngles();
+			gr->recalcLinkParams();
 		}
 	}
 }
@@ -669,10 +669,9 @@ void MctlCompound::replaceNodeX(int from, int to) {
 MctlConnectionPoint::MctlConnectionPoint() {
 	_connectionX = 0;
 	_connectionY = 0;
-	_field_C = 0;
-	_field_10 = 0;
-	_field_14 = 0;
-	_field_16 = 0;
+	_mctlflags = 0;
+	_mctlstatic = 0;
+	_mctlmirror = 0;
 	_messageQueueObj = 0;
 	_motionControllerObj = 0;
 }
@@ -779,7 +778,7 @@ bool MovGraph::load(MfcArchive &file) {
 	return true;
 }
 
-void MovGraph::addObject(StaticANIObject *obj) {
+void MovGraph::attachObject(StaticANIObject *obj) {
 	_mgm.clear();
 	_mgm.addItem(obj->_id);
 
@@ -796,13 +795,13 @@ void MovGraph::addObject(StaticANIObject *obj) {
 	_mgm.addItem(obj->_id); // FIXME: Is it really needed?
 }
 
-int MovGraph::removeObject(StaticANIObject *obj) {
-	warning("STUB: MovGraph::removeObject()");
+int MovGraph::detachObject(StaticANIObject *obj) {
+	warning("STUB: MovGraph::detachObject()");
 
 	return 0;
 }
 
-void MovGraph::freeItems() {
+void MovGraph::detachAllObjects() {
 	for (uint i = 0; i < _items.size(); i++) {
 		_items[i]->free();
 
@@ -812,7 +811,7 @@ void MovGraph::freeItems() {
 	_items.clear();
 }
 
-Common::Array<MovItem *> *MovGraph::method28(StaticANIObject *ani, int x, int y, int flag1, int *rescount) {
+Common::Array<MovItem *> *MovGraph::getPaths(StaticANIObject *ani, int x, int y, int flag1, int *rescount) {
 	*rescount = 0;
 
 	if (_items.size() <= 0)
@@ -828,7 +827,7 @@ Common::Array<MovItem *> *MovGraph::method28(StaticANIObject *ani, int x, int y,
 	}
 	_items[idx]->free();
 
-	calcNodeDistancesAndAngles();
+	recalcLinkParams();
 
 	_items[idx]->movarr._movSteps.clear();
 
@@ -838,7 +837,7 @@ Common::Array<MovItem *> *MovGraph::method28(StaticANIObject *ani, int x, int y,
 	point.y = ani->_oy;
 
 	if (!calcChunk(idx, ani->_ox, ani->_oy, &_items[idx]->movarr, 0))
-		findClosestLink(idx, &point, &_items[idx]->movarr);
+		getNearestPoint(idx, &point, &_items[idx]->movarr);
 
 	_items[idx]->count = 0;
 
@@ -873,12 +872,12 @@ Common::Array<MovItem *> *MovGraph::method28(StaticANIObject *ani, int x, int y,
 	return 0;
 }
 
-bool MovGraph::method2C(StaticANIObject *obj, int x, int y) {
+bool MovGraph::setPosImmediate(StaticANIObject *obj, int x, int y) {
 	obj->setOXY(x, y);
-	return method3C(obj, 1);
+	return resetPosition(obj, 1);
 }
 
-MessageQueue *MovGraph::method34(StaticANIObject *ani, int xpos, int ypos, int fuzzyMatch, int staticsId) {
+MessageQueue *MovGraph::startMove(StaticANIObject *ani, int xpos, int ypos, int fuzzyMatch, int staticsId) {
 	if (!ani) {
 		if (!_items.size())
 			return 0;
@@ -896,7 +895,7 @@ MessageQueue *MovGraph::method34(StaticANIObject *ani, int xpos, int ypos, int f
 		return 0;
 
 	int count;
-	Common::Array<MovItem *> *movitems = method28(ani, xpos, ypos, fuzzyMatch, &count);
+	Common::Array<MovItem *> *movitems = getPaths(ani, xpos, ypos, fuzzyMatch, &count);
 
 	if (!movitems)
 		return 0;
@@ -941,9 +940,9 @@ MessageQueue *MovGraph::method34(StaticANIObject *ani, int xpos, int ypos, int f
 		int count2;
 
 		ani->setSomeDynamicPhaseIndex(ex->_field_14);
-		method28(ani, xpos, ypos, fuzzyMatch, &count2);
+		getPaths(ani, xpos, ypos, fuzzyMatch, &count2);
 
-		int idx = getItemIndexByStaticAni(ani);
+		int idx = getObjectIndex(ani);
 		count = _items[idx]->count;
 		movitems = _items[idx]->movitems;
 	}
@@ -951,12 +950,12 @@ MessageQueue *MovGraph::method34(StaticANIObject *ani, int xpos, int ypos, int f
 	return method50(ani, _callback1(ani, movitems, count), staticsId);
 }
 
-void MovGraph::changeCallback(MovArr *(*callback1)(StaticANIObject *ani, Common::Array<MovItem *> *items, signed int counter)) {
+void MovGraph::setSelFunc(MovArr *(*callback1)(StaticANIObject *ani, Common::Array<MovItem *> *items, signed int counter)) {
 	_callback1 = callback1;
 }
 
-bool MovGraph::method3C(StaticANIObject *ani, int flag) {
-	int idx = getItemIndexByStaticAni(ani);
+bool MovGraph::resetPosition(StaticANIObject *ani, int flag) {
+	int idx = getObjectIndex(ani);
 
 	if (idx == -1)
 		return false;
@@ -967,7 +966,7 @@ bool MovGraph::method3C(StaticANIObject *ani, int flag) {
 	point.x = ani->_ox;
 	point.y = ani->_oy;
 
-	findClosestLink(idx, &point, &movarr);
+	getNearestPoint(idx, &point, &movarr);
 	ani->setOXY(point.x, point.y);
 
 	if (flag) {
@@ -990,15 +989,15 @@ bool MovGraph::method3C(StaticANIObject *ani, int flag) {
 	return true;
 }
 
-bool MovGraph::method44(StaticANIObject *ani, int x, int y) {
-	int idx = getItemIndexByStaticAni(ani);
+bool MovGraph::canDropInventory(StaticANIObject *ani, int x, int y) {
+	int idx = getObjectIndex(ani);
 	MovArr m;
 
 	if (idx != -1) {
 		if (x != -1 || y != -1) {
 			int counter;
 
-			Common::Array<MovItem *> *movitem = method28(ani, x, y, 0, &counter);
+			Common::Array<MovItem *> *movitem = getPaths(ani, x, y, 0, &counter);
 
 			if (movitem) {
 				MovArr *movarr = _callback1(ani, movitem, counter);
@@ -1021,13 +1020,13 @@ MessageQueue *MovGraph::doWalkTo(StaticANIObject *subj, int xpos, int ypos, int
 	PicAniInfo picAniInfo;
 	int ss;
 
-	Common::Array<MovItem *> *movitem = method28(subj, xpos, ypos, fuzzyMatch, &ss);
+	Common::Array<MovItem *> *movitem = getPaths(subj, xpos, ypos, fuzzyMatch, &ss);
 
 	subj->getPicAniInfo(&picAniInfo);
 
 	if (movitem) {
 		MovArr *goal = _callback1(subj, movitem, ss);
-		int idx = getItemIndexByStaticAni(subj);
+		int idx = getObjectIndex(subj);
 
 		for (int i = 0; i < _items[idx]->count; i++) {
 			if ((*_items[idx]->movitems)[i]->movarr == goal) {
@@ -1052,10 +1051,10 @@ MessageQueue *MovGraph::doWalkTo(StaticANIObject *subj, int xpos, int ypos, int
 		}
 	}
 
-	movitem = method28(subj, xpos, ypos, fuzzyMatch, &ss);
+	movitem = getPaths(subj, xpos, ypos, fuzzyMatch, &ss);
 	if (movitem) {
 		MovArr *goal = _callback1(subj, movitem, ss);
-		int idx = getItemIndexByStaticAni(subj);
+		int idx = getObjectIndex(subj);
 
 		if (_items[idx]->count > 0) {
 			int arridx = 0;
@@ -1106,7 +1105,7 @@ MessageQueue *MovGraph::sub1(StaticANIObject *ani, int x, int y, int stid, int x
 
 	int rescount;
 
-	Common::Array<MovItem *> *movitems = method28(ani, x1, y1, flag1, &rescount);
+	Common::Array<MovItem *> *movitems = getPaths(ani, x1, y1, flag1, &rescount);
 
 	if (!movitems) {
 		ani->setPicAniInfo(&picinfo);
@@ -1117,7 +1116,7 @@ MessageQueue *MovGraph::sub1(StaticANIObject *ani, int x, int y, int stid, int x
 	MessageQueue *res = 0;
 
 	MovArr *goal = _callback1(ani, movitems, rescount);
-	int idx = getItemIndexByStaticAni(ani);
+	int idx = getObjectIndex(ani);
 
 	MovGraphItem *movgitem = _items[idx];
 	int cnt = movgitem->count;
@@ -1177,16 +1176,16 @@ MessageQueue *MovGraph::fillMGMinfo(StaticANIObject *ani, MovArr *movarr, int st
 		if (i == movarr->_movStepCount - 1) {
 			nx = movarr->_point.x;
 			ny = movarr->_point.y;
-			nd = st->link->_movGraphNode1->_distance;
+			nd = st->link->_movGraphNode1->_z;
 		} else {
 			if (st->sfield_0) {
 				nx = st->link->_movGraphNode1->_x;
 				ny = st->link->_movGraphNode1->_y;
-				nd = st->link->_movGraphNode1->_distance;
+				nd = st->link->_movGraphNode1->_z;
 			} else {
 				nx = st->link->_movGraphNode2->_x;
 				ny = st->link->_movGraphNode2->_y;
-				nd = st->link->_movGraphNode2->_distance;
+				nd = st->link->_movGraphNode2->_z;
 			}
 		}
 
@@ -1232,7 +1231,7 @@ MessageQueue *MovGraph::method50(StaticANIObject *ani, MovArr *movarr, int stati
 		return 0;
 
 	uint idx;
-	int movidx;
+	int movidx = 0;
 	bool done = false;
 
 	for (idx = 0; idx <= _items.size() && !done; idx++) {
@@ -1294,14 +1293,14 @@ double MovGraph::calcDistance(Common::Point *point, MovGraphLink *link, int fuzz
 	double dist2x = (double)(n2x - n1x);
 	double dist2y = (double)(n2y - n1y);
 	double dist1 = sqrt(dist1y * dist1y + dist1x * dist1x);
-	double dist2 = ((double)(n1y - n2y) * dist1y + dist2x * dist1x) / link->_distance / dist1;
+	double dist2 = ((double)(n1y - n2y) * dist1y + dist2x * dist1x) / link->_z / dist1;
 	double distm = dist2 * dist1;
 	double res = sqrt(1.0 - dist2 * dist2) * dist1;
 
-	if (dist2 <= 0.0 || distm >= link->_distance) {
+	if (dist2 <= 0.0 || distm >= link->_z) {
 		if (fuzzyMatch) {
 			if (dist2 > 0.0) {
-				if (distm >= link->_distance) {
+				if (distm >= link->_z) {
 					point->x = n2x;
 					point->y = n2y;
 				}
@@ -1313,14 +1312,14 @@ double MovGraph::calcDistance(Common::Point *point, MovGraphLink *link, int fuzz
 			return -1.0;
 		}
 	} else {
-		point->x = (int)(n1x + (dist2x * distm / link->_distance));
-		point->y = (int)(n1y + (dist2y * distm / link->_distance));
+		point->x = (int)(n1x + (dist2x * distm / link->_z));
+		point->y = (int)(n1y + (dist2y * distm / link->_z));
 	}
 
 	return res;
 }
 
-void MovGraph::calcNodeDistancesAndAngles() {
+void MovGraph::recalcLinkParams() {
 	for (ObList::iterator i = _links.begin(); i != _links.end(); ++i) {
 		assert(((CObject *)*i)->_objtype == kObjTypeMovGraphLink);
 
@@ -1328,11 +1327,11 @@ void MovGraph::calcNodeDistancesAndAngles() {
 
 		lnk->_flags &= 0x7FFFFFFF;
 
-		lnk->calcNodeDistanceAndAngle();
+		lnk->recalcLength();
 	}
 }
 
-bool MovGraph::findClosestLink(int unusedArg, Common::Point *p, MovArr *movarr) {
+bool MovGraph::getNearestPoint(int unusedArg, Common::Point *p, MovArr *movarr) {
 	MovGraphLink *link = 0;
 	double mindist = 1.0e20;
 	int resx = 0, resy = 0;
@@ -1348,7 +1347,7 @@ bool MovGraph::findClosestLink(int unusedArg, Common::Point *p, MovArr *movarr)
 			double dx3 = lnk->_movGraphNode2->_x - lnk->_movGraphNode1->_x;
 			double dy3 = lnk->_movGraphNode2->_y - lnk->_movGraphNode1->_y;
 			double sq1 = sqrt(dy1 * dy1 + dx1 * dx1);
-			double sdist = (dy3 * dy1 + dx3 * dx1) / lnk->_distance / sq1;
+			double sdist = (dy3 * dy1 + dx3 * dx1) / lnk->_z / sq1;
 			double ldist = sdist * sq1;
 			double dist = sqrt(1.0 - sdist * sdist) * sq1;
 
@@ -1357,14 +1356,14 @@ bool MovGraph::findClosestLink(int unusedArg, Common::Point *p, MovArr *movarr)
 				dist = sqrt(dx1 * dx1 + dy1 * dy1);
 			}
 
-			if (ldist > lnk->_distance) {
-				ldist = lnk->_distance;
+			if (ldist > lnk->_z) {
+				ldist = lnk->_z;
 				dist = sqrt(dx2 * dx2 + dy2 * dy2);
 			}
 
-			if (ldist >= 0.0 && ldist <= lnk->_distance && dist < mindist) {
-				resx = lnk->_movGraphNode1->_x + (int)(dx3 * ldist / lnk->_distance);
-				resy = lnk->_movGraphNode1->_y + (int)(dy3 * ldist / lnk->_distance);
+			if (ldist >= 0.0 && ldist <= lnk->_z && dist < mindist) {
+				resx = lnk->_movGraphNode1->_x + (int)(dx3 * ldist / lnk->_z);
+				resy = lnk->_movGraphNode1->_y + (int)(dy3 * ldist / lnk->_z);
 
 				mindist = dist;
 				link = lnk;
@@ -1387,7 +1386,7 @@ bool MovGraph::findClosestLink(int unusedArg, Common::Point *p, MovArr *movarr)
 	return false;
 }
 
-int MovGraph::getItemIndexByStaticAni(StaticANIObject *ani) {
+int MovGraph::getObjectIndex(StaticANIObject *ani) {
 	for (uint i = 0; i < _items.size(); i++)
 		if (_items[i]->ani == ani)
 			return i;
@@ -1418,7 +1417,7 @@ Common::Array<MovArr *> *MovGraph::genMovArr(int x, int y, int *arrSize, int fla
 				movarr->_link = lnk;
 				movarr->_dist = ((double)(lnk->_movGraphNode1->_y - lnk->_movGraphNode2->_y) * (double)(lnk->_movGraphNode1->_y - point.y) +
 								 (double)(lnk->_movGraphNode2->_x - lnk->_movGraphNode1->_x) * (double)(point.x - lnk->_movGraphNode1->_x)) /
-					lnk->_distance / lnk->_distance;
+					lnk->_z / lnk->_z;
 				movarr->_point = point;
 
 				arr->push_back(movarr);
@@ -1447,7 +1446,7 @@ Common::Array<MovArr *> *MovGraph::genMovArr(int x, int y, int *arrSize, int fla
 						movarr->_link = lnk;
 						movarr->_dist = ((double)(lnk->_movGraphNode1->_y - lnk->_movGraphNode2->_y) * (double)(lnk->_movGraphNode1->_y - y) +
 										 (double)(lnk->_movGraphNode2->_x - lnk->_movGraphNode1->_x) * (double)(x - lnk->_movGraphNode1->_x)) /
-							lnk->_distance / lnk->_distance;
+							lnk->_z / lnk->_z;
 						movarr->_point.x = x;
 						movarr->_point.y = y;
 
@@ -1548,7 +1547,7 @@ bool MovGraph::calcChunk(int idx, int x, int y, MovArr *arr, int a6) {
 	Common::Array<MovArr *> *movarr = genMovArr(x, y, &arrSize, 0, 1);
 
 	if (!movarr)
-		return findClosestLink(idx, 0, arr);
+		return getNearestPoint(idx, 0, arr);
 
 	bool res = false;
 
@@ -1777,8 +1776,8 @@ bool MovGraph2::initDirections(StaticANIObject *obj, MovGraph2Item *item) {
 	return true;
 }
 
-void MovGraph2::addObject(StaticANIObject *obj) {
-	MovGraph::addObject(obj);
+void MovGraph2::attachObject(StaticANIObject *obj) {
+	MovGraph::attachObject(obj);
 
 	int id = getItemIndexByGameObjectId(obj->_id);
 
@@ -2031,20 +2030,20 @@ MessageQueue *MovGraph2::buildMovInfo1MessageQueue(MovInfo1 *movInfo) {
 	return mq;
 }
 
-int MovGraph2::removeObject(StaticANIObject *obj) {
-	warning("STUB: MovGraph2::removeObject()");
+int MovGraph2::detachObject(StaticANIObject *obj) {
+	warning("STUB: MovGraph2::detachObject()");
 
 	return 0;
 }
 
-void MovGraph2::freeItems() {
+void MovGraph2::detachAllObjects() {
 	for (uint i = 0; i < _items2.size(); i++)
 		delete _items2[i];
 
 	_items2.clear();
 }
 
-MessageQueue *MovGraph2::method34(StaticANIObject *ani, int xpos, int ypos, int fuzzyMatch, int staticsId) {
+MessageQueue *MovGraph2::startMove(StaticANIObject *ani, int xpos, int ypos, int fuzzyMatch, int staticsId) {
 	if (!ani->isIdle())
 		return 0;
 
@@ -2240,9 +2239,9 @@ MessageQueue *MovGraph2::doWalkTo(StaticANIObject *obj, int xpos, int ypos, int
 	int dx2, dy2;
 
 	if (linkInfoSource.node)
-		movInfo1.distance1 = linkInfoSource.node->_distance;
+		movInfo1.distance1 = linkInfoSource.node->_z;
 	else
-		movInfo1.distance1 = linkInfoSource.link->_movGraphNode1->_distance;
+		movInfo1.distance1 = linkInfoSource.link->_movGraphNode1->_z;
 
 	if (linkInfoDest.node) {
 		dx2 = linkInfoDest.node->_x;
@@ -2251,16 +2250,16 @@ MessageQueue *MovGraph2::doWalkTo(StaticANIObject *obj, int xpos, int ypos, int
 		movInfo1.pt2.x = linkInfoDest.node->_x;
 		movInfo1.pt2.y = linkInfoDest.node->_y;
 
-		movInfo1.distance2 = linkInfoDest.node->_distance;
+		movInfo1.distance2 = linkInfoDest.node->_z;
 	} else {
 		movInfo1.pt2.x = xpos;
 		movInfo1.pt2.y = ypos;
 
 		MovGraphNode *nod = linkInfoDest.link->_movGraphNode1;
 		double dst1 = sqrt((double)((ypos - nod->_y) * (ypos - nod->_y) + (xpos - nod->_x) * (xpos - nod->_x)));
-		int dst = linkInfoDest.link->_movGraphNode2->_distance - nod->_distance;
+		int dst = linkInfoDest.link->_movGraphNode2->_z - nod->_z;
 
-		movInfo1.distance2 = (int)(nod->_distance + (dst1 * (double)dst / linkInfoDest.link->_distance));
+		movInfo1.distance2 = (int)(nod->_z + (dst1 * (double)dst / linkInfoDest.link->_z));
 
 		calcDistance(&movInfo1.pt2, linkInfoDest.link, 1);
 
@@ -2397,8 +2396,8 @@ int MovGraph2::findLink(Common::Array<MovGraphLink *> *linkList, int idx, Common
 		rect->bottom = node2->_y;
 	}
 	if (point) {
-		point->x = node3->_distance;
-		point->y = node2->_distance;
+		point->x = node3->_z;
+		point->y = node2->_z;
 	}
 
 	if (abs(node3->_x - node2->_x) <= abs(node3->_y - node2->_y))
@@ -2659,7 +2658,7 @@ MovGraphLink *MovGraph2::findLink2(int x, int y) {
 			double n1dx = n1x - x;
 			double n1dy = n1y - y;
 			double dst1 = sqrt(n1dy * n1dy + n1dx * n1dx);
-			double coeff1 = ((n1y - n2y) * n1dy + (n2x - n1x) * n1dx) / lnk->_distance / dst1;
+			double coeff1 = ((n1y - n2y) * n1dy + (n2x - n1x) * n1dx) / lnk->_z / dst1;
 			double dst3 = coeff1 * dst1;
 			double dst2 = sqrt(1.0 - coeff1 * coeff1) * dst1;
 
@@ -2667,11 +2666,11 @@ MovGraphLink *MovGraph2::findLink2(int x, int y) {
 				dst3 = 0.0;
 				dst2 = sqrt(n1dy * n1dy + n1dx * n1dx);
 			}
-			if (dst3 > lnk->_distance) {
-				dst3 = lnk->_distance;
+			if (dst3 > lnk->_z) {
+				dst3 = lnk->_z;
 				dst2 = sqrt((n2x - x) * (n2x - x) + (n2y - y) * (n2y - y));
 			}
-			if (dst3 >= 0.0 && dst3 <= lnk->_distance && dst2 < mindist) {
+			if (dst3 >= 0.0 && dst3 <= lnk->_z && dst2 < mindist) {
 				mindist = dst2;
 				res = lnk;
 			}
@@ -2704,11 +2703,11 @@ double MovGraph2::findMinPath(LinkInfo *linkInfoSource, LinkInfo *linkInfoDest,
 
 					double newDistance = findMinPath(&linkInfoWorkSource, linkInfoDest, &tmpList);
 
-					if (newDistance >= 0.0 && (minDistance < 0.0 || newDistance + lnk->_distance < minDistance)) {
+					if (newDistance >= 0.0 && (minDistance < 0.0 || newDistance + lnk->_z < minDistance)) {
 						listObj->clear();
 						listObj->push_back(tmpList);
 
-						minDistance = newDistance + lnk->_distance;
+						minDistance = newDistance + lnk->_z;
 					}
 
 					lnk->_flags &= 0x7FFFFFFF;
@@ -2775,7 +2774,7 @@ MovGraphNode *MovGraph::calcOffset(int ox, int oy) {
 }
 
 MovGraphLink::MovGraphLink() {
-	_distance = 0;
+	_z = 0;
 	_angle = 0;
 	_flags = 0x10000000;
 	_movGraphNode2 = 0;
@@ -2809,10 +2808,10 @@ bool MovGraphLink::load(MfcArchive &file) {
 	debug(8, "GraphNode2");
 	_movGraphNode2 = (MovGraphNode *)file.readClass();
 
-	_distance = file.readDouble();
+	_z = file.readDouble();
 	_angle = file.readDouble();
 
-	debug(8, "distance: %g, angle: %g", _distance, _angle);
+	debug(8, "distance: %g, angle: %g", _z, _angle);
 
 	_movGraphReact = (MovGraphReact *)file.readClass();
 	_name = file.readPascalString();
@@ -2820,12 +2819,12 @@ bool MovGraphLink::load(MfcArchive &file) {
 	return true;
 }
 
-void MovGraphLink::calcNodeDistanceAndAngle() {
+void MovGraphLink::recalcLength() {
 	if (_movGraphNode1) {
 		double dx = _movGraphNode2->_x - _movGraphNode1->_x;
 		double dy = _movGraphNode2->_y - _movGraphNode1->_y;
 
-		_distance = sqrt(dy * dy + dx * dx);
+		_z = sqrt(dy * dy + dx * dx);
 		_angle = atan2(dx, dy);
 	}
 }
@@ -2836,7 +2835,7 @@ bool MovGraphNode::load(MfcArchive &file) {
 	_field_14 = file.readUint32LE();
 	_x = file.readUint32LE();
 	_y = file.readUint32LE();
-	_distance = file.readUint32LE();
+	_z = file.readUint32LE();
 
 	return true;
 }
@@ -3032,7 +3031,7 @@ int startWalkTo(int objId, int objKey, int x, int y, int fuzzyMatch) {
 	MctlCompound *mc = getCurrSceneSc2MotionController();
 
 	if (mc)
-		return (mc->method34(g_fp->_currentScene->getStaticANIObject1ById(objId, objKey), x, y, fuzzyMatch, 0) != 0);
+		return (mc->startMove(g_fp->_currentScene->getStaticANIObject1ById(objId, objKey), x, y, fuzzyMatch, 0) != 0);
 
 	return 0;
 }
@@ -3042,7 +3041,7 @@ bool doSomeAnimation(int objId, int objKey, int a3) {
 	MctlCompound *cmp = getCurrSceneSc2MotionController();
 
 	if (ani && cmp)
-		return cmp->method3C(ani, a3);
+		return cmp->resetPosition(ani, a3);
 
 	return false;
 }
diff --git a/engines/fullpipe/motion.h b/engines/fullpipe/motion.h
index c488039e22..a40d810ffa 100644
--- a/engines/fullpipe/motion.h
+++ b/engines/fullpipe/motion.h
@@ -48,19 +48,19 @@ public:
 	virtual bool load(MfcArchive &file);
 	virtual void methodC() {}
 	virtual void method10() {}
-	virtual void clearEnabled() { _isEnabled = false; }
-	virtual void setEnabled() { _isEnabled = true; }
-	virtual void addObject(StaticANIObject *obj) {}
-	virtual int removeObject(StaticANIObject *obj) { return 0; }
-	virtual void freeItems() {}
-	virtual Common::Array<MovItem *> *method28(StaticANIObject *ani, int x, int y, int flag1, int *rescount) { return 0; }
-	virtual bool method2C(StaticANIObject *obj, int x, int y) { return false; }
+	virtual void deactivate() { _isEnabled = false; }
+	virtual void activate() { _isEnabled = true; }
+	virtual void attachObject(StaticANIObject *obj) {}
+	virtual int detachObject(StaticANIObject *obj) { return 0; }
+	virtual void detachAllObjects() {}
+	virtual Common::Array<MovItem *> *getPaths(StaticANIObject *ani, int x, int y, int flag1, int *rescount) { return 0; }
+	virtual bool setPosImmediate(StaticANIObject *obj, int x, int y) { return false; }
 	virtual int method30() { return 0; }
-	virtual MessageQueue *method34(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId) { return 0; }
-	virtual void changeCallback(MovArr *(*_callback1)(StaticANIObject *ani, Common::Array<MovItem *> *items, signed int counter)) {}
-	virtual bool method3C(StaticANIObject *ani, int flag) { return 0; }
+	virtual MessageQueue *startMove(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId) { return 0; }
+	virtual void setSelFunc(MovArr *(*_callback1)(StaticANIObject *ani, Common::Array<MovItem *> *items, signed int counter)) {}
+	virtual bool resetPosition(StaticANIObject *ani, int flag) { return 0; }
 	virtual int method40() { return 0; }
-	virtual bool method44(StaticANIObject *ani, int x, int y) { return false; }
+	virtual bool canDropInventory(StaticANIObject *ani, int x, int y) { return false; }
 	virtual int method48() { return -1; }
 	virtual MessageQueue *doWalkTo(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId) { return 0; }
 
@@ -82,7 +82,7 @@ public:
 	virtual bool pointInRegion(int x, int y);
 };
 
-class MctlCompoundArrayItem : public CObject {
+class MctlItem : public CObject {
 public:
 	MotionController *_motionControllerObj;
 	MovGraphReact *_movGraphReactObj;
@@ -92,11 +92,11 @@ public:
 	int _field_28;
 
 public:
-	MctlCompoundArrayItem() : _movGraphReactObj(0), _motionControllerObj(0), _field_20(0), _field_24(0), _field_28(0) {}
-	~MctlCompoundArrayItem();
+	MctlItem() : _movGraphReactObj(0), _motionControllerObj(0), _field_20(0), _field_24(0), _field_28(0) {}
+	~MctlItem();
 };
 
-class MctlCompoundArray : public Common::Array<MctlCompoundArrayItem *>, public CObject {
+class MctlCompoundArray : public Common::Array<MctlItem *>, public CObject {
  public:
 	virtual bool load(MfcArchive &file);
 };
@@ -109,10 +109,10 @@ public:
 
 	virtual bool load(MfcArchive &file);
 
-	virtual void addObject(StaticANIObject *obj);
-	virtual int removeObject(StaticANIObject *obj);
-	virtual void freeItems();
-	virtual MessageQueue *method34(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
+	virtual void attachObject(StaticANIObject *obj);
+	virtual int detachObject(StaticANIObject *obj);
+	virtual void detachAllObjects();
+	virtual MessageQueue *startMove(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
 	virtual MessageQueue *doWalkTo(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
 
 	void initMovGraph2();
@@ -156,10 +156,10 @@ public:
 	virtual ~MctlLadder();
 	int collisionDetection(StaticANIObject *man);
 
-	virtual void addObject(StaticANIObject *obj);
-	virtual int removeObject(StaticANIObject *obj) { return 1; }
-	virtual void freeItems();
-	virtual MessageQueue *method34(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
+	virtual void attachObject(StaticANIObject *obj);
+	virtual int detachObject(StaticANIObject *obj) { return 1; }
+	virtual void detachAllObjects();
+	virtual MessageQueue *startMove(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
 	virtual MessageQueue *doWalkTo(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
 
 	MessageQueue *controllerWalkTo(StaticANIObject *ani, int off);
@@ -173,12 +173,12 @@ class MovGraphNode : public CObject {
 public:
 	int _x;
 	int _y;
-	int _distance;
+	int _z;
 	int16 _field_10;
 	int _field_14;
 
 public:
-	MovGraphNode() : _x(0), _y(0), _distance(0), _field_10(0), _field_14(0) { _objtype = kObjTypeMovGraphNode; }
+	MovGraphNode() : _x(0), _y(0), _z(0), _field_10(0), _field_14(0) { _objtype = kObjTypeMovGraphNode; }
 	virtual bool load(MfcArchive &file);
 };
 
@@ -225,7 +225,7 @@ class MovGraphLink : public CObject {
 	int _flags;
 	int _field_38;
 	int _field_3C;
-	double _distance;
+	double _z;
 	double _angle;
 	MovGraphReact *_movGraphReact;
 	char *_name;
@@ -236,7 +236,7 @@ class MovGraphLink : public CObject {
 
 	virtual bool load(MfcArchive &file);
 
-	void calcNodeDistanceAndAngle();
+	void recalcLength();
 };
 
 struct MovStep {
@@ -290,23 +290,23 @@ public:
 
 	virtual bool load(MfcArchive &file);
 
-	virtual void addObject(StaticANIObject *obj);
-	virtual int removeObject(StaticANIObject *obj);
-	virtual void freeItems();
-	virtual Common::Array<MovItem *> *method28(StaticANIObject *ani, int x, int y, int flag1, int *rescount);
-	virtual bool method2C(StaticANIObject *obj, int x, int y);
-	virtual MessageQueue *method34(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
-	virtual void changeCallback(MovArr *(*_callback1)(StaticANIObject *ani, Common::Array<MovItem *> *items, signed int counter));
-	virtual bool method3C(StaticANIObject *ani, int flag);
-	virtual bool method44(StaticANIObject *ani, int x, int y);
+	virtual void attachObject(StaticANIObject *obj);
+	virtual int detachObject(StaticANIObject *obj);
+	virtual void detachAllObjects();
+	virtual Common::Array<MovItem *> *getPaths(StaticANIObject *ani, int x, int y, int flag1, int *rescount);
+	virtual bool setPosImmediate(StaticANIObject *obj, int x, int y);
+	virtual MessageQueue *startMove(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
+	virtual void setSelFunc(MovArr *(*_callback1)(StaticANIObject *ani, Common::Array<MovItem *> *items, signed int counter));
+	virtual bool resetPosition(StaticANIObject *ani, int flag);
+	virtual bool canDropInventory(StaticANIObject *ani, int x, int y);
 	virtual MessageQueue *doWalkTo(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
 	virtual MessageQueue *method50(StaticANIObject *ani, MovArr *movarr, int staticsId);
 
 	double calcDistance(Common::Point *point, MovGraphLink *link, int fuzzyMatch);
-	void calcNodeDistancesAndAngles();
-	bool findClosestLink(int unusedArg, Common::Point *p, MovArr *movarr);
+	void recalcLinkParams();
+	bool getNearestPoint(int unusedArg, Common::Point *p, MovArr *movarr);
 	MovGraphNode *calcOffset(int ox, int oy);
-	int getItemIndexByStaticAni(StaticANIObject *ani);
+	int getObjectIndex(StaticANIObject *ani);
 	Common::Array<MovArr *> *genMovArr(int x, int y, int *arrSize, int flag1, int flag2);
 	void findAllPaths(MovGraphLink *lnk, MovGraphLink *lnk2, Common::Array<MovGraphLink *> &tempObList1, Common::Array<MovGraphLink *> &tempObList2);
 	Common::Array<MovItem *> *calcMovItems(MovArr *movarr1, MovArr *movarr2, int *listCount);
@@ -374,10 +374,10 @@ public:
 	Common::Array<MovGraph2Item *> _items2;
 
 public:
-	virtual void addObject(StaticANIObject *obj);
-	virtual int removeObject(StaticANIObject *obj);
-	virtual void freeItems();
-	virtual MessageQueue *method34(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
+	virtual void attachObject(StaticANIObject *obj);
+	virtual int detachObject(StaticANIObject *obj);
+	virtual void detachAllObjects();
+	virtual MessageQueue *startMove(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
 	virtual MessageQueue *doWalkTo(StaticANIObject *subj, int xpos, int ypos, int fuzzyMatch, int staticsId);
 
 	int getItemIndexByGameObjectId(int objectId);
@@ -404,10 +404,9 @@ class MctlConnectionPoint : public CObject {
 public:
 	int _connectionX;
 	int _connectionY;
-	int _field_C;
-	int _field_10;
-	int16 _field_14;
-	int16 _field_16;
+	int _mctlflags;
+	int _mctlstatic;
+	int16 _mctlmirror;
 	MessageQueue *_messageQueueObj;
 	int _motionControllerObj;
 
diff --git a/engines/fullpipe/scene.cpp b/engines/fullpipe/scene.cpp
index 00dd70c1b2..5a3fbe34b6 100644
--- a/engines/fullpipe/scene.cpp
+++ b/engines/fullpipe/scene.cpp
@@ -672,11 +672,6 @@ void Scene::drawContent(int minPri, int maxPri, bool drawBg) {
 
 	debug(1, "_bigPict: %d objlist: %d", _bigPictureArray1Count, _picObjList.size());
 
-	for (uint i = 0; i < _picObjList.size(); i++) {
-		debug(1, "%d: %d", i, ((PictureObject *)_picObjList[i])->_priority);
-	}
-
-
 	if (drawBg && _bigPictureArray1Count && _picObjList.size()) {
 
 		_bigPictureArray[0][0]->getDimensions(&point);
@@ -743,7 +738,6 @@ void Scene::drawContent(int minPri, int maxPri, bool drawBg) {
 	for (uint i = 1; i < _picObjList.size(); i++) {
 		PictureObject *obj = (PictureObject *)_picObjList[i];
 
-		debug(8, "pri: %d", obj->_priority);
 		if (obj->_priority < minPri || obj->_priority >= maxPri)
 			continue;
 
diff --git a/engines/fullpipe/scenes.cpp b/engines/fullpipe/scenes.cpp
index 13c653ad09..32aa955a61 100644
--- a/engines/fullpipe/scenes.cpp
+++ b/engines/fullpipe/scenes.cpp
@@ -583,8 +583,8 @@ bool FullpipeEngine::sceneSwitcher(EntranceInfo *entrance) {
 	_aniMan2 = _aniMan;
 	MctlCompound *cmp = getSc2MctlCompoundBySceneId(entrance->_sceneId);
 	cmp->initMovGraph2();
-	cmp->addObject(_aniMan);
-	cmp->setEnabled();
+	cmp->attachObject(_aniMan);
+	cmp->activate();
 	getGameLoaderInteractionController()->enableFlag24();
 	setInputDisabled(0);
 
diff --git a/engines/fullpipe/scenes/scene04.cpp b/engines/fullpipe/scenes/scene04.cpp
index 4a87ae5b87..c0f0960aba 100644
--- a/engines/fullpipe/scenes/scene04.cpp
+++ b/engines/fullpipe/scenes/scene04.cpp
@@ -275,7 +275,7 @@ void sceneHandler04_clickButton() {
 }
 
 void sceneHandler04_downLadder(int x, int y) {
-	g_vars->scene04_ladder->method34(g_fp->_aniMan, x + g_vars->scene04_ladder->_ladder_field_20, y + g_vars->scene04_ladder->_ladder_field_24, 0, 0);
+	g_vars->scene04_ladder->startMove(g_fp->_aniMan, x + g_vars->scene04_ladder->_ladder_field_20, y + g_vars->scene04_ladder->_ladder_field_24, 0, 0);
 }
 
 void sceneHandler04_walkClimbLadder(ExCommand *ex) {
@@ -321,7 +321,7 @@ void sceneHandler04_walkClimbLadder(ExCommand *ex) {
 	g_vars->scene04_ladder->_ladder_field_20 = 0;
 	g_vars->scene04_ladder->_ladder_field_24 = -60;
 
-	g_vars->scene04_ladder->addObject(g_fp->_aniMan);
+	g_vars->scene04_ladder->attachObject(g_fp->_aniMan);
 
 	if (g_vars->scene04_soundPlaying) {
 		g_vars->scene04_ladder->_ladmovements.front()->movVars->varUpStart = MV_MAN_STARTLADDER2;
@@ -337,7 +337,7 @@ void sceneHandler04_walkClimbLadder(ExCommand *ex) {
 
 	g_fp->_aniMan->_priority = 12;
 
-	getSc2MctlCompoundBySceneId(g_fp->_currentScene->_sceneId)->clearEnabled();
+	getSc2MctlCompoundBySceneId(g_fp->_currentScene->_sceneId)->deactivate();
 	getGameLoaderInteractionController()->disableFlag24();
 }
 
@@ -368,7 +368,7 @@ void sceneHandler04_clickLadder() {
 	} else {
 		if (g_fp->_aniMan->isIdle() && !(g_fp->_aniMan->_flags & 0x100)) {
 			if (abs(1095 - g_vars->scene04_dudePosX) > 1 || abs(434 - g_vars->scene04_dudePosY) > 1) {
-				MessageQueue *mq = getSc2MctlCompoundBySceneId(g_fp->_currentScene->_sceneId)->method34(g_fp->_aniMan, 1095, 434, 1, ST_MAN_UP);
+				MessageQueue *mq = getSc2MctlCompoundBySceneId(g_fp->_currentScene->_sceneId)->startMove(g_fp->_aniMan, 1095, 434, 1, ST_MAN_UP);
 				if (mq) {
 					ExCommand *ex = new ExCommand(0, 17, MSG_SC4_CLICKLADDER, 0, 0, 0, 1, 0, 0, 0);
 
@@ -533,7 +533,7 @@ void sceneHandler04_manFromBottle() {
 
 	g_vars->scene04_ladder = 0;
 
-	getSc2MctlCompoundBySceneId(g_fp->_currentScene->_sceneId)->setEnabled();
+	getSc2MctlCompoundBySceneId(g_fp->_currentScene->_sceneId)->activate();
 	getGameLoaderInteractionController()->enableFlag24();
 }
 
@@ -1120,7 +1120,7 @@ void sceneHandler04_leaveLadder(ExCommand *ex) {
 
 						ex->_messageKind = 0;
 
-						mc->setEnabled();
+						mc->activate();
 						getGameLoaderInteractionController()->enableFlag24();
 					} else {
 						delete mq;
@@ -1275,7 +1275,7 @@ void sceneHandler04_winArcade() {
 		g_vars->scene04_objectIsTaken = false;
 		g_vars->scene04_soundPlaying = false;
 
-		getSc2MctlCompoundBySceneId(g_fp->_currentScene->_sceneId)->setEnabled();
+		getSc2MctlCompoundBySceneId(g_fp->_currentScene->_sceneId)->activate();
 
 		getGameLoaderInteractionController()->enableFlag24();
 
diff --git a/engines/fullpipe/scenes/scene06.cpp b/engines/fullpipe/scenes/scene06.cpp
index 06ec20dcb5..e9cecc42f0 100644
--- a/engines/fullpipe/scenes/scene06.cpp
+++ b/engines/fullpipe/scenes/scene06.cpp
@@ -118,7 +118,7 @@ void sceneHandler06_winArcade() {
 
 	sceneHandler06_setExits(g_fp->_currentScene);
 
-	getCurrSceneSc2MotionController()->setEnabled();
+	getCurrSceneSc2MotionController()->activate();
 	getGameLoaderInteractionController()->enableFlag24();
 }
 
@@ -300,7 +300,7 @@ void sceneHandler06_startAiming() {
 		if (getCurrSceneSc2MotionController()->_isEnabled)
 			g_fp->_updateScreenCallback = sceneHandler06_updateScreenCallback;
 
-		getCurrSceneSc2MotionController()->clearEnabled();
+		getCurrSceneSc2MotionController()->deactivate();
 		getGameLoaderInteractionController()->disableFlag24();
 
 		g_vars->scene06_ballDrop->queueMessageQueue(0);
@@ -313,7 +313,7 @@ void sceneHandler06_takeBall() {
 			|| abs(452 - g_fp->_aniMan->_oy) > 1
 			|| g_fp->_aniMan->_movement
 			|| g_fp->_aniMan->_statics->_staticsId != (0x4000 | ST_MAN_RIGHT)) {
-			MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, 1158, 452, 1, (0x4000 | ST_MAN_RIGHT));
+			MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, 1158, 452, 1, (0x4000 | ST_MAN_RIGHT));
 
 			if (mq) {
 				ExCommand *ex = new ExCommand(0, 17, MSG_SC6_TAKEBALL, 0, 0, 0, 1, 0, 0, 0);
@@ -562,7 +562,7 @@ int sceneHandler06(ExCommand *ex) {
 
 	case MSG_SC6_RESTORESCROLL:
 		g_fp->_aniMan2 = g_fp->_aniMan;
-		getCurrSceneSc2MotionController()->setEnabled();
+		getCurrSceneSc2MotionController()->activate();
 		getGameLoaderInteractionController()->enableFlag24();
 		sceneHandler06_setExits(g_fp->_currentScene);
 		break;
diff --git a/engines/fullpipe/scenes/scene08.cpp b/engines/fullpipe/scenes/scene08.cpp
index a5f5a8b389..d64df8688e 100644
--- a/engines/fullpipe/scenes/scene08.cpp
+++ b/engines/fullpipe/scenes/scene08.cpp
@@ -224,7 +224,7 @@ void sceneHandler08_startArcade() {
 	g_vars->scene08_onBelly = false;
 
 	getGameLoaderInteractionController()->disableFlag24();
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 
 	g_vars->scene08_batuta->stopAnim_maybe();
 
@@ -276,7 +276,7 @@ void sceneHandler08_finishArcade() {
 	g_vars->scene08_inArcade = false;
 
 	getGameLoaderInteractionController()->enableFlag24();
-	getCurrSceneSc2MotionController()->setEnabled();
+	getCurrSceneSc2MotionController()->activate();
 }
 
 void sceneHandler08_jumpOff(ExCommand *cmd) {
diff --git a/engines/fullpipe/scenes/scene09.cpp b/engines/fullpipe/scenes/scene09.cpp
index 99cf0b20fd..ffe8a1b2de 100644
--- a/engines/fullpipe/scenes/scene09.cpp
+++ b/engines/fullpipe/scenes/scene09.cpp
@@ -271,7 +271,7 @@ void sceneHandler09_spitterClick() {
 		g_vars->scene09_spitter->setPicAniInfo(&info);
 
 		if (ABS(x - g_fp->_aniMan->_ox) > 1 || ABS(y - g_fp->_aniMan->_oy) > 1) {
-			MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, x, y, 1, ST_MAN_UP);
+			MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, x, y, 1, ST_MAN_UP);
 
 			if (mq) {
 				ExCommand *ex = new ExCommand(0, 17, MSG_SC9_PLVCLICK, 0, 0, 0, 1, 0, 0, 0);
@@ -602,14 +602,14 @@ int sceneHandler09(ExCommand *cmd) {
 		break;
 
 	case MSG_SC9_FROMLADDER:
-		getCurrSceneSc2MotionController()->setEnabled();
+		getCurrSceneSc2MotionController()->activate();
 		getGameLoaderInteractionController()->enableFlag24();
 
 		g_vars->scene09_dudeIsOnLadder = false;
 		break;
 
 	case MSG_SC9_TOLADDER:
-		getCurrSceneSc2MotionController()->clearEnabled();
+		getCurrSceneSc2MotionController()->deactivate();
 		getGameLoaderInteractionController()->disableFlag24();
 
 		g_vars->scene09_dudeIsOnLadder = true;
diff --git a/engines/fullpipe/scenes/scene10.cpp b/engines/fullpipe/scenes/scene10.cpp
index 8c9e0b67d0..3e2a918b64 100644
--- a/engines/fullpipe/scenes/scene10.cpp
+++ b/engines/fullpipe/scenes/scene10.cpp
@@ -82,7 +82,7 @@ void sceneHandler10_clickGum() {
 				int y = g_vars->scene10_gum->_oy - 48;
 
 				if (abs(x - g_fp->_aniMan->_ox) > 1 || abs(y - g_fp->_aniMan->_oy) > 1) {
-					MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, x, y, 1, ST_MAN_RIGHT);
+					MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, x, y, 1, ST_MAN_RIGHT);
 					if (mq) {
 						ExCommand *ex = new ExCommand(0, 17, MSG_SC10_CLICKGUM, 0, 0, 0, 1, 0, 0, 0);
 						ex->_excFlags = 2;
diff --git a/engines/fullpipe/scenes/scene11.cpp b/engines/fullpipe/scenes/scene11.cpp
index 0ce82f5d5f..1fa5cabc15 100644
--- a/engines/fullpipe/scenes/scene11.cpp
+++ b/engines/fullpipe/scenes/scene11.cpp
@@ -191,7 +191,7 @@ void sceneHandler11_restartMan() {
 	chainObjQueue(0, QU_SC11_RESTARTMAN, 1);
 
 	getGameLoaderInteractionController()->enableFlag24();
-	getCurrSceneSc2MotionController()->setEnabled();
+	getCurrSceneSc2MotionController()->activate();
 
 	g_vars->scene11_scrollIsEnabled = false;
 }
@@ -234,7 +234,7 @@ int sceneHandler11_updateScreenCallback() {
 void sceneHandler11_manToSwing() {
 	g_vars->scene11_arcadeIsOn = true;
 
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 	getGameLoaderInteractionController()->disableFlag24();
 
 	g_fp->_aniMan2->hide();
@@ -271,7 +271,7 @@ void sceneHandler11_putABoot() {
 void sceneHandler11_putBoot() {
 	if (abs(353 - g_fp->_aniMan->_ox) > 1 || abs(498 - g_fp->_aniMan->_oy) > 1
 		|| g_fp->_aniMan->_movement || g_fp->_aniMan->_statics->_staticsId != ST_MAN_RIGHT) {
-		MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, 353, 498, 1, ST_MAN_RIGHT);
+		MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, 353, 498, 1, ST_MAN_RIGHT);
 
 		if (mq) {
 			ExCommand *ex = new ExCommand(0, 17, MSG_SC11_PUTBOOT, 0, 0, 0, 1, 0, 0, 0);
@@ -299,7 +299,7 @@ void sceneHandler11_jumpFromSwing() {
 	g_vars->scene11_hint->_flags &= 0xFFFB;
 	g_vars->scene11_scrollIsEnabled = false;
 
-	getCurrSceneSc2MotionController()->setEnabled();
+	getCurrSceneSc2MotionController()->activate();
 	getGameLoaderInteractionController()->enableFlag24();
 
 	g_vars->scene11_swingOldAngle = 0.0;
diff --git a/engines/fullpipe/scenes/scene14.cpp b/engines/fullpipe/scenes/scene14.cpp
index 446f477133..dc919c6d7f 100644
--- a/engines/fullpipe/scenes/scene14.cpp
+++ b/engines/fullpipe/scenes/scene14.cpp
@@ -174,7 +174,7 @@ void sceneHandler14_exitScene() {
 	chainQueue(QU_SC14_ENDARCADE, 0);
 
 	getGameLoaderInteractionController()->disableFlag24();
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 }
 
 void sceneHandler14_showBallMan() {
@@ -284,7 +284,7 @@ void sceneHandler14_endArcade() {
 	setInputDisabled(0);
 
 	getGameLoaderInteractionController()->enableFlag24();
-	getCurrSceneSc2MotionController()->setEnabled();
+	getCurrSceneSc2MotionController()->activate();
 
 	BehaviorEntryInfo *beh = g_fp->_behaviorManager->getBehaviorEntryInfoByMessageQueueDataId(g_vars->scene14_grandma, ST_GMA_SIT, QU_GMA_BLINK);
 	if (beh)
@@ -365,7 +365,7 @@ void sceneHandler14_startArcade() {
 		g_fp->_aniMan->_priority = 25;
 	}
 
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 	getGameLoaderInteractionController()->disableFlag24();
 
 	g_fp->_aniMan2 = 0;
@@ -458,7 +458,7 @@ bool sceneHandler14_arcadeProcessClick(ExCommand *cmd) {
 	if (cmd->_sceneClickX > 1237)
 		return false;
 
-	MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, 1237, 451, 1, 0);
+	MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, 1237, 451, 1, 0);
 
 	if (!mq)
 		return false;
@@ -473,7 +473,7 @@ bool sceneHandler14_arcadeProcessClick(ExCommand *cmd) {
 
 	cmd->_messageKind = 0;
 
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 	getGameLoaderInteractionController()->disableFlag24();
 	return true;
 }
diff --git a/engines/fullpipe/scenes/scene16.cpp b/engines/fullpipe/scenes/scene16.cpp
index df005950d2..5079863b4e 100644
--- a/engines/fullpipe/scenes/scene16.cpp
+++ b/engines/fullpipe/scenes/scene16.cpp
@@ -298,7 +298,7 @@ void sceneHandler16_drink() {
 void sceneHandler16_mugClick() {
 	if (abs(310 - g_fp->_aniMan->_ox) >= 1 || abs(449 - g_fp->_aniMan->_oy) >= 1
 		|| g_fp->_aniMan->_movement || g_fp->_aniMan->_statics->_staticsId != ST_MAN_RIGHT) {
-		MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, 310, 449, 1, ST_MAN_RIGHT);
+		MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, 310, 449, 1, ST_MAN_RIGHT);
 
 		if (mq) {
 			ExCommand *ex = new ExCommand(0, 17, MSG_SC16_MUGCLICK, 0, 0, 0, 1, 0, 0, 0);
diff --git a/engines/fullpipe/scenes/scene18and19.cpp b/engines/fullpipe/scenes/scene18and19.cpp
index 4f6677876b..5af7ef9043 100644
--- a/engines/fullpipe/scenes/scene18and19.cpp
+++ b/engines/fullpipe/scenes/scene18and19.cpp
@@ -379,7 +379,7 @@ int scene19_updateCursor() {
 
 void sceneHandler18_clickBoard() {
 	if (ABS(967 - g_fp->_aniMan->_ox) > 1 || ABS(379 - g_fp->_aniMan->_oy) > 1 || g_fp->_aniMan->_statics->_staticsId != ST_MAN_RIGHT) {
-		MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, 967, 379, 1, ST_MAN_RIGHT);
+		MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, 967, 379, 1, ST_MAN_RIGHT);
 		ExCommand *ex = new ExCommand(0, 17, MSG_SC18_MANREADY, 0, 0, 0, 1, 0, 0, 0);
 
 		ex->_excFlags = 2;
diff --git a/engines/fullpipe/scenes/scene22.cpp b/engines/fullpipe/scenes/scene22.cpp
index 542834b51a..f51469da69 100644
--- a/engines/fullpipe/scenes/scene22.cpp
+++ b/engines/fullpipe/scenes/scene22.cpp
@@ -191,7 +191,7 @@ void sceneHandler22_stoolLogic(ExCommand *cmd) {
 				xpos = 841;
 				manId = ST_MAN_RIGHT;
 			LABEL_31:
-				mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, xpos, 449, 1, manId);
+				mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, xpos, 449, 1, manId);
 
 				if (!mq)
 					return;
@@ -278,7 +278,7 @@ void sceneHandler22_stoolLogic(ExCommand *cmd) {
 					}
 				}
 
-				mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, 1010, 443, 1, ST_MAN_UP);
+				mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, 1010, 443, 1, ST_MAN_UP);
 
 				if (mq) {
 					mq->addExCommandToEnd(cmd->createClone());
@@ -318,13 +318,13 @@ int sceneHandler22(ExCommand *cmd) {
 		g_vars->scene22_dudeIsOnStool = false;
 		g_vars->scene22_interactionIsDisabled = false;
 
-		getCurrSceneSc2MotionController()->setEnabled();
+		getCurrSceneSc2MotionController()->activate();
 		g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 1);
 		break;
 
 	case MSG_SC22_ONSTOOL:
 		g_vars->scene22_dudeIsOnStool = true;
-		getCurrSceneSc2MotionController()->clearEnabled();
+		getCurrSceneSc2MotionController()->deactivate();
 		g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 0);
 		break;
 
diff --git a/engines/fullpipe/scenes/scene23.cpp b/engines/fullpipe/scenes/scene23.cpp
index f66ea12b4b..d6075c271b 100644
--- a/engines/fullpipe/scenes/scene23.cpp
+++ b/engines/fullpipe/scenes/scene23.cpp
@@ -296,17 +296,17 @@ void sceneHandler23_pushButton(ExCommand *cmd) {
 					if (g_fp->_msgX == 276 && g_fp->_msgY == 438 )
 						return;
 
-					MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, 276, 438, 1, ST_MAN_RIGHT);
+					MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, 276, 438, 1, ST_MAN_RIGHT);
 
 					if (mq) {
-						mq->addExCommandToEnd(cmd->createClone());;
+						mq->addExCommandToEnd(cmd->createClone());
 
 						postExCommand(g_fp->_aniMan->_id, 2, 276, 438, 0, -1);
 					}
 				} else {
 					MessageQueue *mq = new MessageQueue(g_fp->_currentScene->getMessageQueueById(QU_SC23_TOCALENDAR), 0, 0);
 
-					mq->addExCommandToEnd(cmd->createClone());;
+					mq->addExCommandToEnd(cmd->createClone());
 					mq->setFlags(mq->getFlags() | 1);
 					mq->chain(0);
 				}
@@ -424,7 +424,7 @@ int sceneHandler23(ExCommand *cmd) {
 	case MSG_SC23_FROMSTOOL:
 		g_vars->scene23_isOnStool = false;
 
-		getCurrSceneSc2MotionController()->setEnabled();
+		getCurrSceneSc2MotionController()->activate();
 		getGameLoaderInteractionController()->enableFlag24();
 
 		g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 1);
@@ -438,7 +438,7 @@ int sceneHandler23(ExCommand *cmd) {
 	case MSG_SC23_ONSTOOL:
 		g_vars->scene23_isOnStool = true;
 
-		getCurrSceneSc2MotionController()->clearEnabled();
+		getCurrSceneSc2MotionController()->deactivate();
 		getGameLoaderInteractionController()->disableFlag24();
 
 		g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 0);
diff --git a/engines/fullpipe/scenes/scene25.cpp b/engines/fullpipe/scenes/scene25.cpp
index a07330f057..07eda73cf2 100644
--- a/engines/fullpipe/scenes/scene25.cpp
+++ b/engines/fullpipe/scenes/scene25.cpp
@@ -153,7 +153,7 @@ void sceneHandler25_enterMan() {
 	if (g_vars->scene25_waterIsPresent) {
 		chainQueue(QU_SC25_ENTERUP_WATER, 1);
 
-		getCurrSceneSc2MotionController()->clearEnabled();
+		getCurrSceneSc2MotionController()->deactivate();
 	} else {
 		chainQueue(QU_SC25_ENTERUP_FLOOR, 1);
 	}
diff --git a/engines/fullpipe/scenes/scene26.cpp b/engines/fullpipe/scenes/scene26.cpp
index b9d9161e7d..baed928d00 100644
--- a/engines/fullpipe/scenes/scene26.cpp
+++ b/engines/fullpipe/scenes/scene26.cpp
@@ -257,7 +257,7 @@ void sceneHandler26_clickVent(StaticANIObject *ani, ExCommand *cmd) {
 			int y = ani->_oy + 61;
 
 			if (abs(x - g_fp->_aniMan->_ox) > 1 || abs(y - g_fp->_aniMan->_oy) > 1 || g_fp->_aniMan->_movement || g_fp->_aniMan->_statics->_staticsId != ST_MAN_UP) {
-				MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, x, y, 1, ST_MAN_UP);
+				MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, x, y, 1, ST_MAN_UP);
 
 				if (mq) {
 					ExCommand *ex = new ExCommand(0, 17, MSG_SC26_CLICKVENT, 0, 0, 0, 1, 0, 0, 0);
diff --git a/engines/fullpipe/scenes/scene27.cpp b/engines/fullpipe/scenes/scene27.cpp
index 8ec05caaff..9570d30913 100644
--- a/engines/fullpipe/scenes/scene27.cpp
+++ b/engines/fullpipe/scenes/scene27.cpp
@@ -159,7 +159,7 @@ void sceneHandler27_driverGiveVent() {
 
 	g_vars->scene27_driverHasVent = false;
 
-	getCurrSceneSc2MotionController()->setEnabled();
+	getCurrSceneSc2MotionController()->activate();
 	getGameLoaderInteractionController()->enableFlag24();
 
 	g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 1);
@@ -226,7 +226,7 @@ void sceneHandler27_throwBat() {
 
 	g_fp->_aniMan->startAnim(MV_MAN27_THROWBET, 0, -1);
 
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 	getGameLoaderInteractionController()->disableFlag24();
 
 	g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 0);
@@ -247,7 +247,7 @@ void sceneHandler27_clickBat(ExCommand *cmd) {
 
 	if (ABS(bx - g_fp->_aniMan->_ox) > 1 || ABS(by - g_fp->_aniMan->_oy) > 1
 		|| g_fp->_aniMan->_movement || g_fp->_aniMan->_statics->_staticsId != ST_MAN_RIGHT) {
-		MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, bx, by, 1, ST_MAN_RIGHT);
+		MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, bx, by, 1, ST_MAN_RIGHT);
 
 		if (mq) {
 			mq->addExCommandToEnd(cmd->createClone());
@@ -501,7 +501,7 @@ void sceneHandler27_batLogic() {
 		default:
 			chainQueue(QU_SC27_RESTARTBETS, 1);
 
-			getCurrSceneSc2MotionController()->setEnabled();
+			getCurrSceneSc2MotionController()->activate();
 			getGameLoaderInteractionController()->enableFlag24();
 
 			g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 1);
diff --git a/engines/fullpipe/scenes/scene28.cpp b/engines/fullpipe/scenes/scene28.cpp
index de5a96e70d..75ba2567b2 100644
--- a/engines/fullpipe/scenes/scene28.cpp
+++ b/engines/fullpipe/scenes/scene28.cpp
@@ -258,7 +258,7 @@ void sceneHandler28_clickLift(int keycode) {
 	if (abs(x - g_fp->_aniMan->_ox) > 1 || abs(472 - g_fp->_aniMan->_oy) > 1
 		|| g_fp->_aniMan->_movement
 		|| g_fp->_aniMan->_statics->_staticsId != ST_MAN_UP) {
-		MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, x, 472, 1, ST_MAN_UP);
+		MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, x, 472, 1, ST_MAN_UP);
 		if (mq) {
 			ExCommand *ex = new ExCommand(0, 17, MSG_SC28_CLICKLIFT, 0, 0, 0, 1, 0, 0, 0);
 			ex->_excFlags |= 3;
diff --git a/engines/fullpipe/scenes/scene29.cpp b/engines/fullpipe/scenes/scene29.cpp
index 222a541554..a03671a4d0 100644
--- a/engines/fullpipe/scenes/scene29.cpp
+++ b/engines/fullpipe/scenes/scene29.cpp
@@ -687,7 +687,7 @@ void sceneHandler29_ballHitCheck() {
 
 void sceneHandler29_manFromL() {
 	if (g_vars->scene29_manX < 497 && !g_vars->scene29_scrollingDisabled) {
-		getCurrSceneSc2MotionController()->setEnabled();
+		getCurrSceneSc2MotionController()->activate();
 		getGameLoaderInteractionController()->enableFlag24();
 
 		g_fp->_aniMan->changeStatics2(ST_MAN_RIGHT | 0x4000);
@@ -700,7 +700,7 @@ void sceneHandler29_manFromL() {
 }
 
 void sceneHandler29_manFromR() {
-	getCurrSceneSc2MotionController()->setEnabled();
+	getCurrSceneSc2MotionController()->activate();
 	getGameLoaderInteractionController()->enableFlag24();
 
 	chainQueue(QU_SC29_MANFROM_R, 1);
@@ -721,7 +721,7 @@ int sceneHandler29_updateScreenCallback() {
 }
 
 void sceneHandler29_manToL() {
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 	getGameLoaderInteractionController()->disableFlag24();
 
 	chainQueue(QU_SC29_MANTO_L, 1);
@@ -737,7 +737,7 @@ void sceneHandler29_manToL() {
 }
 
 void sceneHandler29_manToR() {
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 	getGameLoaderInteractionController()->disableFlag24();
 
 	chainQueue(QU_SC29_MANTO_R, 1);
@@ -763,7 +763,7 @@ void sceneHandler29_clickPorter(ExCommand *cmd) {
 		if (ABS(351 - g_vars->scene29_manX) > 1 || ABS(443 - g_vars->scene29_manY) > 1
 			|| g_fp->_aniMan->_movement || g_fp->_aniMan->_statics->_staticsId != ST_MAN_RIGHT) {
 			if (g_fp->_msgX != 351 || g_fp->_msgY != 443) {
-				MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, 351, 443, 1, ST_MAN_RIGHT);
+				MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, 351, 443, 1, ST_MAN_RIGHT);
 
 				if (mq) {
 					mq->addExCommandToEnd(cmd->createClone());
@@ -781,7 +781,7 @@ void sceneHandler29_clickPorter(ExCommand *cmd) {
 		if (ABS(1582 - g_vars->scene29_manX) > 1 || ABS(445 - g_fp->_aniMan->_oy) > 1
 			|| g_fp->_aniMan->_movement || g_fp->_aniMan->_statics->_staticsId != (0x4000 | ST_MAN_RIGHT)) {
 			if (g_fp->_msgX != 1582 || g_fp->_msgY != 445) {
-				MessageQueue *mq = getCurrSceneSc2MotionController()->method34(g_fp->_aniMan, 1582, 445, 1, (0x4000 | ST_MAN_RIGHT));
+				MessageQueue *mq = getCurrSceneSc2MotionController()->startMove(g_fp->_aniMan, 1582, 445, 1, (0x4000 | ST_MAN_RIGHT));
 
 				if (mq) {
 					mq->addExCommandToEnd(cmd->createClone());
@@ -1001,7 +1001,7 @@ int sceneHandler29(ExCommand *cmd) {
 		g_vars->scene29_reachedFarRight = false;
 		g_vars->scene29_rideBackEnabled = false;
 
-		getCurrSceneSc2MotionController()->setEnabled();
+		getCurrSceneSc2MotionController()->activate();
 		getGameLoaderInteractionController()->enableFlag24();
 		break;
 
diff --git a/engines/fullpipe/scenes/scene32.cpp b/engines/fullpipe/scenes/scene32.cpp
index 9279db7513..05b78efb3d 100644
--- a/engines/fullpipe/scenes/scene32.cpp
+++ b/engines/fullpipe/scenes/scene32.cpp
@@ -189,7 +189,7 @@ void sceneHandler32_trySit(ExCommand *cmd) {
 
 		g_vars->scene32_dudeIsSitting = true;
 
-		getCurrSceneSc2MotionController()->clearEnabled();
+		getCurrSceneSc2MotionController()->deactivate();
 		getGameLoaderInteractionController()->disableFlag24();
 	}
 }
@@ -236,7 +236,7 @@ void sceneHandler32_ladderLogic(ExCommand *cmd) {
 
 	g_vars->scene32_dudeOnLadder = false;
 
-	getCurrSceneSc2MotionController()->setEnabled();
+	getCurrSceneSc2MotionController()->activate();
 	getGameLoaderInteractionController()->enableFlag24();
 }
 
@@ -258,7 +258,7 @@ void sceneHandler32_potLogic(ExCommand *cmd) {
 		mq->setFlags(mq->getFlags() | 1);
 		mq->chain(0);
 
-		getCurrSceneSc2MotionController()->setEnabled();
+		getCurrSceneSc2MotionController()->activate();
 		getGameLoaderInteractionController()->enableFlag24();
 
 		g_vars->scene32_dudeIsSitting = false;
@@ -330,7 +330,7 @@ int sceneHandler32(ExCommand *cmd) {
 	case MSG_SC32_ONLADDER:
 		g_vars->scene32_dudeOnLadder = true;
 
-		getCurrSceneSc2MotionController()->clearEnabled();
+		getCurrSceneSc2MotionController()->deactivate();
 		getGameLoaderInteractionController()->disableFlag24();
 		break;
 
diff --git a/engines/fullpipe/scenes/scene34.cpp b/engines/fullpipe/scenes/scene34.cpp
index 1c8c8b4855..32fb192756 100644
--- a/engines/fullpipe/scenes/scene34.cpp
+++ b/engines/fullpipe/scenes/scene34.cpp
@@ -115,7 +115,7 @@ int scene34_updateCursor() {
 }
 
 void sceneHandler34_leaveBoard() {
-	getCurrSceneSc2MotionController()->setEnabled();
+	getCurrSceneSc2MotionController()->activate();
 	getGameLoaderInteractionController()->enableFlag24();
 
 	g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 1);
@@ -124,7 +124,7 @@ void sceneHandler34_leaveBoard() {
 }
 
 void sceneHandler34_onBoard() {
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 	getGameLoaderInteractionController()->disableFlag24();
 
 	g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 0);
@@ -149,7 +149,7 @@ void sceneHandler34_hideStool() {
 }
 
 void sceneHandler34_climb() {
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 	getGameLoaderInteractionController()->disableFlag24();
 
 	g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 0);
@@ -287,7 +287,7 @@ void sceneHandler34_showStool() {
 }
 
 void sceneHandler34_unclimb() {
-	getCurrSceneSc2MotionController()->setEnabled();
+	getCurrSceneSc2MotionController()->activate();
 	getGameLoaderInteractionController()->enableFlag24();
 
 	g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 1);
@@ -323,7 +323,7 @@ int sceneHandler34(ExCommand *cmd) {
 	case MSG_SC34_FROMCACTUS:
 		g_vars->scene34_dudeOnCactus = false;
 
-		getCurrSceneSc2MotionController()->setEnabled();
+		getCurrSceneSc2MotionController()->activate();
 		getGameLoaderInteractionController()->enableFlag24();
 
 		g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 1);
@@ -381,7 +381,7 @@ int sceneHandler34(ExCommand *cmd) {
 	case MSG_SC34_ONCACTUS:
 		g_vars->scene34_dudeOnCactus = true;
 
-		getCurrSceneSc2MotionController()->clearEnabled();
+		getCurrSceneSc2MotionController()->deactivate();
 		getGameLoaderInteractionController()->disableFlag24();
 
 		g_fp->_behaviorManager->setFlagByStaticAniObject(g_fp->_aniMan, 0);
diff --git a/engines/fullpipe/scenes/sceneFinal.cpp b/engines/fullpipe/scenes/sceneFinal.cpp
index d0040463ef..8b3ecb1025 100644
--- a/engines/fullpipe/scenes/sceneFinal.cpp
+++ b/engines/fullpipe/scenes/sceneFinal.cpp
@@ -97,7 +97,7 @@ void sceneHandlerFinal_goto2() {
 void sceneHandlerFinal_startFinal() {
 	g_vars->sceneFinal_var01 = 1;
 
-	getCurrSceneSc2MotionController()->clearEnabled();
+	getCurrSceneSc2MotionController()->deactivate();
 	getGameLoaderInteractionController()->disableFlag24();
 
 	g_fp->_aniMan2 = 0;
diff --git a/engines/gob/gob.cpp b/engines/gob/gob.cpp
index 5ab3271a8f..24bdb858d8 100644
--- a/engines/gob/gob.cpp
+++ b/engines/gob/gob.cpp
@@ -389,6 +389,9 @@ void GobEngine::syncSoundSettings() {
 	Engine::syncSoundSettings();
 
 	_init->updateConfig();
+
+	if (_sound)
+		_sound->adlibSyncVolume();
 }
 
 void GobEngine::pauseGame() {
diff --git a/engines/gob/map_v2.cpp b/engines/gob/map_v2.cpp
index cb5abe9644..370e62c88f 100644
--- a/engines/gob/map_v2.cpp
+++ b/engines/gob/map_v2.cpp
@@ -163,11 +163,9 @@ void Map_v2::loadMapObjects(const char *avjFile) {
 		mapHeight = _screenHeight / _tilesHeight;
 		mapWidth = _screenWidth / _tilesWidth;
 
-		for (int i = 0; i < mapHeight; i++) {
+		for (int i = 0; i < mapHeight; i++)
 			for (int j = 0; j < mapWidth; j++)
 				setPass(j, i, mapData.readSByte());
-			_vm->_inter->_variables->getAddressOff8(var + i * _passWidth);
-		}
 	}
 	mapData.seek(tmpPos);
 
diff --git a/engines/gob/sound/adlib.cpp b/engines/gob/sound/adlib.cpp
index 65b43cae7a..1e024d5a50 100644
--- a/engines/gob/sound/adlib.cpp
+++ b/engines/gob/sound/adlib.cpp
@@ -37,6 +37,28 @@ static const int kPitchTomToSnare =  7;
 static const int kPitchSnareDrum  = kPitchTom + kPitchTomToSnare;
 
 
+// Attenuation map for GUI volume slider
+// Note: no volume control in the original engine
+const uint8 AdLib::kVolumeTable[Audio::Mixer::kMaxMixerVolume + 1] = {
+	63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 62, 61, 59, 57, 56, 55,
+	53, 52, 51, 50, 49, 48, 47, 46, 46, 45, 44, 43, 43, 42, 41, 41,
+	40, 39, 39, 38, 38, 37, 37, 36, 36, 35, 35, 34, 34, 33, 33, 33,
+	32, 32, 31, 31, 31, 30, 30, 30, 29, 29, 29, 28, 28, 28, 27, 27,
+	27, 26, 26, 26, 26, 25, 25, 25, 24, 24, 24, 24, 23, 23, 23, 23,
+	22, 22, 22, 22, 21, 21, 21, 21, 21, 20, 20, 20, 20, 19, 19, 19,
+	19, 19, 18, 18, 18, 18, 18, 18, 17, 17, 17, 17, 17, 16, 16, 16,
+	16, 16, 16, 15, 15, 15, 15, 15, 15, 14, 14, 14, 14, 14, 14, 13,
+	13, 13, 13, 13, 13, 13, 12, 12, 12, 12, 12, 12, 12, 11, 11, 11,
+	11, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10,  9,  9,  9,
+	 9,  9,  9,  9,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  7,  7,
+	 7,  7,  7,  7,  7,  7,  7,  6,  6,  6,  6,  6,  6,  6,  6,  6,
+	 6,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  4,  4,  4,  4,  4,
+	 4,  4,  4,  4,  4,  4,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
+	 3,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  1,  1,  1,
+	 1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,
+	 0
+};
+
 // Is the operator a modulator (0) or a carrier (1)?
 const uint8 AdLib::kOperatorType[kOperatorCount] = {
 	0, 0, 0, 1, 1, 1,
@@ -93,23 +115,20 @@ const uint16 AdLib::kHihatParams    [kParamCount] = {
 	  0,  1,  0, 15, 11,  0,  7,  5,  0,  0,  0,  0,  0,  0   };
 
 
-AdLib::AdLib(Audio::Mixer &mixer) : _mixer(&mixer), _opl(0),
-	_toPoll(0), _repCount(0), _first(true), _playing(false), _ended(true) {
-
-	_rate = _mixer->getOutputRate();
+AdLib::AdLib(int callbackFreq) : _opl(0),
+	_toPoll(0), _repCount(0), _first(true), _playing(false), _ended(true), _volume(0) {
 
 	initFreqs();
 
 	createOPL();
 	initOPL();
 
-	_mixer->playStream(Audio::Mixer::kMusicSoundType, &_handle,
-			this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
+	syncVolume();
+
+	_opl->start(new Common::Functor0Mem<void, AdLib>(this, &AdLib::onTimer), callbackFreq);
 }
 
 AdLib::~AdLib() {
-	_mixer->stopHandle(_handle);
-
 	delete _opl;
 }
 
@@ -136,46 +155,38 @@ void AdLib::createOPL() {
 	}
 
 	_opl = OPL::Config::create(OPL::Config::parse(oplDriver), OPL::Config::kOpl2);
-	if (!_opl || !_opl->init(_rate)) {
+	if (!_opl || !_opl->init()) {
 		delete _opl;
 
 		error("Could not create an AdLib emulator");
 	}
 }
 
-int AdLib::readBuffer(int16 *buffer, const int numSamples) {
+void AdLib::onTimer() {
 	Common::StackLock slock(_mutex);
 
-	// Nothing to do, fill with silence
-	if (!_playing) {
-		memset(buffer, 0, numSamples * sizeof(int16));
-		return numSamples;
+	// Nothing to do
+	if (!_playing)
+		return;
+
+	// Check if there's anything to do on this step
+	// If not, decrease the poll number and move on
+	if (_toPoll > 0) {
+		_toPoll--;
+		return;
 	}
 
-	// Read samples from the OPL, polling in more music when necessary
-	uint32 samples = numSamples;
-	while (samples && _playing) {
-		if (_toPoll) {
-			const uint32 render = MIN(samples, _toPoll);
-
-			_opl->readBuffer(buffer, render);
-
-			buffer  += render;
-			samples -= render;
-			_toPoll -= render;
-
-		} else {
-			// Song ended, fill the rest with silence
-			if (_ended) {
-				memset(buffer, 0, samples * sizeof(int16));
-				samples = 0;
-				break;
-			}
-
-			// Poll more music
-			_toPoll = pollMusic(_first);
-			_first  = false;
+	// Poll until we have to delay until the next poll
+	while (_toPoll == 0 && _playing) {
+		// Song ended, break out
+		if (_ended) {
+			_toPoll = 0;
+			break;
 		}
+
+		// Poll more music
+		_toPoll = pollMusic(_first);
+		_first  = false;
 	}
 
 	// Song ended, loop if requested
@@ -195,24 +206,6 @@ int AdLib::readBuffer(int16 *buffer, const int numSamples) {
 		} else
 			_playing = false;
 	}
-
-	return numSamples;
-}
-
-bool AdLib::isStereo() const {
-	return _opl->isStereo();
-}
-
-bool AdLib::endOfData() const {
-	return !_playing;
-}
-
-bool AdLib::endOfStream() const {
-	return false;
-}
-
-int AdLib::getRate() const {
-	return _rate;
 }
 
 bool AdLib::isPlaying() const {
@@ -231,10 +224,6 @@ void AdLib::setRepeating(int32 repCount) {
 	_repCount = repCount;
 }
 
-uint32 AdLib::getSamplesPerSecond() const {
-	return _rate * (isStereo() ? 2 : 1);
-}
-
 void AdLib::startPlay() {
 	Common::StackLock slock(_mutex);
 
@@ -442,6 +431,13 @@ void AdLib::writeKeyScaleLevelVolume(uint8 oper) {
 	volume = (63 - (_operatorParams[oper][kParamLevel] & 0x3F)) * _operatorVolume[oper];
 	volume = 63 - ((2 * volume + kMaxVolume) / (2 * kMaxVolume));
 
+	// Adjust carriers for GUI volume slider
+	if (kOperatorType[oper] == 1) {
+		volume += kVolumeTable[_volume];
+		if (volume > 63)
+			volume = 63;
+	}
+
 	uint8 keyScale = _operatorParams[oper][kParamKeyScaleLevel] << 6;
 
 	writeOPL(0x40 + kOperatorOffset[oper], volume | keyScale);
@@ -639,4 +635,23 @@ void AdLib::setFreq(uint8 voice, uint16 note, bool on) {
 	writeOPL(0xB0 + voice, value);
 }
 
+void AdLib::setTimerFrequency(int timerFrequency) {
+	_opl->setCallbackFrequency(timerFrequency);
+}
+
+void AdLib::syncVolume() {
+	Common::StackLock slock(_mutex);
+
+	bool mute = false;
+	if (ConfMan.hasKey("mute"))
+		mute = ConfMan.getBool("mute");
+
+	_volume = (mute ? 0 : ConfMan.getInt("music_volume"));
+
+	if (_playing) {
+		for(int i = 0; i < kOperatorCount; i++)
+			writeKeyScaleLevelVolume(i);
+	}
+}
+
 } // End of namespace Gob
diff --git a/engines/gob/sound/adlib.h b/engines/gob/sound/adlib.h
index 8071249374..d60458295c 100644
--- a/engines/gob/sound/adlib.h
+++ b/engines/gob/sound/adlib.h
@@ -35,9 +35,9 @@ namespace OPL {
 namespace Gob {
 
 /** Base class for a player of an AdLib music format. */
-class AdLib : public Audio::AudioStream {
+class AdLib {
 public:
-	AdLib(Audio::Mixer &mixer);
+	AdLib(int callbackFrequency);
 	virtual ~AdLib();
 
 	bool isPlaying() const;    ///< Are we currently playing?
@@ -53,13 +53,7 @@ public:
 
 	void startPlay();
 	void stopPlay();
-
-// AudioStream API
-	int  readBuffer(int16 *buffer, const int numSamples);
-	bool isStereo()    const;
-	bool endOfData()   const;
-	bool endOfStream() const;
-	int  getRate()     const;
+	void syncVolume();
 
 protected:
 	enum kVoice {
@@ -120,8 +114,6 @@ protected:
 	static const int kOPLMidC      = 48; ///< A mid C for the OPL.
 
 
-	/** Return the number of samples per second. */
-	uint32 getSamplesPerSecond() const;
 
 	/** Write a value into an OPL register. */
 	void writeOPL(byte reg, byte val);
@@ -135,7 +127,7 @@ protected:
 	/** The callback function that's called for polling more AdLib commands.
 	 *
 	 *  @param  first Is this the first poll since the start of the song?
-	 *  @return The number of samples until the next poll.
+	 *  @return The number of ticks until the next poll.
 	 */
 	virtual uint32 pollMusic(bool first) = 0;
 
@@ -207,7 +199,14 @@ protected:
 	/** Switch a voice off. */
 	void noteOff(uint8 voice);
 
+	/**
+	 * Set the OPL timer frequency
+	 */
+	void setTimerFrequency(int timerFrequency);
+
 private:
+	static const uint8 kVolumeTable[Audio::Mixer::kMaxMixerVolume + 1];
+
 	static const uint8 kOperatorType  [kOperatorCount];
 	static const uint8 kOperatorOffset[kOperatorCount];
 	static const uint8 kOperatorVoice [kOperatorCount];
@@ -226,13 +225,11 @@ private:
 	static const uint16 kHihatParams    [kParamCount];
 
 
-	Audio::Mixer *_mixer;
-	Audio::SoundHandle _handle;
 	OPL::OPL *_opl;
 
 	Common::Mutex _mutex;
 
-	uint32 _rate;
+	int _volume;
 
 	uint32 _toPoll;
 
@@ -300,6 +297,11 @@ private:
 	void changePitch(uint8 voice, uint16 pitchBend);
 
 	void setFreq(uint8 voice, uint16 note, bool on);
+
+	/**
+	 * Callback function for OPL
+	 */
+	void onTimer();
 };
 
 } // End of namespace Gob
diff --git a/engines/gob/sound/adlplayer.cpp b/engines/gob/sound/adlplayer.cpp
index 384a928360..6354d8c37f 100644
--- a/engines/gob/sound/adlplayer.cpp
+++ b/engines/gob/sound/adlplayer.cpp
@@ -28,7 +28,7 @@
 
 namespace Gob {
 
-ADLPlayer::ADLPlayer(Audio::Mixer &mixer) : AdLib(mixer),
+ADLPlayer::ADLPlayer() : AdLib(1000),
 	_songData(0), _songDataSize(0), _playPos(0) {
 
 }
@@ -135,14 +135,7 @@ uint32 ADLPlayer::pollMusic(bool first) {
 	if (delay & 0x80)
 		delay = ((delay & 3) << 8) | *_playPos++;
 
-	return getSampleDelay(delay);
-}
-
-uint32 ADLPlayer::getSampleDelay(uint16 delay) const {
-	if (delay == 0)
-		return 0;
-
-	return ((uint32)delay * getSamplesPerSecond()) / 1000;
+	return delay;
 }
 
 void ADLPlayer::rewind() {
diff --git a/engines/gob/sound/adlplayer.h b/engines/gob/sound/adlplayer.h
index 3edd238343..50e1db5b70 100644
--- a/engines/gob/sound/adlplayer.h
+++ b/engines/gob/sound/adlplayer.h
@@ -36,7 +36,7 @@ namespace Gob {
 /** A player for Coktel Vision's ADL music format. */
 class ADLPlayer : public AdLib {
 public:
-	ADLPlayer(Audio::Mixer &mixer);
+	ADLPlayer();
 	~ADLPlayer();
 
 	bool load(Common::SeekableReadStream &adl);
@@ -76,8 +76,6 @@ private:
 	bool readHeader  (Common::SeekableReadStream &adl, int &timbreCount);
 	bool readTimbres (Common::SeekableReadStream &adl, int  timbreCount);
 	bool readSongData(Common::SeekableReadStream &adl);
-
-	uint32 getSampleDelay(uint16 delay) const;
 };
 
 } // End of namespace Gob
diff --git a/engines/gob/sound/cdrom.cpp b/engines/gob/sound/cdrom.cpp
index eca6ca4c9e..b862ca96fb 100644
--- a/engines/gob/sound/cdrom.cpp
+++ b/engines/gob/sound/cdrom.cpp
@@ -91,7 +91,10 @@ void CDROM::startTrack(const char *trackName) {
 		return;
 	}
 
-	Common::strlcpy(_curTrack, trackName, 16);
+	Common::String curTrack(trackName);
+	curTrack.toUppercase();
+
+	Common::strlcpy(_curTrack, curTrack.c_str(), 16);
 
 	stopPlaying();
 	_curTrackBuffer = matchPtr;
diff --git a/engines/gob/sound/musplayer.cpp b/engines/gob/sound/musplayer.cpp
index 7001a5724b..dcbb712b56 100644
--- a/engines/gob/sound/musplayer.cpp
+++ b/engines/gob/sound/musplayer.cpp
@@ -27,7 +27,7 @@
 
 namespace Gob {
 
-MUSPlayer::MUSPlayer(Audio::Mixer &mixer) : AdLib(mixer),
+MUSPlayer::MUSPlayer() : AdLib(60),
 	_songData(0), _songDataSize(0), _playPos(0), _songID(0) {
 
 }
@@ -43,15 +43,6 @@ void MUSPlayer::unload() {
 	unloadMUS();
 }
 
-uint32 MUSPlayer::getSampleDelay(uint16 delay) const {
-	if (delay == 0)
-		return 0;
-
-	uint32 freq = (_ticksPerBeat * _tempo) / 60;
-
-	return ((uint32)delay * getSamplesPerSecond()) / freq;
-}
-
 void MUSPlayer::skipToTiming() {
 	while (*_playPos < 0x80)
 		_playPos++;
@@ -66,8 +57,12 @@ uint32 MUSPlayer::pollMusic(bool first) {
 		return 0;
 	}
 
-	if (first)
-		return getSampleDelay(*_playPos++);
+	if (first) {
+		// Set the timer frequency on first run.
+		// Do not set it in rewind() for thread safety reasons.
+		setTimerFrequency((_ticksPerBeat * _tempo) / 60);
+		return *_playPos++;
+	}
 
 	uint16 delay = 0;
 	while (delay == 0) {
@@ -100,6 +95,7 @@ uint32 MUSPlayer::pollMusic(bool first) {
 				uint32 denom = *_playPos++;
 
 				_tempo = _baseTempo * num + ((_baseTempo * denom) >> 7);
+				setTimerFrequency((_ticksPerBeat * _tempo) / 60);
 
 				_playPos++;
 			} else {
@@ -182,7 +178,7 @@ uint32 MUSPlayer::pollMusic(bool first) {
 			delay += *_playPos++;
 	}
 
-	return getSampleDelay(delay);
+	return delay;
 }
 
 void MUSPlayer::rewind() {
diff --git a/engines/gob/sound/musplayer.h b/engines/gob/sound/musplayer.h
index c76c5aab38..973192ffd9 100644
--- a/engines/gob/sound/musplayer.h
+++ b/engines/gob/sound/musplayer.h
@@ -40,7 +40,7 @@ namespace Gob {
  */
 class MUSPlayer : public AdLib {
 public:
-	MUSPlayer(Audio::Mixer &mixer);
+	MUSPlayer();
 	~MUSPlayer();
 
 	/** Load the instruments (.SND or .TBR) */
@@ -97,7 +97,6 @@ private:
 	bool readMUSHeader(Common::SeekableReadStream &mus);
 	bool readMUSSong  (Common::SeekableReadStream &mus);
 
-	uint32 getSampleDelay(uint16 delay) const;
 	void setInstrument(uint8 voice, uint8 instrument);
 	void skipToTiming();
 
diff --git a/engines/gob/sound/sound.cpp b/engines/gob/sound/sound.cpp
index d2b2d3d6e8..22dfe9d3c3 100644
--- a/engines/gob/sound/sound.cpp
+++ b/engines/gob/sound/sound.cpp
@@ -234,7 +234,7 @@ bool Sound::adlibLoadADL(const char *fileName) {
 		return false;
 
 	if (!_adlPlayer)
-		_adlPlayer = new ADLPlayer(*_vm->_mixer);
+		_adlPlayer = new ADLPlayer();
 
 	debugC(1, kDebugSound, "AdLib: Loading ADL data (\"%s\")", fileName);
 
@@ -256,7 +256,7 @@ bool Sound::adlibLoadADL(byte *data, uint32 size, int index) {
 		return false;
 
 	if (!_adlPlayer)
-		_adlPlayer = new ADLPlayer(*_vm->_mixer);
+		_adlPlayer = new ADLPlayer();
 
 	debugC(1, kDebugSound, "AdLib: Loading ADL data (%d)", index);
 
@@ -425,6 +425,16 @@ int32 Sound::adlibGetRepeating() const {
 	return false;
 }
 
+void Sound::adlibSyncVolume() {
+	if (!_hasAdLib)
+		return;
+
+	if (_adlPlayer)
+		_adlPlayer->syncVolume();
+	if (_mdyPlayer)
+		_mdyPlayer->syncVolume();
+}
+
 void Sound::adlibSetRepeating(int32 repCount) {
 	if (!_hasAdLib)
 		return;
@@ -739,7 +749,7 @@ void Sound::createMDYPlayer() {
 	delete _adlPlayer;
 	_adlPlayer = 0;
 
-	_mdyPlayer = new MUSPlayer(*_vm->_mixer);
+	_mdyPlayer = new MUSPlayer();
 }
 
 void Sound::createADLPlayer() {
@@ -749,7 +759,7 @@ void Sound::createADLPlayer() {
 	delete _mdyPlayer;
 	_mdyPlayer= 0;
 
-	_adlPlayer = new ADLPlayer(*_vm->_mixer);
+	_adlPlayer = new ADLPlayer();
 }
 
 } // End of namespace Gob
diff --git a/engines/gob/sound/sound.h b/engines/gob/sound/sound.h
index c959959755..6ebc323b18 100644
--- a/engines/gob/sound/sound.h
+++ b/engines/gob/sound/sound.h
@@ -96,6 +96,7 @@ public:
 	int32 adlibGetRepeating() const;
 
 	void adlibSetRepeating(int32 repCount);
+	void adlibSyncVolume();
 
 
 	// Infogrames
diff --git a/engines/gob/surface.cpp b/engines/gob/surface.cpp
index 42ac2b0d74..ed83e8255c 100644
--- a/engines/gob/surface.cpp
+++ b/engines/gob/surface.cpp
@@ -470,7 +470,7 @@ void Surface::blitScaled(const Surface &from, Common::Rational scale, int32 tran
 	blitScaled(from, 0, 0, from._width - 1, from._height - 1, 0, 0, scale, transp);
 }
 
-void Surface::fillRect(uint16 left, uint16 top, uint16 right, uint16 bottom, uint32 color) {
+void Surface::fillRect(int16 left, int16 top, int16 right, int16 bottom, uint32 color) {
 	// Just in case those are swapped
 	if (left > right)
 		SWAP(left, right);
@@ -481,6 +481,11 @@ void Surface::fillRect(uint16 left, uint16 top, uint16 right, uint16 bottom, uin
 		// Nothing to do
 		return;
 
+	left   = CLIP<int32>(left  , 0, _width  - 1);
+	top    = CLIP<int32>(top   , 0, _height - 1);
+	right  = CLIP<int32>(right , 0, _width  - 1);
+	bottom = CLIP<int32>(bottom, 0, _height - 1);
+
 	// Area to actually fill
 	uint16 width  = CLIP<int32>(right  - left + 1, 0, _width  - left);
 	uint16 height = CLIP<int32>(bottom - top  + 1, 0, _height - top);
diff --git a/engines/gob/surface.h b/engines/gob/surface.h
index c931731908..eb0a5bf1a4 100644
--- a/engines/gob/surface.h
+++ b/engines/gob/surface.h
@@ -121,7 +121,7 @@ public:
 	void blitScaled(const Surface &from, int16 x, int16 y, Common::Rational scale, int32 transp = -1);
 	void blitScaled(const Surface &from, Common::Rational scale, int32 transp = -1);
 
-	void fillRect(uint16 left, uint16 top, uint16 right, uint16 bottom, uint32 color);
+	void fillRect(int16 left, int16 top, int16 right, int16 bottom, uint32 color);
 	void fill(uint32 color);
 	void clear();
 
diff --git a/engines/groovie/music.cpp b/engines/groovie/music.cpp
index 2c164e020c..cf65e012c8 100644
--- a/engines/groovie/music.cpp
+++ b/engines/groovie/music.cpp
@@ -36,6 +36,7 @@
 #include "common/textconsole.h"
 #include "audio/audiostream.h"
 #include "audio/midiparser.h"
+#include "audio/miles.h"
 
 namespace Groovie {
 
@@ -379,14 +380,56 @@ bool MusicPlayerMidi::loadParser(Common::SeekableReadStream *stream, bool loop)
 
 MusicPlayerXMI::MusicPlayerXMI(GroovieEngine *vm, const Common::String &gtlName) :
 	MusicPlayerMidi(vm) {
-	// Create the parser
-	_midiParser = MidiParser::createParser_XMIDI();
 
 	// Create the driver
 	MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_GM);
-	_driver = MidiDriver::createMidi(dev);
+	MusicType musicType = MidiDriver::getMusicType(dev);
+	_driver = NULL;
+
+	// new Miles Audio support, to disable set milesAudioEnabled to false
+	_milesAudioMode = false;
+	bool milesAudioEnabled = true;
+	MidiParser::XMidiNewTimbreListProc newTimbreListProc = NULL;
+
+	if (milesAudioEnabled) {
+		// 7th Guest uses FAT.AD/FAT.OPL/FAT.MT
+		// 11th Hour uses SAMPLE.AD/SAMPLE.OPL/SAMPLE.MT
+		switch (musicType) {
+		case MT_ADLIB:
+			_driver = Audio::MidiDriver_Miles_AdLib_create(gtlName + ".AD", gtlName + ".OPL");
+			break;
+		case MT_MT32:
+			_driver = Audio::MidiDriver_Miles_MT32_create(gtlName + ".MT");
+			break;
+		case MT_GM:
+			if (ConfMan.getBool("native_mt32")) {
+				_driver = Audio::MidiDriver_Miles_MT32_create(gtlName + ".MT");
+				musicType = MT_MT32;
+			}
+			break;
+		default:
+			break;
+		}
+
+		if (musicType == MT_MT32) {
+			newTimbreListProc = Audio::MidiDriver_Miles_MT32_processXMIDITimbreChunk;
+		}
+	}
+
+	if (_driver) {
+		_milesAudioMode = true;
+	}
+
+	if (!_driver) {
+		// No driver yet? create a generic one
+		_driver = MidiDriver::createMidi(dev);
+	}
+
 	assert(_driver);
 
+	// Create the parser
+	_midiParser = MidiParser::createParser_XMIDI(NULL, NULL, newTimbreListProc, _driver);
+
 	_driver->open();	// TODO: Handle return value != 0 (indicating an error)
 
 	// Set the parser's driver
@@ -400,6 +443,9 @@ MusicPlayerXMI::MusicPlayerXMI(GroovieEngine *vm, const Common::String &gtlName)
 		_chanBanks[i] = 0;
 	}
 
+	if (_milesAudioMode)
+		return;
+
 	// Load the Global Timbre Library
 	if (MidiDriver::getMusicType(dev) == MT_ADLIB) {
 		// MIDI through AdLib
@@ -433,6 +479,11 @@ MusicPlayerXMI::~MusicPlayerXMI() {
 }
 
 void MusicPlayerXMI::send(uint32 b) {
+	if (_milesAudioMode) {
+		MusicPlayerMidi::send(b);
+		return;
+	}
+
 	if ((b & 0xFFF0) == 0x72B0) { // XMIDI Patch Bank Select 114
 		// From AIL2's documentation: XMIDI Patch Bank Select controller (114)
 		// selects a bank to be used when searching the next patches
@@ -883,16 +934,18 @@ bool MusicPlayerIOS::load(uint32 fileref, bool loop) {
 	}
 
 	// Create the audio stream
-	Audio::AudioStream *audStream = Audio::SeekableAudioStream::openStreamFile(info.filename);
+	Audio::SeekableAudioStream *seekStream = Audio::SeekableAudioStream::openStreamFile(info.filename);
 
-	if (!audStream) {
+	if (!seekStream) {
 		warning("Could not play audio file '%s'", info.filename.c_str());
 		return false;
 	}
 
+	Audio::AudioStream *audStream = seekStream;
+
 	// Loop if requested
 	if (loop)
-		audStream = Audio::makeLoopingAudioStream((Audio::RewindableAudioStream *)audStream, 0);
+		audStream = Audio::makeLoopingAudioStream(seekStream, 0);
 
 	// MIDI player handles volume reset on load, IOS player doesn't - force update here
 	updateVolume();
diff --git a/engines/groovie/music.h b/engines/groovie/music.h
index 4853840673..dcb91d42a8 100644
--- a/engines/groovie/music.h
+++ b/engines/groovie/music.h
@@ -134,6 +134,8 @@ private:
 	// Output music type
 	uint8 _musicType;
 
+	bool _milesAudioMode;
+
 	// Timbres
 	class Timbre {
 	public:
diff --git a/engines/hopkins/computer.cpp b/engines/hopkins/computer.cpp
index 18b16cb4c8..16977e0cb8 100644
--- a/engines/hopkins/computer.cpp
+++ b/engines/hopkins/computer.cpp
@@ -325,13 +325,13 @@ static const char _spanishText[] =
 "% **** ORDENADOR DEL FBI NUMERO 4985 **** ORDENADOR J.HOPKINS *****\n"
 "% **** ORDENADOR DEL FBI NUMERO 4998 **** ORDENADOR S.COLLINS *****\n"
 "% *** ORDENADOR DEL FBI NUMERO 4997 *** ORDENADOR DE ACCESO LIBRE ***\n"
-"% LA CONTRASE\0245A ES: ALLFREE\n"
-"% ESCRIBE CONTRASE\0245A ACTUAL\n"
+"% LA CONTRASE\xA5" "A ES: ALLFREE\n"
+"% ESCRIBE CONTRASE\xA5" "A ACTUAL\n"
 "% **** ACCESO DENEGADO ****\n"
 "% 1) *** JUEGO ***\n"
 "% 0) SALIR DEL ORDENADOR\n"
-"% 2) CADAVER EXTRA\0245O\n"
-"% 3) CADAVER EXTRA\0245O\n"
+"% 2) CADAVER EXTRA\xA5" "O\n"
+"% 3) CADAVER EXTRA\xA5" "O\n"
 "% 4) SENADOR FERGUSSON\n"
 "% 5) MATAPERROS\n"
 "% 2) CIENTIFICO SECUESTRADO.\n"
diff --git a/engines/hopkins/lines.cpp b/engines/hopkins/lines.cpp
index 709f17a8b2..f511e6aa5a 100644
--- a/engines/hopkins/lines.cpp
+++ b/engines/hopkins/lines.cpp
@@ -2110,7 +2110,7 @@ RouteItem *LinesManager::cityMapCarRoute(int x1, int y1, int x2, int y2) {
 				_testRoute0[superRouteIdx].set(curRouteX, curRouteY, curRouteDir);
 				superRouteIdx++;
 				if (curRouteX == -1)
-					break;;
+					break;
 			}
 			if (curRouteX != -1) {
 				curRouteLineIdx = arrLineIdx[DIR_UP];
diff --git a/engines/hugo/mouse.cpp b/engines/hugo/mouse.cpp
index 558a596b35..3674c90757 100644
--- a/engines/hugo/mouse.cpp
+++ b/engines/hugo/mouse.cpp
@@ -121,12 +121,24 @@ void MouseHandler::cursorText(const char *buffer, const int16 cx, const int16 cy
 	int16 sx, sy;
 	if (cx < kXPix / 2) {
 		sx = cx + kCursorNameOffX;
-		sy = (_vm->_inventory->getInventoryObjId() == -1) ? cy + kCursorNameOffY : cy + kCursorNameOffY - (_vm->_screen->fontHeight() + 1);
+		if (_vm->_inventory->getInventoryObjId() == -1) {
+			sy = cy + kCursorNameOffY;
+		} else {
+			sy = cy + kCursorNameOffY - (_vm->_screen->fontHeight() + 1);
+			if (sy < 0) {
+				sx = cx + kCursorNameOffX + 25;
+				sy = cy + kCursorNameOffY;
+			}
+		}
 	} else {
 		sx = cx - sdx - kCursorNameOffX / 2;
 		sy = cy + kCursorNameOffY;
 	}
 
+	if (sy < 0) {
+		sy = 0;
+	}
+
 	// Display the string and add rect to display list
 	_vm->_screen->shadowStr(sx, sy, buffer, _TBRIGHTWHITE);
 	_vm->_screen->displayList(kDisplayAdd, sx, sy, sdx, sdy);
diff --git a/engines/kyra/sound_adlib.cpp b/engines/kyra/sound_adlib.cpp
index 89ee41e859..1d741d8bd0 100644
--- a/engines/kyra/sound_adlib.cpp
+++ b/engines/kyra/sound_adlib.cpp
@@ -55,7 +55,7 @@
 
 namespace Kyra {
 
-class AdLibDriver : public Audio::AudioStream {
+class AdLibDriver {
 public:
 	AdLibDriver(Audio::Mixer *mixer, int version);
 	~AdLibDriver();
@@ -70,34 +70,6 @@ public:
 
 	void callback();
 
-	// AudioStream API
-	int readBuffer(int16 *buffer, const int numSamples) {
-		int32 samplesLeft = numSamples;
-		memset(buffer, 0, sizeof(int16) * numSamples);
-		while (samplesLeft) {
-			if (!_samplesTillCallback) {
-				callback();
-				_samplesTillCallback = _samplesPerCallback;
-				_samplesTillCallbackRemainder += _samplesPerCallbackRemainder;
-				if (_samplesTillCallbackRemainder >= CALLBACKS_PER_SECOND) {
-					_samplesTillCallback++;
-					_samplesTillCallbackRemainder -= CALLBACKS_PER_SECOND;
-				}
-			}
-
-			int32 render = MIN(samplesLeft, _samplesTillCallback);
-			samplesLeft -= render;
-			_samplesTillCallback -= render;
-			YM3812UpdateOne(_adlib, buffer, render);
-			buffer += render;
-		}
-		return numSamples;
-	}
-
-	bool isStereo() const { return false; }
-	bool endOfData() const { return false; }
-	int getRate() const { return _mixer->getOutputRate(); }
-
 	void setSyncJumpMask(uint16 mask) { _syncJumpMask = mask; }
 
 	void setMusicVolume(uint8 volume);
@@ -334,11 +306,6 @@ private:
 	// _unkTable2_2[]  - One of the tables in _unkTable2[]
 	// _unkTable2_3[]  - One of the tables in _unkTable2[]
 
-	int32 _samplesPerCallback;
-	int32 _samplesPerCallbackRemainder;
-	int32 _samplesTillCallback;
-	int32 _samplesTillCallbackRemainder;
-
 	int _curChannel;
 	uint8 _soundTrigger;
 
@@ -365,7 +332,7 @@ private:
 	uint8 _unkValue19;
 	uint8 _unkValue20;
 
-	FM_OPL *_adlib;
+	OPL::OPL *_adlib;
 
 	uint8 *_soundData;
 	uint32 _soundDataSize;
@@ -411,7 +378,6 @@ private:
 
 	Common::Mutex _mutex;
 	Audio::Mixer *_mixer;
-	Audio::SoundHandle _soundHandle;
 
 	uint8 _musicVolume, _sfxVolume;
 
@@ -427,8 +393,9 @@ AdLibDriver::AdLibDriver(Audio::Mixer *mixer, int version) {
 
 	_mixer = mixer;
 
-	_adlib = makeAdLibOPL(getRate());
-	assert(_adlib);
+	_adlib = OPL::Config::create();
+	if (!_adlib || !_adlib->init())
+		error("Failed to create OPL");
 
 	memset(_channels, 0, sizeof(_channels));
 	_soundData = 0;
@@ -451,13 +418,6 @@ AdLibDriver::AdLibDriver(Audio::Mixer *mixer, int version) {
 
 	_tablePtr1 = _tablePtr2 = 0;
 
-	_mixer->playStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
-
-	_samplesPerCallback = getRate() / CALLBACKS_PER_SECOND;
-	_samplesPerCallbackRemainder = getRate() % CALLBACKS_PER_SECOND;
-	_samplesTillCallback = 0;
-	_samplesTillCallbackRemainder = 0;
-
 	_syncJumpMask = 0;
 
 	_musicVolume = 0;
@@ -467,11 +427,12 @@ AdLibDriver::AdLibDriver(Audio::Mixer *mixer, int version) {
 
 	_programQueueStart = _programQueueEnd = 0;
 	_retrySounds = false;
+
+	_adlib->start(new Common::Functor0Mem<void, AdLibDriver>(this, &AdLibDriver::callback), CALLBACKS_PER_SECOND);
 }
 
 AdLibDriver::~AdLibDriver() {
-	_mixer->stopHandle(_soundHandle);
-	OPLDestroy(_adlib);
+	delete _adlib;
 	_adlib = 0;
 }
 
@@ -877,7 +838,7 @@ void AdLibDriver::resetAdLibState() {
 // New calling style: writeOPL(0xAB, 0xCD)
 
 void AdLibDriver::writeOPL(byte reg, byte val) {
-	OPLWriteReg(_adlib, reg, val);
+	_adlib->writeReg(reg, val);
 }
 
 void AdLibDriver::initChannel(Channel &channel) {
@@ -947,15 +908,10 @@ void AdLibDriver::unkOutput2(uint8 chan) {
 	//
 	// This is very strange behavior, and causes problems with the ancient
 	// FMOPL code we borrowed from AdPlug. I've added a workaround. See
-	// fmopl.cpp for more details.
-	//
-	// More recent versions of the MAME FMOPL don't seem to have this
-	// problem, but cannot currently be used because of licensing and
-	// performance issues.
+	// audio/softsynth/opl/mame.cpp for more details.
 	//
-	// Ken Silverman's AdLib emulator (which can be found on his Web page -
-	// http://www.advsys.net/ken - and as part of AdPlug) also seems to be
-	// immune, but is apparently not as feature complete as MAME's.
+	// Fortunately, the more modern DOSBox FMOPL code does not seem to have
+	// any trouble with this.
 
 	writeOPL(0xB0 + chan, 0x20);
 }
diff --git a/engines/kyra/sound_intern.h b/engines/kyra/sound_intern.h
index 007ca3d3f5..4b77bf1351 100644
--- a/engines/kyra/sound_intern.h
+++ b/engines/kyra/sound_intern.h
@@ -151,7 +151,7 @@ private:
 	uint8 *_sfxFileData;
 	uint8 _sfxChannel;
 
-	TownsEuphonyDriver *_driver;
+	EuphonyPlayer *_player;
 
 	bool _cdaPlaying;
 
diff --git a/engines/kyra/sound_towns.cpp b/engines/kyra/sound_towns.cpp
index 725dedae3f..65ab4f31ef 100644
--- a/engines/kyra/sound_towns.cpp
+++ b/engines/kyra/sound_towns.cpp
@@ -37,13 +37,13 @@ SoundTowns::SoundTowns(KyraEngine_v1 *vm, Audio::Mixer *mixer)
 	: Sound(vm, mixer), _lastTrack(-1), _musicTrackData(0), _sfxFileData(0), _cdaPlaying(0),
 	_sfxFileIndex((uint)-1), _musicFadeTable(0), _sfxWDTable(0), _sfxBTTable(0), _sfxChannel(0x46), _currentResourceSet(0) {
 	memset(&_resInfo, 0, sizeof(_resInfo));
-	_driver = new TownsEuphonyDriver(_mixer);
+	_player = new EuphonyPlayer(_mixer);
 }
 
 SoundTowns::~SoundTowns() {
 	g_system->getAudioCDManager()->stop();
 	haltTrack();
-	delete _driver;
+	delete _player;
 	delete[] _musicTrackData;
 	delete[] _sfxFileData;
 	for (int i = 0; i < 3; i++)
@@ -58,15 +58,15 @@ bool SoundTowns::init() {
 	_sfxBTTable = _vm->staticres()->loadRawData(k1TownsSFXbtTable, unused);
 	_musicTrackData = new uint8[50570];
 
-	if (!_driver->init())
+	if (!_player->init())
 		return false;
 
 	if (!loadInstruments())
 		return false;
 
-	_driver->intf()->callback(68);
-	_driver->intf()->callback(70, 0x33);
-	_driver->setOutputVolume(1, 118, 118);
+	/*_player->driver()->intf()->callback(68);
+	_player->driver()->intf()->callback(70, 0x33);*/
+	_player->driver()->setOutputVolume(1, 118, 118);
 
 	return true;
 }
@@ -93,7 +93,7 @@ void SoundTowns::playTrack(uint8 track) {
 	beginFadeOut();
 
 	if (_musicEnabled == 2 && trackNum != -1) {
-		_driver->setOutputVolume(1, 118, 118);
+		_player->driver()->setOutputVolume(1, 118, 118);
 		g_system->getAudioCDManager()->play(trackNum + 1, loop ? -1 : 1, 0, 0);
 		g_system->getAudioCDManager()->updateCD();
 		_cdaPlaying = true;
@@ -112,12 +112,12 @@ void SoundTowns::haltTrack() {
 	_cdaPlaying = false;
 
 	for (int i = 0; i < 6; i++)
-		_driver->chanVolume(i, 0);
+		_player->driver()->channelVolume(i, 0);
 	for (int i = 0x40; i < 0x46; i++)
-		_driver->chanVolume(i, 0);
+		_player->driver()->channelVolume(i, 0);
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_enable(i, 0);
-	_driver->stopParser();
+		_player->configPart_enable(i, 0);
+	_player->stop();
 }
 
 void SoundTowns::initAudioResourceInfo(int set, void *info) {
@@ -179,11 +179,11 @@ void SoundTowns::playSoundEffect(uint8 track, uint8) {
 	if (offset == -1)
 		return;
 
-	if (!_driver->soundEffectIsPlaying(_sfxChannel ^ 1)) {
+	if (!_player->driver()->soundEffectIsPlaying(_sfxChannel ^ 1)) {
 		_sfxChannel ^= 1;
-	} else if (_driver->soundEffectIsPlaying(_sfxChannel)) {
+	} else if (_player->driver()->soundEffectIsPlaying(_sfxChannel)) {
 		_sfxChannel ^= 1;
-		_driver->stopSoundEffect(_sfxChannel);
+		_player->driver()->stopSoundEffect(_sfxChannel);
 	}
 
 	uint32 *sfxHeader = (uint32 *)(fileBody + offset);
@@ -221,57 +221,57 @@ void SoundTowns::playSoundEffect(uint8 track, uint8) {
 		}
 	}
 
-	_driver->chanVolume(_sfxChannel, 127);
-	_driver->chanPanPos(_sfxChannel, 0x40);
-	_driver->chanPitch(_sfxChannel, 0);
-	_driver->playSoundEffect(_sfxChannel, note, 127, sfxPlaybackBuffer);
+	_player->driver()->channelVolume(_sfxChannel, 127);
+	_player->driver()->channelPan(_sfxChannel, 0x40);
+	_player->driver()->channelPitch(_sfxChannel, 0);
+	_player->driver()->playSoundEffect(_sfxChannel, note, 127, sfxPlaybackBuffer);
 	delete[] sfxPlaybackBuffer;
 }
 
 void SoundTowns::updateVolumeSettings() {
-	if (!_driver)
+	if (!_player)
 		return;
 
 	bool mute = false;
-	_driver->setSoundEffectVolume(ConfMan.getInt("sfx_volume"));
+	_player->driver()->setSoundEffectVolume(ConfMan.getInt("sfx_volume"));
 	if (ConfMan.hasKey("mute"))
 		mute = ConfMan.getBool("mute");
 
-	_driver->setMusicVolume((mute ? 0 : ConfMan.getInt("music_volume")));
-	_driver->setSoundEffectVolume((mute ? 0 : ConfMan.getInt("sfx_volume")));
+	_player->driver()->setMusicVolume((mute ? 0 : ConfMan.getInt("music_volume")));
+	_player->driver()->setSoundEffectVolume((mute ? 0 : ConfMan.getInt("sfx_volume")));
 }
 
 void SoundTowns::stopAllSoundEffects() {
-	_driver->chanVolume(0x46, 0);
-	_driver->chanVolume(0x47, 0);
-	_driver->stopSoundEffect(0x46);
-	_driver->stopSoundEffect(0x47);
+	_player->driver()->channelVolume(0x46, 0);
+	_player->driver()->channelVolume(0x47, 0);
+	_player->driver()->stopSoundEffect(0x46);
+	_player->driver()->stopSoundEffect(0x47);
 	_sfxChannel = 0x46;
 }
 
 void SoundTowns::beginFadeOut() {
 	if (_cdaPlaying) {
 		for (int i = 118; i > 103; i--) {
-			_driver->setOutputVolume(1, i, i);
+			_player->driver()->setOutputVolume(1, i, i);
 			_vm->delay(2 * _vm->tickLength());
 		}
 
 		for (int i = 103; i > 83; i -= 2) {
-			_driver->setOutputVolume(1, i, i);
+			_player->driver()->setOutputVolume(1, i, i);
 			_vm->delay(2 * _vm->tickLength());
 		}
 
 		for (int i = 83; i > 58; i -= 2) {
-			_driver->setOutputVolume(1, i, i);
+			_player->driver()->setOutputVolume(1, i, i);
 			_vm->delay(_vm->tickLength());
 		}
 
 		for (int i = 58; i > 0; i--) {
-			_driver->setOutputVolume(1, i, i);
+			_player->driver()->setOutputVolume(1, i, i);
 			_vm->delay(1);
 		}
 
-		_driver->setOutputVolume(1, 0, 0);
+		_player->driver()->setOutputVolume(1, 0, 0);
 
 	} else {
 		if (_lastTrack == -1)
@@ -292,9 +292,9 @@ void SoundTowns::beginFadeOut() {
 
 		for (int i = 0; i < 12; i++) {
 			for (int ii = 0; ii < 6; ii++)
-				_driver->chanVolume(ii, fadeVolCur[ii]);
+				_player->driver()->channelVolume(ii, fadeVolCur[ii]);
 			for (int ii = 0x40; ii < 0x46; ii++)
-				_driver->chanVolume(ii, fadeVolCur[ii - 0x3A]);
+				_player->driver()->channelVolume(ii, fadeVolCur[ii - 0x3A]);
 
 			for (int ii = 0; ii < 6; ii++) {
 				fadeVolCur[ii] -= fadeVolStep[ii];
@@ -323,20 +323,20 @@ bool SoundTowns::loadInstruments() {
 
 	Screen::decodeFrame4(twm, _musicTrackData, 50570);
 	for (int i = 0; i < 128; i++)
-		_driver->loadInstrument(0, i, &_musicTrackData[i * 48 + 8]);
+		_player->driver()->loadInstrument(0, i, &_musicTrackData[i * 48 + 8]);
 
 	Screen::decodeFrame4(twm + 3232, _musicTrackData, 50570);
 	for (int i = 0; i < 32; i++)
-		_driver->loadInstrument(0x40, i, &_musicTrackData[i * 128 + 8]);
+		_player->driver()->loadInstrument(0x40, i, &_musicTrackData[i * 128 + 8]);
 
-	_driver->unloadWaveTable(-1);
+	_player->driver()->unloadWaveTable(-1);
 	uint8 *src = &_musicTrackData[32 * 128 + 8];
 	for (int i = 0; i < 10; i++) {
-		_driver->loadWaveTable(src);
+		_player->driver()->loadWaveTable(src);
 		src = src + READ_LE_UINT16(&src[12]) + 32;
 	}
 
-	_driver->reserveSoundEffectChannels(2);
+	_player->driver()->reserveSoundEffectChannels(2);
 
 	delete[] twm;
 
@@ -350,26 +350,26 @@ void SoundTowns::playEuphonyTrack(uint32 offset, int loop) {
 
 	const uint8 *src = _musicTrackData + 852;
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_enable(i, *src++);
+		_player->configPart_enable(i, *src++);
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_setMode(i, *src++);
+		_player->configPart_setType(i, *src++);
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_remap(i, *src++);
+		_player->configPart_remap(i, *src++);
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_adjustVolume(i, *src++);
+		_player->configPart_adjustVolume(i, *src++);
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_setTranspose(i, *src++);
+		_player->configPart_setTranspose(i, *src++);
 
 	src = _musicTrackData + 1748;
 	for (int i = 0; i < 6; i++)
-		_driver->assignChannel(i, *src++);
+		_player->driver()->assignPartToChannel(i, *src++);
 	for (int i = 0x40; i < 0x46; i++)
-		_driver->assignChannel(i, *src++);
+		_player->driver()->assignPartToChannel(i, *src++);
 
 	uint32 trackSize = READ_LE_UINT32(_musicTrackData + 2048);
 	uint8 startTick = _musicTrackData[2052];
 
-	_driver->setMusicTempo(_musicTrackData[2053]);
+	_player->setTempo(_musicTrackData[2053]);
 
 	src = _musicTrackData + 2054;
 	uint32 l = READ_LE_UINT32(src + trackSize);
@@ -377,14 +377,14 @@ void SoundTowns::playEuphonyTrack(uint32 offset, int loop) {
 	l = READ_LE_UINT32(src + trackSize);
 	trackSize += (l + 4);
 
-	_driver->setMusicLoop(loop);
-	_driver->startMusicTrack(src, trackSize, startTick);
+	_player->setLoopStatus(loop);
+	_player->startTrack(src, trackSize, startTick);
 }
 
 void SoundTowns::fadeOutSoundEffects() {
 	for (int i = 127; i > 0; i-= 12) {
-		_driver->chanVolume(0x46, i);
-		_driver->chanVolume(0x47, i);
+		_player->driver()->channelVolume(0x46, i);
+		_player->driver()->channelVolume(0x47, i);
 		_vm->delay(_vm->tickLength());
 	}
 	stopAllSoundEffects();
diff --git a/engines/kyra/staticres.cpp b/engines/kyra/staticres.cpp
index 731f2f4ce5..1a2e2c093c 100644
--- a/engines/kyra/staticres.cpp
+++ b/engines/kyra/staticres.cpp
@@ -39,7 +39,7 @@
 
 namespace Kyra {
 
-#define RESFILE_VERSION 86
+#define RESFILE_VERSION 87
 
 namespace {
 bool checkKyraDat(Common::SeekableReadStream *file) {
diff --git a/engines/lastexpress/data/snd.cpp b/engines/lastexpress/data/snd.cpp
index 2a221afadc..e310bafd18 100644
--- a/engines/lastexpress/data/snd.cpp
+++ b/engines/lastexpress/data/snd.cpp
@@ -442,7 +442,7 @@ void SimpleSound::loadHeader(Common::SeekableReadStream *in) {
 	_blockSize = _size / _blocks;
 }
 
-Audio::AudioStream *SimpleSound::makeDecoder(Common::SeekableReadStream *in, uint32 size, int32 filterId) const {
+LastExpress_ADPCMStream *SimpleSound::makeDecoder(Common::SeekableReadStream *in, uint32 size, int32 filterId) const {
 	return new LastExpress_ADPCMStream(in, DisposeAfterUse::YES, size, _blockSize, filterId);
 }
 
@@ -489,7 +489,7 @@ void StreamedSound::setFilterId(int32 filterId) {
 	if (!_as)
 		return;
 
-	((LastExpress_ADPCMStream *)_as)->setFilterId(filterId);
+	_as->setFilterId(filterId);
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -525,8 +525,8 @@ void AppendableSound::queueBuffer(Common::SeekableReadStream *bufferIn) {
 
 	// Setup the ADPCM decoder
 	uint32 sizeIn = (uint32)bufferIn->size();
-	Audio::AudioStream *adpcm = makeDecoder(bufferIn, sizeIn);
-	((LastExpress_ADPCMStream *)adpcm)->setFilterId(16);
+	LastExpress_ADPCMStream *adpcm = makeDecoder(bufferIn, sizeIn);
+	adpcm->setFilterId(16);
 
 	// Queue the stream
 	_as->queueAudioStream(adpcm);
diff --git a/engines/lastexpress/data/snd.h b/engines/lastexpress/data/snd.h
index f489304ff3..19e5fda9c9 100644
--- a/engines/lastexpress/data/snd.h
+++ b/engines/lastexpress/data/snd.h
@@ -49,6 +49,8 @@ class SeekableReadStream;
 
 namespace LastExpress {
 
+class LastExpress_ADPCMStream;
+
 class SimpleSound {
 public:
 	SimpleSound();
@@ -59,7 +61,7 @@ public:
 
 protected:
 	void loadHeader(Common::SeekableReadStream *in);
-	Audio::AudioStream *makeDecoder(Common::SeekableReadStream *in, uint32 size, int32 filterId = -1) const;
+	LastExpress_ADPCMStream *makeDecoder(Common::SeekableReadStream *in, uint32 size, int32 filterId = -1) const;
 	void play(Audio::AudioStream *as);
 
 	uint32 _size;   ///< data size
@@ -82,7 +84,7 @@ public:
 	void setFilterId(int32 filterId);
 
 private:
-	Audio::AudioStream *_as;
+	LastExpress_ADPCMStream *_as;
 	bool _loaded;
 };
 
diff --git a/engines/lure/res.h b/engines/lure/res.h
index 9002ca3056..19fbde1aad 100644
--- a/engines/lure/res.h
+++ b/engines/lure/res.h
@@ -100,7 +100,6 @@ public:
 	static Resources &getReference();
 	void reset();
 
-	byte *getResource(uint16 resId);
 	RoomDataList &roomData() { return _roomData; }
 	RoomData *getRoom(uint16 roomNumber);
 	bool checkHotspotExtent(HotspotData *hotspot);
diff --git a/engines/made/database.cpp b/engines/made/database.cpp
index a9855ba1fe..3eab31acc2 100644
--- a/engines/made/database.cpp
+++ b/engines/made/database.cpp
@@ -252,6 +252,10 @@ byte *ObjectV3::getData() {
 
 
 GameDatabase::GameDatabase(MadeEngine *vm) : _vm(vm) {
+	_gameState = nullptr;
+	_gameStateSize = 0;
+	_mainCodeObjectIndex = 0;
+	_isRedSource = false;
 }
 
 GameDatabase::~GameDatabase() {
@@ -595,6 +599,8 @@ const char *GameDatabaseV2::getString(uint16 offset) {
 /* GameDatabaseV3 */
 
 GameDatabaseV3::GameDatabaseV3(MadeEngine *vm) : GameDatabase(vm) {
+	_gameText = nullptr;
+	_gameStateOffs = 0;
 }
 
 void GameDatabaseV3::load(Common::SeekableReadStream &sourceS) {
diff --git a/engines/made/made.cpp b/engines/made/made.cpp
index af8156fc3e..ab07ef757b 100644
--- a/engines/made/made.cpp
+++ b/engines/made/made.cpp
@@ -275,7 +275,7 @@ void MadeEngine::handleEvents() {
 }
 
 Common::Error MadeEngine::run() {
-	_music = new MusicPlayer();
+	_music = new MusicPlayer(getGameID() == GID_RTZ);
 	syncSoundSettings();
 
 	// Initialize backend
diff --git a/engines/made/music.cpp b/engines/made/music.cpp
index b2917b58ed..f57da833c2 100644
--- a/engines/made/music.cpp
+++ b/engines/made/music.cpp
@@ -25,27 +25,67 @@
 // MIDI and digital music class
 
 #include "made/music.h"
+#include "made/redreader.h"
 #include "made/resource.h"
 
 #include "audio/midiparser.h"
+#include "audio/miles.h"
+
+#include "common/file.h"
+#include "common/stream.h"
 
 namespace Made {
 
-MusicPlayer::MusicPlayer() : _isGM(false) {
-	MidiPlayer::createDriver();
+MusicPlayer::MusicPlayer(bool milesAudio) : _isGM(false),_milesAudioMode(false) {
+	MusicType musicType = MT_INVALID;
+	if (milesAudio) {
+		MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_MT32);
+		musicType = MidiDriver::getMusicType(dev);
+		Common::SeekableReadStream *adLibInstrumentStream = nullptr;
+		switch (musicType) {
+		case MT_ADLIB:
+			_milesAudioMode = true;
+			if (Common::File::exists("rtzcd.red")) {
+				// Installing Return to Zork produces both a SAMPLE.AD and
+				// a SAMPLE.OPL file, but they are identical. The resource
+				// file appears to only contain SAMPLE.AD.
+				adLibInstrumentStream = RedReader::loadFromRed("rtzcd.red", "SAMPLE.AD");
+			}
+			_driver = Audio::MidiDriver_Miles_AdLib_create("SAMPLE.AD", "SAMPLE.OPL", adLibInstrumentStream);
+			delete adLibInstrumentStream;
+			break;
+		case MT_MT32:
+			_milesAudioMode = true;
+			_driver = Audio::MidiDriver_Miles_MT32_create("");
+			break;
+		default:
+			_milesAudioMode = false;
+			MidiPlayer::createDriver();
+			break;
+		}
+	} else {
+			MidiPlayer::createDriver();
+	}
 
 	int ret = _driver->open();
 	if (ret == 0) {
-		if (_nativeMT32)
-			_driver->sendMT32Reset();
-		else
-			_driver->sendGMReset();
+		if (musicType != MT_ADLIB) {
+			if (_nativeMT32)
+				_driver->sendMT32Reset();
+			else
+				_driver->sendGMReset();
+		}
 
 		_driver->setTimerCallback(this, &timerCallback);
 	}
 }
 
 void MusicPlayer::send(uint32 b) {
+	if (_milesAudioMode) {
+		_driver->send(b);
+		return;
+	}
+
 	if ((b & 0xF0) == 0xC0 && !_isGM && !_nativeMT32) {
 		b = (b & 0xFFFF00FF) | MidiDriver::_mt32ToGm[(b >> 8) & 0xFF] << 8;
 	}
diff --git a/engines/made/music.h b/engines/made/music.h
index 95d1bd35c1..558b41c2e2 100644
--- a/engines/made/music.h
+++ b/engines/made/music.h
@@ -38,7 +38,7 @@ enum MusicFlags {
 
 class MusicPlayer : public Audio::MidiPlayer {
 public:
-	MusicPlayer();
+	MusicPlayer(bool milesAudio);
 
 	void playXMIDI(GenericResource *midiResource, MusicFlags flags = MUSIC_NORMAL);
 	void playSMF(GenericResource *midiResource, MusicFlags flags = MUSIC_NORMAL);
@@ -51,6 +51,7 @@ public:
 
 protected:
 	bool _isGM;
+	bool _milesAudioMode;
 };
 
 } // End of namespace Made
diff --git a/engines/made/pmvplayer.cpp b/engines/made/pmvplayer.cpp
index 3cac017e10..453e2a4872 100644
--- a/engines/made/pmvplayer.cpp
+++ b/engines/made/pmvplayer.cpp
@@ -37,16 +37,18 @@
 
 namespace Made {
 
-PmvPlayer::PmvPlayer(MadeEngine *vm, Audio::Mixer *mixer) : _fd(NULL), _vm(vm), _mixer(mixer) {
+PmvPlayer::PmvPlayer(MadeEngine *vm, Audio::Mixer *mixer) : _fd(nullptr), _vm(vm), _mixer(mixer) {
+	_audioStream = nullptr;
+	_surface = nullptr;
+	_aborted = false;
 }
 
 PmvPlayer::~PmvPlayer() {
 }
 
 bool PmvPlayer::play(const char *filename) {
-
 	_aborted = false;
-	_surface = NULL;
+	_surface = nullptr;
 
 	_fd = new Common::File();
 	if (!_fd->open(filename)) {
@@ -81,8 +83,11 @@ bool PmvPlayer::play(const char *filename) {
 	// results to sound being choppy. Therefore, we set them to more
 	// "common" values here (11025 instead of 11127 and 22050 instead
 	// of 22254)
-	if (soundFreq == 11127) soundFreq = 11025;
-	if (soundFreq == 22254) soundFreq = 22050;
+	if (soundFreq == 11127)
+		soundFreq = 11025;
+
+	if (soundFreq == 22254)
+		soundFreq = 22050;
 
 	for (int i = 0; i < 22; i++) {
 		int unk = _fd->readUint16LE();
@@ -113,6 +118,8 @@ bool PmvPlayer::play(const char *filename) {
 	// get it to work well?
 	_audioStream = Audio::makeQueuingAudioStream(soundFreq, false);
 
+	SoundDecoderData *soundDecoderData = new SoundDecoderData();
+
 	while (!_vm->shouldQuit() && !_aborted && !_fd->eos() && frameNumber < frameCount) {
 
 		int32 frameTime = _vm->_system->getMillis();
@@ -148,7 +155,7 @@ bool PmvPlayer::play(const char *filename) {
 
 			soundSize = chunkCount * chunkSize;
 			soundData = (byte *)malloc(soundSize);
-			decompressSound(audioData + 8, soundData, chunkSize, chunkCount);
+			decompressSound(audioData + 8, soundData, chunkSize, chunkCount, NULL, soundDecoderData);
 			_audioStream->queueBuffer(soundData, soundSize, DisposeAfterUse::YES, Audio::FLAG_UNSIGNED);
 		}
 
@@ -208,6 +215,7 @@ bool PmvPlayer::play(const char *filename) {
 
 	}
 
+	delete soundDecoderData;
 	delete[] frameData;
 
 	_audioStream->finish();
diff --git a/engines/made/redreader.cpp b/engines/made/redreader.cpp
index f5e6ca85b3..f92ffd8dd8 100644
--- a/engines/made/redreader.cpp
+++ b/engines/made/redreader.cpp
@@ -76,6 +76,22 @@ bool RedReader::seekFile(Common::File &fd, FileEntry &fileEntry, const char *fil
 }
 
 LzhDecompressor::LzhDecompressor() {
+	freq = nullptr;
+	len_table = nullptr;
+	sortptr = nullptr;
+	_source = nullptr;
+
+	_compSize = 0;
+	_blockPos = 0;
+	_bitbuf = 0;
+	_subbitbuf = 0;
+	_bitcount = 0;
+	_blocksize = 0;
+	tree_n = 0;
+	heapsize = 0;
+	decode_i = 0;
+	decode_j = 0;
+	count_len_depth = 0;
 }
 
 LzhDecompressor::~LzhDecompressor() {
diff --git a/engines/made/resource.cpp b/engines/made/resource.cpp
index 2c75965976..f8e763e74e 100644
--- a/engines/made/resource.cpp
+++ b/engines/made/resource.cpp
@@ -241,6 +241,7 @@ void AnimationResource::load(byte *source, int size) {
 /* SoundResource */
 
 SoundResource::SoundResource() : _soundSize(0), _soundData(NULL) {
+	_soundEnergyArray = nullptr;
 }
 
 SoundResource::~SoundResource() {
@@ -377,6 +378,9 @@ void GenericResource::load(byte *source, int size) {
 ResourceReader::ResourceReader() {
 	_isV1 = false;
 	_cacheDataSize = 0;
+
+	_fd = _fdMusic = _fdPics = _fdSounds = nullptr;
+	_cacheCount = 0;
 }
 
 ResourceReader::~ResourceReader() {
diff --git a/engines/made/screenfx.cpp b/engines/made/screenfx.cpp
index 2a155d67ac..bae59f05cc 100644
--- a/engines/made/screenfx.cpp
+++ b/engines/made/screenfx.cpp
@@ -51,7 +51,12 @@ ScreenEffects::ScreenEffects(Screen *screen) : _screen(screen) {
 	vfxHeight = 0;
 
 	_fxPalette = new byte[768];
-
+	
+	_blendedPaletteStatus._active = false;
+	_blendedPaletteStatus._palette = _blendedPaletteStatus._newPalette = nullptr;
+	_blendedPaletteStatus._colorCount = 0;
+	_blendedPaletteStatus._value = _blendedPaletteStatus._maxValue = 0;
+	_blendedPaletteStatus._incr = 0;
 }
 
 ScreenEffects::~ScreenEffects() {
@@ -196,7 +201,7 @@ void ScreenEffects::startBlendedPalette(byte *palette, byte *newPalette, int col
 }
 
 void ScreenEffects::stepBlendedPalette() {
-	if (_blendedPaletteStatus._active && _blendedPaletteStatus._value < _blendedPaletteStatus._maxValue) {
+	if (_blendedPaletteStatus._active && _blendedPaletteStatus._value <= _blendedPaletteStatus._maxValue) {
 		setBlendedPalette(_blendedPaletteStatus._palette, _blendedPaletteStatus._newPalette,
 			_blendedPaletteStatus._colorCount, _blendedPaletteStatus._value, _blendedPaletteStatus._maxValue);
 		if (_blendedPaletteStatus._value == _blendedPaletteStatus._maxValue)
diff --git a/engines/made/screenfx.h b/engines/made/screenfx.h
index fd216bfd63..cedb059927 100644
--- a/engines/made/screenfx.h
+++ b/engines/made/screenfx.h
@@ -38,7 +38,6 @@ struct BlendedPaletteStatus {
 	byte *_palette, *_newPalette;
 	int _colorCount;
 	int16 _value, _maxValue, _incr;
-	int cnt;
 };
 
 class ScreenEffects {
diff --git a/engines/made/script.cpp b/engines/made/script.cpp
index 20fa026a40..f9f7acffde 100644
--- a/engines/made/script.cpp
+++ b/engines/made/script.cpp
@@ -122,6 +122,11 @@ ScriptInterpreter::ScriptInterpreter(MadeEngine *vm) : _vm(vm) {
 	_functions = new ScriptFunctions(_vm);
 	_functions->setupExternalsTable();
 
+	_localStackPos = 0;
+	_runningScriptObjectIndex = 0;
+	_codeBase = nullptr;
+	_codeIp = nullptr;
+
 #undef COMMAND
 }
 
diff --git a/engines/made/script.h b/engines/made/script.h
index bf75bc0875..f28425d13b 100644
--- a/engines/made/script.h
+++ b/engines/made/script.h
@@ -84,7 +84,6 @@ protected:
 	int16 _localStackPos;
 	int16 _runningScriptObjectIndex;
 	byte *_codeBase, *_codeIp;
-	bool _terminated;
 
 	ScriptFunctions *_functions;
 
diff --git a/engines/made/scriptfuncs.cpp b/engines/made/scriptfuncs.cpp
index efa765c7eb..bcc08e0dcc 100644
--- a/engines/made/scriptfuncs.cpp
+++ b/engines/made/scriptfuncs.cpp
@@ -42,6 +42,8 @@ ScriptFunctions::ScriptFunctions(MadeEngine *vm) : _vm(vm), _soundStarted(false)
 	_pcSpeaker2 = new Audio::PCSpeaker();
 	_vm->_system->getMixer()->playStream(Audio::Mixer::kMusicSoundType, &_pcSpeakerHandle1, _pcSpeaker1);
 	_vm->_system->getMixer()->playStream(Audio::Mixer::kMusicSoundType, &_pcSpeakerHandle2, _pcSpeaker2);
+	_soundResource = nullptr;
+	_musicRes = nullptr;
 }
 
 ScriptFunctions::~ScriptFunctions() {
diff --git a/engines/made/sound.cpp b/engines/made/sound.cpp
index 91e855cbf5..ad49031e7b 100644
--- a/engines/made/sound.cpp
+++ b/engines/made/sound.cpp
@@ -133,10 +133,10 @@ void ManholeEgaSoundDecompressor::update3() {
 		_sample2 += _sample1;
 }
 
-void decompressSound(byte *source, byte *dest, uint16 chunkSize, uint16 chunkCount, SoundEnergyArray *soundEnergyArray) {
+void decompressSound(byte *source, byte *dest, uint16 chunkSize, uint16 chunkCount, SoundEnergyArray *soundEnergyArray, SoundDecoderData *soundDecoderData) {
 
-	int16 prevSample = 0, workSample = 0;
-	byte soundBuffer[1025];
+	int16 prevSample, workSample;
+	byte* soundBuffer;
 	byte deltaSoundBuffer[1024];
 	int16 soundBuffer2[16];
 	byte deltaType, type;
@@ -159,6 +159,15 @@ void decompressSound(byte *source, byte *dest, uint16 chunkSize, uint16 chunkCou
 	if (soundEnergyArray)
 		soundEnergyArray->clear();
 
+	if (soundDecoderData) {
+		soundBuffer = soundDecoderData->_soundBuffer;
+		prevSample = soundDecoderData->_prevSample;
+	} else {
+		soundBuffer = new byte[1025];
+		memset(soundBuffer, 0x80, 1025);
+		prevSample = 0;
+	}
+
 	while (chunkCount--) {
 		deltaType = (*source) >> 6;
 		workChunkSize = chunkSize;
@@ -233,6 +242,11 @@ void decompressSound(byte *source, byte *dest, uint16 chunkSize, uint16 chunkCou
 		}
 
 		if (deltaType > 0) {
+			// NB: The original did not add this extra value at the end (as far
+			// as I can tell), and so technically read past the filled part of
+			// soundBuffer.
+			soundBuffer[workChunkSize] = soundBuffer[workChunkSize - 1];
+
 			if (deltaType == 1) {
 				for (i = 0; i < chunkSize - 1; i += 2) {
 					l = i / 2;
@@ -255,9 +269,13 @@ void decompressSound(byte *source, byte *dest, uint16 chunkSize, uint16 chunkCou
 		prevSample = workSample;
 		memcpy(dest, soundBuffer, chunkSize);
 		dest += chunkSize;
-
 	}
 
+	if (soundDecoderData) {
+		soundDecoderData->_prevSample = prevSample;
+	} else {
+		delete[] soundBuffer;
+	}
 }
 
 } // End of namespace Made
diff --git a/engines/made/sound.h b/engines/made/sound.h
index 6ffca13aaa..72537322f9 100644
--- a/engines/made/sound.h
+++ b/engines/made/sound.h
@@ -53,7 +53,22 @@ struct SoundEnergyItem {
 
 typedef Common::Array<SoundEnergyItem> SoundEnergyArray;
 
-void decompressSound(byte *source, byte *dest, uint16 chunkSize, uint16 chunkCount, SoundEnergyArray *soundEnergyArray = NULL);
+
+// Persistent data for decompressSound(). When calling decompressSound()
+// repeatedly (for the same stream), pass the same SoundDecoderData object to
+// ensure decoding properly resumes.
+class SoundDecoderData {
+public:
+	SoundDecoderData() {
+		memset(_soundBuffer, 0x80, sizeof(_soundBuffer));
+		_prevSample = 0;
+	}
+
+	byte _soundBuffer[1025];
+	int16 _prevSample;
+};
+
+void decompressSound(byte *source, byte *dest, uint16 chunkSize, uint16 chunkCount, SoundEnergyArray *soundEnergyArray = NULL, SoundDecoderData *decoderData = NULL);
 
 } // End of namespace Made
 
diff --git a/engines/mads/action.cpp b/engines/mads/action.cpp
index 199ae39000..f1c562675f 100644
--- a/engines/mads/action.cpp
+++ b/engines/mads/action.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -567,9 +567,8 @@ void MADSAction::leftClick() {
 		switch (userInterface._category) {
 		case CAT_COMMAND:
 			if (_selectedRow >= 0) {
-				if (_verbType == VERB_ONLY) {
+				if (_verbType == VERB_ONLY)
 					_selectedAction = -1;
-				}
 				else {
 					_recentCommand = _selectedRow;
 					_recentCommandSource = _commandSource;
diff --git a/engines/mads/action.h b/engines/mads/action.h
index cfd5a3be3f..3ea10cd964 100644
--- a/engines/mads/action.h
+++ b/engines/mads/action.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/animation.cpp b/engines/mads/animation.cpp
index 2b999fa305..e4f44fc308 100644
--- a/engines/mads/animation.cpp
+++ b/engines/mads/animation.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -41,7 +41,7 @@ void AAHeader::load(Common::SeekableReadStream *f) {
 	_spritesIndex = f->readUint16LE();
 	_scrollPosition.x = f->readSint16LE();
 	_scrollPosition.y = f->readSint16LE();
-	_scrollTicks = f->readUint32LE();
+	_scrollTicks = f->readUint32LE() & 0xffff;
 	f->skip(6);
 
 	char buffer[FILENAME_SIZE];
@@ -436,10 +436,8 @@ void Animation::update() {
 	if (_vm->_game->_scene._frameStartTime < _nextFrameTimer)
 		return;
 
-	for (uint idx = 0; idx < scene._spriteSlots.size(); ++idx) {
-		if (scene._spriteSlots[idx]._seqIndex >= 0x80)
-			scene._spriteSlots[idx]._flags = IMG_ERASE;
-	}
+	// Erase any active sprites
+	eraseSprites();
 
 	// Validate the current frame
 	if (_currentFrame >= (int)_miscEntries.size()) {
@@ -598,12 +596,19 @@ void Animation::setCurrentFrame(int frameNumber) {
 	_currentFrame = frameNumber;
 	_oldFrameEntry = 0;
 	_freeFlag = false;
-
-	_nextScrollTimer = _nextFrameTimer = _vm->_game->_scene._frameStartTime;
 }
 
 void Animation::setNextFrameTimer(int frameNumber) {
 	_nextFrameTimer = frameNumber;
 }
 
+void Animation::eraseSprites() {
+	Scene &scene = _vm->_game->_scene;
+
+	for (uint idx = 0; idx < scene._spriteSlots.size(); ++idx) {
+		if (scene._spriteSlots[idx]._seqIndex >= 0x80)
+			scene._spriteSlots[idx]._flags = IMG_ERASE;
+	}
+}
+
 } // End of namespace MADS
diff --git a/engines/mads/animation.h b/engines/mads/animation.h
index 8b85a5370d..46ef85c5eb 100644
--- a/engines/mads/animation.h
+++ b/engines/mads/animation.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -219,6 +219,11 @@ public:
 	 */
 	void update();
 
+	/**
+	 * Erases any sprites from the previous animation frame
+	 */
+	void eraseSprites();
+
 	void setNextFrameTimer(int frameNumber);
 	int getNextFrameTimer() const { return _nextFrameTimer; }
 	void setCurrentFrame(int frameNumber);
diff --git a/engines/mads/assets.cpp b/engines/mads/assets.cpp
index a2d495f311..1d4634e383 100644
--- a/engines/mads/assets.cpp
+++ b/engines/mads/assets.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/assets.h b/engines/mads/assets.h
index 155590f9bd..8a0dc2cd44 100644
--- a/engines/mads/assets.h
+++ b/engines/mads/assets.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/audio.cpp b/engines/mads/audio.cpp
index def2cd6c62..8f33f22243 100644
--- a/engines/mads/audio.cpp
+++ b/engines/mads/audio.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/audio.h b/engines/mads/audio.h
index 13c540bf85..5c3cd5e682 100644
--- a/engines/mads/audio.h
+++ b/engines/mads/audio.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/compression.cpp b/engines/mads/compression.cpp
index 79cd1786de..1f6f1ee202 100644
--- a/engines/mads/compression.cpp
+++ b/engines/mads/compression.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/compression.h b/engines/mads/compression.h
index f7381e4af3..b560ed33c1 100644
--- a/engines/mads/compression.h
+++ b/engines/mads/compression.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/debugger.cpp b/engines/mads/debugger.cpp
index 99251f9fbb..a6a4d3edbc 100644
--- a/engines/mads/debugger.cpp
+++ b/engines/mads/debugger.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * 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.
diff --git a/engines/mads/debugger.h b/engines/mads/debugger.h
index c8fee5f5b2..70b2cadc65 100644
--- a/engines/mads/debugger.h
+++ b/engines/mads/debugger.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * 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.
diff --git a/engines/mads/detection.cpp b/engines/mads/detection.cpp
index 971acde024..57f4776e82 100644
--- a/engines/mads/detection.cpp
+++ b/engines/mads/detection.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -29,6 +29,7 @@
 #include "common/memstream.h"
 #include "engines/advancedDetector.h"
 #include "common/system.h"
+#include "common/translation.h"
 #include "graphics/colormasks.h"
 #include "graphics/surface.h"
 #include "mads/events.h"
@@ -75,11 +76,71 @@ static const PlainGameDescriptor MADSGames[] = {
 	{0, 0}
 };
 
+#define GAMEOPTION_EASY_MOUSE          GUIO_GAMEOPTIONS1
+#define GAMEOPTION_ANIMATED_INVENTORY  GUIO_GAMEOPTIONS2
+#define GAMEOPTION_ANIMATED_INTERFACE  GUIO_GAMEOPTIONS3
+#define GAMEOPTION_NAUGHTY_MODE        GUIO_GAMEOPTIONS4
+//#define GAMEOPTION_GRAPHICS_DITHERING  GUIO_GAMEOPTIONS5
+
 #include "mads/detection_tables.h"
 
+static const ADExtraGuiOptionsMap optionsList[] = {
+	{
+		GAMEOPTION_EASY_MOUSE,
+		{
+			_s("Easy mouse interface"),
+			_s("Shows object names when hovering the mouse over them"),
+			"EasyMouse",
+			true
+		}
+	},
+
+	{
+		GAMEOPTION_ANIMATED_INVENTORY,
+		{
+			_s("Animated inventory items"),
+			_s("Animated inventory items"),
+			"InvObjectsAnimated",
+			true
+		}
+	},
+
+	{
+		GAMEOPTION_ANIMATED_INTERFACE,
+		{
+			_s("Animated game interface"),
+			_s("Animated game interface"),
+			"TextWindowAnimated",
+			true
+		}
+	},
+
+	{
+		GAMEOPTION_NAUGHTY_MODE,
+		{
+			_s("Naughty game mode"),
+			_s("Naughty game mode"),
+			"NaughtyMode",
+			true
+		}
+	},
+
+	/*{
+		GAMEOPTION_GRAPHICS_DITHERING,
+		{
+			_s("Graphics dithering"),
+			_s("Graphics dithering"),
+			"GraphicsDithering",
+			true
+		}
+	},*/
+
+	AD_EXTRA_GUI_OPTIONS_TERMINATOR
+};
+
 class MADSMetaEngine : public AdvancedMetaEngine {
 public:
-	MADSMetaEngine() : AdvancedMetaEngine(MADS::gameDescriptions, sizeof(MADS::MADSGameDescription), MADSGames) {
+	MADSMetaEngine() : AdvancedMetaEngine(MADS::gameDescriptions, sizeof(MADS::MADSGameDescription), MADSGames, optionsList) {
 		_maxScanDepth = 3;
 	}
 
diff --git a/engines/mads/detection_tables.h b/engines/mads/detection_tables.h
index e68ae380d0..56df09577c 100644
--- a/engines/mads/detection_tables.h
+++ b/engines/mads/detection_tables.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -37,7 +37,7 @@ static const MADSGameDescription gameDescriptions[] = {
 			Common::EN_ANY,
 			Common::kPlatformDOS,
 			ADGF_NO_FLAGS,
-			GUIO1(GUIO_NONE)
+			GUIO5(GUIO_NOSPEECH, GAMEOPTION_EASY_MOUSE, GAMEOPTION_ANIMATED_INVENTORY, GAMEOPTION_ANIMATED_INTERFACE, GAMEOPTION_NAUGHTY_MODE)
 		},
 		GType_RexNebular,
 		0
@@ -55,8 +55,8 @@ static const MADSGameDescription gameDescriptions[] = {
 			},
 			Common::EN_ANY,
 			Common::kPlatformDOS,
-			ADGF_NO_FLAGS,
-			GUIO1(GUIO_NONE)
+			ADGF_TESTING,
+			GUIO5(GUIO_NOSPEECH, GAMEOPTION_EASY_MOUSE, GAMEOPTION_ANIMATED_INVENTORY, GAMEOPTION_ANIMATED_INTERFACE, GAMEOPTION_NAUGHTY_MODE)
 		},
 		GType_RexNebular,
 		0
@@ -73,8 +73,8 @@ static const MADSGameDescription gameDescriptions[] = {
 			},
 			Common::EN_ANY,
 			Common::kPlatformDOS,
-			ADGF_NO_FLAGS,
-			GUIO1(GUIO_NONE)
+			ADGF_TESTING,
+			GUIO5(GUIO_NOSPEECH, GAMEOPTION_EASY_MOUSE, GAMEOPTION_ANIMATED_INVENTORY, GAMEOPTION_ANIMATED_INTERFACE, GAMEOPTION_NAUGHTY_MODE)
 		},
 		GType_RexNebular,
 		0
@@ -92,7 +92,7 @@ static const MADSGameDescription gameDescriptions[] = {
 			Common::EN_ANY,
 			Common::kPlatformDOS,
 			ADGF_NO_FLAGS,
-			GUIO1(GUIO_NONE)
+			GUIO1(GAMEOPTION_EASY_MOUSE)
 		},
 		GType_Phantom,
 		0
@@ -110,7 +110,7 @@ static const MADSGameDescription gameDescriptions[] = {
 			Common::EN_ANY,
 			Common::kPlatformDOS,
 			ADGF_NO_FLAGS,
-			GUIO1(GUIO_NONE)
+			GUIO1(GAMEOPTION_EASY_MOUSE)
 		},
 		GType_Dragonsphere,
 		0
diff --git a/engines/mads/dialogs.cpp b/engines/mads/dialogs.cpp
index 5e38f34fc6..d9b27ce926 100644
--- a/engines/mads/dialogs.cpp
+++ b/engines/mads/dialogs.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -43,6 +43,7 @@ Dialog::Dialog(MADSEngine *vm)
 }
 
 Dialog::~Dialog() {
+	delete _savedSurface;
 }
 
 void Dialog::save() {
@@ -430,6 +431,7 @@ void FullScreenDialog::display() {
 	if (_screenId > 0) {
 		SceneInfo *sceneInfo = SceneInfo::init(_vm);
 		sceneInfo->load(_screenId, 0, "", 0, scene._depthSurface, scene._backgroundSurface);
+		delete sceneInfo;
 	}
 
 	scene._priorSceneId = priorSceneId;
@@ -449,7 +451,7 @@ void FullScreenDialog::display() {
 	}
 
 	// Set Fx state and palette entries
-	game._fx = _vm->_screenFade == SCREEN_FADE_SMOOTH ? kTransitionFadeIn : kCenterVertTransition;
+	game._fx = _vm->_screenFade == SCREEN_FADE_SMOOTH ? kTransitionFadeIn : kNullPaletteCopy;
 	game._trigger = 0;
 
 	// Clear the screen and draw the upper and lower horizontal lines
diff --git a/engines/mads/dialogs.h b/engines/mads/dialogs.h
index 317c7bd792..efd2871d89 100644
--- a/engines/mads/dialogs.h
+++ b/engines/mads/dialogs.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/dragonsphere/dragonsphere_scenes.cpp b/engines/mads/dragonsphere/dragonsphere_scenes.cpp
index f32d17d9c9..6f5a28bff9 100644
--- a/engines/mads/dragonsphere/dragonsphere_scenes.cpp
+++ b/engines/mads/dragonsphere/dragonsphere_scenes.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -201,6 +201,10 @@ Common::String DragonsphereScene::formAnimName(char sepChar, int suffixNum) {
 /*------------------------------------------------------------------------*/
 
 void SceneInfoDragonsphere::loadCodes(MSurface &depthSurface, int variant) {
+	// The intro scenes do not have any codes
+	if (_sceneId >= 900)
+		return;
+
 	Common::String ext = Common::String::format(".WW%d", variant);
 	File f(Resources::formatName(RESPREFIX_RM, _sceneId, ext));
 	MadsPack codesPack(&f);
diff --git a/engines/mads/dragonsphere/dragonsphere_scenes.h b/engines/mads/dragonsphere/dragonsphere_scenes.h
index a6c778eca7..173cc667ce 100644
--- a/engines/mads/dragonsphere/dragonsphere_scenes.h
+++ b/engines/mads/dragonsphere/dragonsphere_scenes.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/dragonsphere/game_dragonsphere.cpp b/engines/mads/dragonsphere/game_dragonsphere.cpp
index 3836adb6d2..b07eab9daa 100644
--- a/engines/mads/dragonsphere/game_dragonsphere.cpp
+++ b/engines/mads/dragonsphere/game_dragonsphere.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/dragonsphere/game_dragonsphere.h b/engines/mads/dragonsphere/game_dragonsphere.h
index 7869dc87b4..b57f8833c6 100644
--- a/engines/mads/dragonsphere/game_dragonsphere.h
+++ b/engines/mads/dragonsphere/game_dragonsphere.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/events.cpp b/engines/mads/events.cpp
index de4dc3c070..7ba9098935 100644
--- a/engines/mads/events.cpp
+++ b/engines/mads/events.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -41,10 +41,9 @@ EventsManager::EventsManager(MADSEngine *vm) {
 	_mouseReleased = false;
 	_mouseButtons = 0;
 	_mouseStatus = 0;
-	_vD2 = 0;
+	_strokeGoing = 0;
 	_mouseStatusCopy = 0;
 	_mouseMoved = false;
-	_vD8 = 0;
 	_rightMousePressed = false;
 	_eventTarget = nullptr;
 }
@@ -85,8 +84,8 @@ void EventsManager::waitCursor() {
 	CursorType cursorId = (CursorType)MIN(_cursorSprites->getCount(), (int)CURSOR_WAIT);
 	_newCursorId = cursorId;
 	if (_cursorId != _newCursorId) {
-		changeCursor();
 		_cursorId = _newCursorId;
+		changeCursor();
 	}
 }
 
@@ -158,11 +157,17 @@ void EventsManager::pollEvents() {
 				_vm->_debugger->attach();
 				_vm->_debugger->onFrame();
 			} else {
-				_pendingKeys.push(event);
+				_pendingKeys.push(event.kbd);
 			}
 			return;
 		case Common::EVENT_KEYUP:
 			return;
+		case Common::EVENT_WHEELUP:
+			_pendingKeys.push(Common::KeyState(Common::KEYCODE_PAGEUP));
+			return;
+		case Common::EVENT_WHEELDOWN:
+			_pendingKeys.push(Common::KeyState(Common::KEYCODE_PAGEDOWN));
+			return;
 		case Common::EVENT_LBUTTONDOWN:
 		case Common::EVENT_RBUTTONDOWN:
 			_mouseClicked = true;
@@ -261,7 +266,7 @@ void EventsManager::waitForNextFrame() {
 void EventsManager::initVars() {
 	_mousePos = Common::Point(-1, -1);
 	_mouseStatusCopy = _mouseStatus;
-	_vD2 = _vD8 = 0;
+	_strokeGoing = 0;
 }
 
 } // End of namespace MADS
diff --git a/engines/mads/events.h b/engines/mads/events.h
index 54df337efd..1a2579cae0 100644
--- a/engines/mads/events.h
+++ b/engines/mads/events.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -67,11 +67,10 @@ public:
 	byte _mouseButtons;
 	bool _rightMousePressed;
 	int _mouseStatus;
-	int _vD2;
+	int _strokeGoing;
 	int _mouseStatusCopy;
 	bool _mouseMoved;
-	int _vD8;
-	Common::Stack<Common::Event> _pendingKeys;
+	Common::Stack<Common::KeyState> _pendingKeys;
 public:
 	/**
 	 * Constructor
@@ -169,6 +168,8 @@ public:
 	 * Returns true if there's any pending keys to be processed
 	 */
 	bool isKeyPressed() const { return !_pendingKeys.empty(); }
+
+	Common::KeyState getKey() { return _pendingKeys.pop(); }
 };
 
 } // End of namespace MADS
diff --git a/engines/mads/font.cpp b/engines/mads/font.cpp
index f7c1c52703..3e6d23fe6f 100644
--- a/engines/mads/font.cpp
+++ b/engines/mads/font.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/font.h b/engines/mads/font.h
index 47df647637..486cadcfff 100644
--- a/engines/mads/font.h
+++ b/engines/mads/font.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/game.cpp b/engines/mads/game.cpp
index 94653f9a39..91f6cd5630 100644
--- a/engines/mads/game.cpp
+++ b/engines/mads/game.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -100,13 +100,12 @@ Game::~Game() {
 	}
 
 	delete _saveFile;
+	_surface->free();
 	delete _surface;
 	delete _sectionHandler;
 }
 
 void Game::run() {
-	initializeGlobals();
-
 	// If requested, load a savegame instead of showing the intro
 	if (ConfMan.hasKey("save_slot")) {
 		int saveSlot = ConfMan.getInt("save_slot");
@@ -116,15 +115,17 @@ void Game::run() {
 
 	_statusFlag = true;
 
-	if (_loadGameSlot == -1) {
-		startGame();
-	}
+	while (!_vm->shouldQuit()) {
+		if (_loadGameSlot == -1) {
+			startGame();
+		}
 
-	// Get the initial starting time for the first scene
-	_scene._frameStartTime = _vm->_events->getFrameCounter();
+		// Get the initial starting time for the first scene
+		_scene._frameStartTime = _vm->_events->getFrameCounter();
 
-	if (!_vm->shouldQuit())
-		gameLoop();
+		if (!_vm->shouldQuit())
+			gameLoop();
+	}
 }
 
 void Game::splitQuote(const Common::String &source, Common::String &line1, Common::String &line2) {
@@ -140,7 +141,7 @@ void Game::splitQuote(const Common::String &source, Common::String &line1, Commo
 }
 
 void Game::gameLoop() {
-	while (!_vm->shouldQuit() && _statusFlag) {
+	while (!_vm->shouldQuit() && _statusFlag && !_winStatus) {
 		if (_loadGameSlot != -1) {
 			loadGame(_loadGameSlot);
 			_loadGameSlot = -1;
@@ -158,7 +159,7 @@ void Game::gameLoop() {
 			sectionLoop();
 
 		_player.releasePlayerSprites();
-		assert(_scene._sprites._assetCount == 0);
+		assert(_scene._sprites.size() == 0);
 
 		_vm->_palette->unlock();
 		_vm->_events->waitCursor();
@@ -168,7 +169,8 @@ void Game::gameLoop() {
 }
 
 void Game::sectionLoop() {
-	while (!_vm->shouldQuit() && _statusFlag && (_sectionNumber == _currentSectionNumber)) {
+	while (!_vm->shouldQuit() && _statusFlag && !_winStatus &&
+			(_sectionNumber == _currentSectionNumber)) {
 		_kernelMode = KERNEL_ROOM_PRELOAD;
 		_player._spritesChanged = true;
 		_quoteEmergency = false;
@@ -240,7 +242,7 @@ void Game::sectionLoop() {
 			_fx = kTransitionFadeOutIn;
 			break;
 		case SCREEN_FADE_FAST:
-			_fx = kCenterVertTransition;
+			_fx = kNullPaletteCopy;
 			break;
 		default:
 			_fx = kTransitionNone;
@@ -324,7 +326,7 @@ void Game::initSection(int sectionNumber) {
 	_vm->_palette->resetGamePalette(18, 10);
 	_vm->_palette->setLowRange();
 
-	if (_scene._layer == LAYER_GUI)
+	if (_scene._mode == SCREENMODE_VGA)
 		_vm->_palette->setPalette(_vm->_palette->_mainPalette, 0, 4);
 
 	_vm->_events->loadCursors("*CURSOR.SS");
@@ -403,12 +405,12 @@ Common::StringArray Game::getMessage(uint32 id) {
 
 static const char *const DEBUG_STRING = "WIDEPIPE";
 
-void Game::handleKeypress(const Common::Event &event) {
-	if (event.kbd.flags & Common::KBD_CTRL) {
+void Game::handleKeypress(const Common::KeyState &kbd) {
+	if (kbd.flags & Common::KBD_CTRL) {
 		if (_widepipeCtr == 8) {
 			// Implement original game cheating keys here someday
 		} else {
-			if (event.kbd.keycode == (Common::KEYCODE_a +
+			if (kbd.keycode == (Common::KEYCODE_a +
 					(DEBUG_STRING[_widepipeCtr] - 'a'))) {
 				if (++_widepipeCtr == 8) {
 					MessageDialog *dlg = new MessageDialog(_vm, 2,
@@ -420,7 +422,8 @@ void Game::handleKeypress(const Common::Event &event) {
 		}
 	}
 
-	switch (event.kbd.keycode) {
+	Scene &scene = _vm->_game->_scene;
+	switch (kbd.keycode) {
 	case Common::KEYCODE_F1:
 		_vm->_dialogs->_pendingDialog = DIALOG_GAME_MENU;
 		break;
@@ -430,6 +433,16 @@ void Game::handleKeypress(const Common::Event &event) {
 	case Common::KEYCODE_F7:
 		_vm->_dialogs->_pendingDialog = DIALOG_RESTORE;
 		break;
+	case Common::KEYCODE_PAGEUP:
+		scene._userInterface._scrollbarStrokeType = SCROLLBAR_UP;
+		scene._userInterface.changeScrollBar();
+		break;
+	case Common::KEYCODE_PAGEDOWN:
+		scene._userInterface._scrollbarStrokeType = SCROLLBAR_DOWN;
+		scene._userInterface.changeScrollBar();
+		break;
+
+
 	default:
 		break;
 	}
diff --git a/engines/mads/game.h b/engines/mads/game.h
index 1a61fc8ac8..95b54b0d1a 100644
--- a/engines/mads/game.h
+++ b/engines/mads/game.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -195,6 +195,9 @@ public:
 	 */
 	virtual void synchronize(Common::Serializer &s, bool phase1);
 
+	virtual void setNaughtyMode(bool naughtyMode) {}
+	virtual bool getNaughtyMode() const { return true; }
+
 	// DEPRECATED: ScummVM re-implementation keeps all the quotes loaded, so the methods below are stubs
 	void clearQuotes() {}
 	void loadQuoteRange(int startNum, int endNum) {}
@@ -204,7 +207,7 @@ public:
 	/**
 	* Handle a keyboard event
 	*/
-	void handleKeypress(const Common::Event &event);
+	void handleKeypress(const Common::KeyState &kbd);
 
 	/**
 	 * Starts a savegame loading.
diff --git a/engines/mads/game_data.cpp b/engines/mads/game_data.cpp
index 70e9e6c30b..6421d057e8 100644
--- a/engines/mads/game_data.cpp
+++ b/engines/mads/game_data.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/game_data.h b/engines/mads/game_data.h
index 65a9ae1553..e9bf45d8a5 100644
--- a/engines/mads/game_data.h
+++ b/engines/mads/game_data.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/globals.cpp b/engines/mads/globals.cpp
index 1d088992ea..e4a681d551 100644
--- a/engines/mads/globals.cpp
+++ b/engines/mads/globals.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/globals.h b/engines/mads/globals.h
index a6c9b628dd..27553a2b06 100644
--- a/engines/mads/globals.h
+++ b/engines/mads/globals.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/hotspots.cpp b/engines/mads/hotspots.cpp
index d75d7ae13e..8afef2e524 100644
--- a/engines/mads/hotspots.cpp
+++ b/engines/mads/hotspots.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * 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.
@@ -137,7 +137,7 @@ void DynamicHotspots::refresh() {
 			switch (scrObjects._inputMode) {
 			case kInputBuildingSentences:
 			case kInputLimitedSentences:
-				scrObjects.add(dh._bounds, _vm->_game->_scene._layer, CAT_12, dh._descId);
+				scrObjects.add(dh._bounds, _vm->_game->_scene._mode, CAT_12, dh._descId);
 				scrObjects._forceRescan = true;
 				break;
 			default:
@@ -193,9 +193,8 @@ Hotspot::Hotspot(Common::SeekableReadStream &f, bool isV2) {
 	_active = f.readByte() != 0;
 	_cursor = (CursorType)f.readByte();
 	if (isV2) {
-		// This looks to be some sort of bitmask. Perhaps it signifies
-		// the valid verbs for this hotspot
-		f.skip(2);		// unknown
+		f.skip(1);		// cursor
+		f.skip(1);		// syntax
 	}
 	_vocabId = f.readUint16LE();
 	_verbId = f.readUint16LE();
diff --git a/engines/mads/hotspots.h b/engines/mads/hotspots.h
index f9334eace8..902275bb21 100644
--- a/engines/mads/hotspots.h
+++ b/engines/mads/hotspots.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * 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.
diff --git a/engines/mads/inventory.cpp b/engines/mads/inventory.cpp
index ca05575ec5..fe1d24baea 100644
--- a/engines/mads/inventory.cpp
+++ b/engines/mads/inventory.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/inventory.h b/engines/mads/inventory.h
index cf82de59f1..2897f950e4 100644
--- a/engines/mads/inventory.h
+++ b/engines/mads/inventory.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/mads.cpp b/engines/mads/mads.cpp
index 52a0b40561..8c7b6b1ce3 100644
--- a/engines/mads/mads.cpp
+++ b/engines/mads/mads.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -38,12 +38,13 @@ namespace MADS {
 MADSEngine::MADSEngine(OSystem *syst, const MADSGameDescription *gameDesc) :
 		_gameDescription(gameDesc), Engine(syst), _randomSource("MADS") {
 
-	// Initialize fields
+	// Initialize game/engine options
 	_easyMouse = true;
 	_invObjectsAnimated = true;
 	_textWindowStill = false;
 	_screenFade = SCREEN_FADE_SMOOTH;
 	_musicFlag = true;
+	_soundFlag = true;
 	_dithering = false;
 
 	_debugger = nullptr;
@@ -95,9 +96,63 @@ void MADSEngine::initialize() {
 	_audio = new AudioPlayer(_mixer, getGameID());
 	_game = Game::init(this);
 
+	loadOptions();
+
 	_screen.empty();
 }
 
+void MADSEngine::loadOptions() {
+	if (ConfMan.hasKey("EasyMouse"))
+		_easyMouse = ConfMan.getBool("EasyMouse");
+
+	if (ConfMan.hasKey("mute") && ConfMan.getBool("mute")) {
+		_soundFlag = false;
+		_musicFlag = false;
+	} else {
+		_soundFlag = !ConfMan.hasKey("sfx_mute") || !ConfMan.getBool("sfx_mute");
+		_musicFlag = !ConfMan.hasGameDomain("music_mute") || !ConfMan.getBool("music_mute");
+	}
+
+	if (ConfMan.hasKey("ScreenFade"))
+		_screenFade = (ScreenFade)ConfMan.getInt("ScreenFade");
+	//if (ConfMan.hasKey("GraphicsDithering"))
+	//	_dithering = ConfMan.getBool("GraphicsDithering");
+
+	if (getGameID() == GType_RexNebular) {
+		if (ConfMan.hasKey("InvObjectsAnimated"))
+			_invObjectsAnimated = ConfMan.getBool("InvObjectsAnimated");
+		if (ConfMan.hasKey("TextWindowStill"))
+			_textWindowStill = !ConfMan.getBool("TextWindowAnimated");
+		if (ConfMan.hasKey("NaughtyMode"))
+			_game->setNaughtyMode(ConfMan.getBool("NaughtyMode"));
+	}
+
+	// Note: MADS is weird in that sfx and music are handled by the same driver,
+	// and the game scripts themselves check for music being enabled before playing
+	// a "music" sound. Which means we can independantly mute music in ScummVM, but
+	// otherwise all sound, music and sfx, is controlled by the SFX volume slider.
+	int soundVolume = MIN(255, ConfMan.getInt("sfx_volume"));
+	_sound->setVolume(soundVolume);
+}
+
+void MADSEngine::saveOptions() {
+	ConfMan.setBool("EasyMouse", _easyMouse);
+	ConfMan.setInt("ScreenFade", (int)_screenFade);
+	//ConfMan.setBool("GraphicsDithering", _dithering);
+
+	ConfMan.setBool("mute", !_soundFlag && !_musicFlag);
+	ConfMan.setBool("sfx_mute", !_soundFlag && _musicFlag);
+	ConfMan.setBool("music_mute", _soundFlag && !_musicFlag);
+
+	if (getGameID() == GType_RexNebular) {
+		ConfMan.setBool("InvObjectsAnimated", _invObjectsAnimated);
+		ConfMan.setBool("TextWindowAnimated", !_textWindowStill);
+		ConfMan.setBool("NaughtyMode", _game->getNaughtyMode());
+	}
+
+	ConfMan.flushToDisk();
+}
+
 Common::Error MADSEngine::run() {
 	initGraphics(MADS_SCREEN_WIDTH, MADS_SCREEN_HEIGHT, false);
 	initialize();
@@ -134,6 +189,12 @@ bool MADSEngine::canSaveGameStateCurrently() {
 		&& _events->_cursorId != CURSOR_WAIT;
 }
 
+void MADSEngine::syncSoundSettings() {
+	Engine::syncSoundSettings();
+
+	loadOptions();
+}
+
 /**
 * Support method that generates a savegame name
 * @param slot		Slot number
diff --git a/engines/mads/mads.h b/engines/mads/mads.h
index 9a8f2152a1..901035320a 100644
--- a/engines/mads/mads.h
+++ b/engines/mads/mads.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -84,6 +84,8 @@ private:
 	 * Handles basic initialisation
 	 */
 	void initialize();
+
+	void loadOptions();
 protected:
 	// Engine APIs
 	virtual Common::Error run();
@@ -104,6 +106,7 @@ public:
 	bool _textWindowStill;
 	ScreenFade _screenFade;
 	bool _musicFlag;
+	bool _soundFlag;
 	bool _dithering;
 public:
 	MADSEngine(OSystem *syst, const MADSGameDescription *gameDesc);
@@ -145,6 +148,13 @@ public:
 	 * Handles saving the game via the GMM
 	 */
 	virtual Common::Error saveGameState(int slot, const Common::String &desc);
+
+	/**
+	 * Handles updating sound settings after they're changed in the GMM dialog
+	 */
+	virtual void syncSoundSettings();
+
+	void saveOptions();
 };
 
 } // End of namespace MADS
diff --git a/engines/mads/menu_views.cpp b/engines/mads/menu_views.cpp
index ee4268a650..cfc3b09461 100644
--- a/engines/mads/menu_views.cpp
+++ b/engines/mads/menu_views.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -426,7 +426,7 @@ void TextView::doFrame() {
 			scene._textDisplay.expire(tl._textDisplayIndex);
 
 		tl._pos.y--;
-		if (tl._pos.y < 0) {
+		if (tl._pos.y + _font->getHeight() < 0) {
 			_textLines.remove_at(i);
 		} else {
 			tl._textDisplayIndex = scene._textDisplay.add(tl._pos.x, tl._pos.y,
@@ -484,6 +484,7 @@ AnimationView::AnimationView(MADSEngine *vm) : MenuView(vm) {
 	_animFrameNumber = 0;
 	_nextCyclingActive = false;
 	_sceneInfo = SceneInfo::init(_vm);
+	_scrollFrameCtr = 0;
 
 	load();
 }
@@ -543,16 +544,26 @@ void AnimationView::doFrame() {
 			scriptDone();
 		} else {
 			scene._frameStartTime = 0;
+			scene._spriteSlots.clear();
 			loadNextResource();
 		}
 	} else if (_currentAnimation->getCurrentFrame() == 1) {
 		scene._cyclingActive = _nextCyclingActive;
 	}
 
+	if (_currentAnimation && (++_scrollFrameCtr >= _currentAnimation->_header._scrollTicks)) {
+		_scrollFrameCtr = 0;
+		scroll();
+	}
+
 	if (_currentAnimation) {
 		++scene._frameStartTime;
 		_currentAnimation->update();
 		_redrawFlag = true;
+
+		if (_currentAnimation->freeFlag())
+			// We don't want the sprites removed after the last animation frame
+			scene._spriteSlots.clear();
 	}
 }
 
@@ -636,6 +647,21 @@ void AnimationView::loadNextResource() {
 	scene.initPaletteAnimation(paletteCycles, _nextCyclingActive && !_vm->_game->_fx);
 }
 
+void AnimationView::scroll() {
+	Scene &scene = _vm->_game->_scene;
+	Common::Point pt = _currentAnimation->_header._scrollPosition;
+
+	if (pt.x != 0) {
+		scene._backgroundSurface.scrollX(pt.x);
+		scene._spriteSlots.fullRefresh();
+	}
+
+	if (pt.y != 0) {
+		scene._backgroundSurface.scrollY(pt.y);
+		scene._spriteSlots.fullRefresh();
+	}
+}
+
 void AnimationView::scriptDone() {
 	_breakFlag = true;
 	_vm->_dialogs->_pendingDialog = DIALOG_MAIN_MENU;
@@ -657,6 +683,10 @@ void AnimationView::processLines() {
 				_currentLine += c;
 		}
 
+		// Check for comment line
+		if (_currentLine.hasPrefix("#"))
+			continue;
+
 		// Process the line
 		while (!_currentLine.empty()) {
 			if (_currentLine.hasPrefix("-")) {
diff --git a/engines/mads/menu_views.h b/engines/mads/menu_views.h
index cc5a13006f..6c8a2a8bdd 100644
--- a/engines/mads/menu_views.h
+++ b/engines/mads/menu_views.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -191,6 +191,7 @@ private:
 	int _manualFrame2;
 	int _animFrameNumber;
 	bool _nextCyclingActive;
+	uint _scrollFrameCtr;
 private:
 	void load();
 
@@ -201,6 +202,8 @@ private:
 	int getParameter();
 
 	void loadNextResource();
+
+	void scroll();
 protected:
 	virtual void display();
 
diff --git a/engines/mads/messages.cpp b/engines/mads/messages.cpp
index e83b69d210..d88806150d 100644
--- a/engines/mads/messages.cpp
+++ b/engines/mads/messages.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -69,7 +69,7 @@ void KernelMessages::clear() {
 }
 
 int KernelMessages::add(const Common::Point &pt, uint fontColor, uint8 flags,
-		uint8 abortTimers, uint32 timeout, const Common::String &msg) {
+		int endTrigger, uint32 timeout, const Common::String &msg) {
 	Scene &scene = _vm->_game->_scene;
 
 	// Find a free slot
@@ -77,7 +77,7 @@ int KernelMessages::add(const Common::Point &pt, uint fontColor, uint8 flags,
 	while ((idx < _entries.size()) && ((_entries[idx]._flags & KMSG_ACTIVE) != 0))
 		++idx;
 	if (idx == _entries.size()) {
-		if (abortTimers == 0)
+		if (endTrigger == 0)
 			return -1;
 
 		error("KernelMessages overflow");
@@ -91,8 +91,8 @@ int KernelMessages::add(const Common::Point &pt, uint fontColor, uint8 flags,
 	rec._position = pt;
 	rec._textDisplayIndex = -1;
 	rec._timeout = timeout;
-	rec._frameTimer = _vm->_game->_priorFrameTimer;
-	rec._trigger = abortTimers;
+	rec._frameTimer = scene._frameStartTime;
+	rec._trigger = endTrigger;
 	rec._abortMode = _vm->_game->_triggerSetupMode;
 
 	rec._actionDetails = scene._action._activeAction;
@@ -104,10 +104,10 @@ int KernelMessages::add(const Common::Point &pt, uint fontColor, uint8 flags,
 	return idx;
 }
 
-int KernelMessages::addQuote(int quoteId, int abortTimers, uint32 timeout) {
+int KernelMessages::addQuote(int quoteId, int endTrigger, uint32 timeout) {
 	Common::String quoteStr = _vm->_game->getQuote(quoteId);
 	return add(Common::Point(), 0x1110, KMSG_PLAYER_TIMEOUT | KMSG_CENTER_ALIGN,
-		abortTimers, timeout, quoteStr);
+		endTrigger, timeout, quoteStr);
 }
 
 void KernelMessages::scrollMessage(int msgIndex, int numTicks, bool quoted) {
@@ -162,8 +162,10 @@ void KernelMessages::update() {
 	uint32 currentTimer = _vm->_game->_scene._frameStartTime;
 
 	for (uint i = 0; i < _entries.size() && !_vm->_game->_trigger; ++i) {
-		KernelMessage &msg = _entries[i];
+		if (_vm->_game->_trigger)
+			break;
 
+		KernelMessage &msg = _entries[i];
 		if (((msg._flags & KMSG_ACTIVE) != 0) && (currentTimer >= msg._frameTimer))
 			processText(i);
 	}
@@ -172,7 +174,7 @@ void KernelMessages::update() {
 void KernelMessages::processText(int msgIndex) {
 	Scene &scene = _vm->_game->_scene;
 	KernelMessage &msg = _entries[msgIndex];
-	uint32 currentTimer = _vm->_game->_priorFrameTimer;
+	uint32 currentTimer = scene._frameStartTime;
 	bool flag = false;
 
 	if ((msg._flags & KMSG_EXPIRE) != 0) {
diff --git a/engines/mads/messages.h b/engines/mads/messages.h
index a7411d98d1..764477a7fc 100644
--- a/engines/mads/messages.h
+++ b/engines/mads/messages.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -99,9 +99,9 @@ public:
 	~KernelMessages();
 
 	void clear();
-	int add(const Common::Point &pt, uint fontColor, uint8 flags, uint8 abortTimers,
+	int add(const Common::Point &pt, uint fontColor, uint8 flags, int endTrigger,
 		uint32 timeout, const Common::String &msg);
-	int addQuote(int quoteId, int abortTimers, uint32 timeout);
+	int addQuote(int quoteId, int endTrigger, uint32 timeout);
 	void scrollMessage(int msgIndex, int numTicks, bool quoted);
 	void setSeqIndex(int msgIndex, int seqIndex);
 	void remove(int msgIndex);
diff --git a/engines/mads/module.mk b/engines/mads/module.mk
index fc04a2f8ba..7cb7a91e8c 100644
--- a/engines/mads/module.mk
+++ b/engines/mads/module.mk
@@ -4,7 +4,9 @@ MODULE_OBJS := \
 	dragonsphere/game_dragonsphere.o \
 	dragonsphere/dragonsphere_scenes.o \
 	phantom/game_phantom.o \
+	phantom/globals_phantom.o \
 	phantom/phantom_scenes.o \
+	phantom/phantom_scenes1.o \
 	nebular/dialogs_nebular.o \
 	nebular/game_nebular.o \
 	nebular/globals_nebular.o \
diff --git a/engines/mads/msurface.cpp b/engines/mads/msurface.cpp
index 39824bac4b..f768624278 100644
--- a/engines/mads/msurface.cpp
+++ b/engines/mads/msurface.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -308,6 +308,9 @@ void MSurface::copyFrom(MSurface *src, const Common::Point &destPos, int depth,
 		if (!copyRect.isValidRect())
 			return;
 
+		if (flipped)
+			copyRect.moveTo(0, copyRect.top);
+
 		byte *data = src->getData();
 		byte *srcPtr = data + (src->getWidth() * copyRect.top + copyRect.left);
 		byte *destPtr = (byte *)pixels + (destY * pitch) + destX;
@@ -397,14 +400,16 @@ void MSurface::copyFrom(MSurface *src, const Common::Point &destPos, int depth,
 		const byte *srcP = srcPixelsP;
 		byte *destP = destPixelsP;
 
-		for (int xp = 0, sprX = 0; xp < frameWidth; ++xp, ++srcP) {
-			if (xp < spriteLeft)
-				// Not yet reached start of display area
-				continue;
-			if (!lineDist[sprX++])
+		for (int xp = 0, sprX = -1; xp < frameWidth; ++xp, ++srcP) {
+			if (!lineDist[xp])
 				// Not a display pixel
 				continue;
 
+			++sprX;
+			if (sprX < spriteLeft || sprX >= spriteRight)
+				// Skip pixel if it's not in horizontal display portion
+				continue;
+
 			// Get depth of current output pixel in depth surface
 			Common::Point pt((destP - (byte *)this->pixels) % this->pitch,
 				(destP - (byte *)this->pixels) / this->pitch);
@@ -485,7 +490,6 @@ void MSurface::scrollY(int yAmount) {
 	delete[] tempData;
 }
 
-
 void MSurface::translate(Common::Array<RGB6> &palette) {
 	for (int y = 0; y < this->h; ++y) {
 		byte *pDest = getBasePtr(0, y);
@@ -521,6 +525,20 @@ MSurface *MSurface::flipHorizontal() const {
 	return dest;
 }
 
+void MSurface::copyRectTranslate(MSurface &srcSurface, const byte *paletteMap,
+		const Common::Point &destPos, const Common::Rect &srcRect) {
+	// Loop through the lines
+	for (int yCtr = 0; yCtr < srcRect.height(); ++yCtr) {
+		const byte *srcP = srcSurface.getBasePtr(srcRect.left, srcRect.top + yCtr);
+		byte *destP = getBasePtr(destPos.x, destPos.y + yCtr);
+
+		// Copy the line over
+		for (int xCtr = 0; xCtr < srcRect.width(); ++xCtr, ++srcP, ++destP) {
+			*destP = paletteMap[*srcP];
+		}
+	}
+}
+
 /*------------------------------------------------------------------------*/
 
 int DepthSurface::getDepth(const Common::Point &pt) {
diff --git a/engines/mads/msurface.h b/engines/mads/msurface.h
index 650d7fdaee..80891afb83 100644
--- a/engines/mads/msurface.h
+++ b/engines/mads/msurface.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -220,6 +220,13 @@ public:
 	 * Create a new surface which is a flipped horizontal copy of the current one
 	 */
 	MSurface *flipHorizontal() const;
+
+	/**
+	 * Copy an area from one surface to another, translating it using a palette
+	 * map as it's done
+	 */
+	void copyRectTranslate(MSurface &srcSurface, const byte *paletteMap,
+		const Common::Point &destPos, const Common::Rect &srcRect);
 };
 
 class DepthSurface : public MSurface {
diff --git a/engines/mads/nebular/dialogs_nebular.cpp b/engines/mads/nebular/dialogs_nebular.cpp
index f5355517bd..960a2cc2f4 100644
--- a/engines/mads/nebular/dialogs_nebular.cpp
+++ b/engines/mads/nebular/dialogs_nebular.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -91,6 +91,8 @@ bool DialogsNebular::show(int messageId, int objectId) {
 							dialog->incNumLines();
 						}
 					} else if (commandCheck("ASK", valStr, commandText)) {
+						if (!dialog)
+							error("DialogsNebular::show - Uninitialized dialog");
 						dialog->addInput();
 					} else if (commandCheck("VERB", valStr, commandText)) {
 						dialogText += getVocab(action._activeAction._verbId);
@@ -114,12 +116,18 @@ bool DialogsNebular::show(int messageId, int objectId) {
 					} else if (commandCheck("WIDTH", valStr, commandText)) {
 						_dialogWidth = atoi(valStr.c_str());
 					} else if (commandCheck("BAR", valStr, commandText)) {
+						if (!dialog)
+							error("DialogsNebular::show - Uninitialized dialog");
 						dialog->addBarLine();
 					} else if (commandCheck("UNDER", valStr, commandText)) {
 						underlineFlag = true;
 					} else if (commandCheck("DOWN", valStr, commandText)) {
+						if (!dialog)
+							error("DialogsNebular::show - Uninitialized dialog");
 						dialog->downPixelLine();
 					} else if (commandCheck("TAB", valStr, commandText)) {
+						if (!dialog)
+							error("DialogsNebular::show - Uninitialized dialog");
 						int xp = atoi(valStr.c_str());
 						dialog->setLineXp(xp);
 					}
@@ -164,6 +172,9 @@ bool DialogsNebular::show(int messageId, int objectId) {
 	if (!centerFlag)
 		dialog->incNumLines();
 
+	if (!dialog)
+		error("DialogsNebular::show - Uninitialized dialog");
+
 	// Show the dialog
 	_vm->_events->setCursor(CURSOR_ARROW);
 	dialog->show();
@@ -317,7 +328,7 @@ void DialogsNebular::showDialog() {
 			TextView *dlg = new RexTextView(_vm);
 			dlg->show();
 			delete dlg;
-			break;
+			return;
 		}
 		case DIALOG_ANIMVIEW: {
 			AnimationView *dlg = new RexAnimationView(_vm);
@@ -333,7 +344,7 @@ void DialogsNebular::showDialog() {
 
 void DialogsNebular::showScummVMSaveDialog() {
 	Nebular::GameNebular &game = *(Nebular::GameNebular *)_vm->_game;
-	Scene *scene = &(game._scene);
+	Scene &scene = game._scene;
 	GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Save game:"), _("Save"), true);
 
 	int slot = dialog->runModalWithCurrentTarget();
@@ -345,24 +356,31 @@ void DialogsNebular::showScummVMSaveDialog() {
 			desc = dialog->createDefaultSaveDescription(slot);
 		}
 
-		scene->_spriteSlots.reset();
-		scene->loadScene(scene->_currentSceneId, game._aaName, true);
-		scene->_userInterface.noInventoryAnim();
+		scene._spriteSlots.reset();
+		scene.loadScene(scene._currentSceneId, game._aaName, true);
+		scene._userInterface.noInventoryAnim();
 		game._scene.drawElements(kTransitionFadeIn, false);
 
 		game.saveGame(slot, desc);
 	}
+
+	// Flag for scene loading that we're returning from a dialog
+	scene._currentSceneId = RETURNING_FROM_DIALOG;
 }
 
 void DialogsNebular::showScummVMRestoreDialog() {
 	Nebular::GameNebular &game = *(Nebular::GameNebular *)_vm->_game;
 	GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Restore game:"), _("Restore"), false);
+	Scene &scene = game._scene;
 
 	int slot = dialog->runModalWithCurrentTarget();
 	if (slot >= 0) {
 		game._loadGameSlot = slot;
-		game._scene._currentSceneId = -1;
+		game._scene._currentSceneId = RETURNING_FROM_LOADING;
 		game._currentSectionNumber = -1;
+	} else {
+		// Flag for scene loading that we're returning from a dialog
+		scene._currentSceneId = RETURNING_FROM_DIALOG;
 	}
 }
 
@@ -376,8 +394,7 @@ TextDialog(vm, FONT_INTERFACE, Common::Point(-1, -1), 32) {
 		addLine("ANSWER INCORRECT!", true);
 		wordWrap("\n");
 		addLine("(But we'll give you another chance!)");
-	}
-	else {
+	} else {
 		addLine("REX NEBULAR version 8.43", true);
 		wordWrap("\n");
 		addLine("(Copy Protection, for your convenience)");
@@ -400,7 +417,7 @@ TextDialog(vm, FONT_INTERFACE, Common::Point(-1, -1), 32) {
 		_hogEntry._pageNum, _hogEntry._lineNum, _hogEntry._wordNum);
 	wordWrap(line);
 
-	wordWrap("and type it on the line below (we',27h,'ve even given you");
+	wordWrap("and type it on the line below (we've even given you");
 	wordWrap("first letter as a hint).  As soon as you do that, we can get");
 	wordWrap("right into this really COOL adventure game!\n");
 	wordWrap("\n");
@@ -411,17 +428,58 @@ TextDialog(vm, FONT_INTERFACE, Common::Point(-1, -1), 32) {
 
 void CopyProtectionDialog::show() {
 	draw();
-	_vm->_events->showCursor();
 
-	// TODO: Replace with text input
-	while (!_vm->shouldQuit() && !_vm->_events->isKeyPressed() &&
-		!_vm->_events->_mouseClicked) {
-		_vm->_events->delay(1);
+	Common::KeyState curKey;
+	const Common::Rect inputArea(110, 165, 210, 175);
+	MSurface *origInput = new MSurface(inputArea.width(), inputArea.height());
+	_vm->_screen.frameRect(inputArea, TEXTDIALOG_BLACK);
+	_vm->_screen.copyTo(origInput, inputArea, Common::Point(0, 0));
+	_font->setColors(TEXTDIALOG_FE, TEXTDIALOG_FE, TEXTDIALOG_FE, TEXTDIALOG_FE);
+	_vm->_screen.copyRectToScreen(inputArea);
+	_vm->_screen.updateScreen();
+
+	bool firstTime = true;
+
+	while (!_vm->shouldQuit()) {
+		if (!firstTime) {
+			while (!_vm->shouldQuit() && !_vm->_events->isKeyPressed()) {
+				_vm->_events->delay(1);
+			}
+
+			if (_vm->shouldQuit())
+				break;
+
+			curKey = _vm->_events->getKey();
+
+			if (curKey.keycode == Common::KEYCODE_RETURN || curKey.keycode == Common::KEYCODE_KP_ENTER)
+				break;
+			else if (curKey.keycode == Common::KEYCODE_BACKSPACE)
+				_textInput.deleteLastChar();
+			else if (_textInput.size() < 14)
+				_textInput += curKey.ascii;
+
+			_vm->_events->_pendingKeys.clear();
+		} else {
+			firstTime = false;
+			_textInput = _hogEntry._word[0];
+		}
+
+		_vm->_screen.copyFrom(origInput, Common::Rect(0, 0, inputArea.width(), inputArea.height()), Common::Point(inputArea.left, inputArea.top));
+		_font->writeString(&_vm->_screen, _textInput,
+			Common::Point(inputArea.left + 2, inputArea.top + 1), 1);
+		_vm->_screen.copyRectToScreen(inputArea);
+		_vm->_screen.updateScreen();
 	}
 
-	_vm->_events->_pendingKeys.clear();
+	origInput->free();
+	delete origInput;
+}
+
+bool CopyProtectionDialog::isCorrectAnswer() {
+	return _hogEntry._word == _textInput;
 }
 
+
 bool CopyProtectionDialog::getHogAnusEntry(HOGANUS &entry) {
 	File f;
 	f.open("*HOGANUS.DAT");
@@ -535,6 +593,7 @@ void PictureDialog::save() {
 void PictureDialog::restore() {
 	if (_savedSurface) {
 		_savedSurface->copyTo(&_vm->_screen);
+		_savedSurface->free();
 		delete _savedSurface;
 		_savedSurface = nullptr;
 
@@ -602,9 +661,12 @@ GameDialog::GameDialog(MADSEngine *vm) : FullScreenDialog(vm) {
 }
 
 void GameDialog::display() {
+	Palette &palette = *_vm->_palette;
+	palette.initPalette();
+	palette.resetGamePalette(18, 10);
+
 	FullScreenDialog::display();
 
-	Palette &palette = *_vm->_palette;
 	palette.setEntry(10, 0, 63, 0);
 	palette.setEntry(11, 0, 45, 0);
 	palette.setEntry(12, 63, 63, 0);
@@ -624,6 +686,7 @@ void GameDialog::display() {
 
 GameDialog::~GameDialog() {
 	_vm->_screen.resetClipBounds();
+	_vm->_game->_scene._currentSceneId = RETURNING_FROM_DIALOG;
 }
 
 void GameDialog::clearLines() {
@@ -643,14 +706,14 @@ void GameDialog::setClickableLines() {
 			int maxHeight = _lines[idx]._font->getHeight();
 
 			screenObjects.add(Common::Rect(pt.x, pt.y, pt.x + strWidth, pt.y + maxHeight - 1),
-				LAYER_GUI, CAT_COMMAND, idx);
+				SCREENMODE_VGA, CAT_COMMAND, idx);
 		}
 	}
 
 	if (_vm->_dialogs->_pendingDialog == DIALOG_SAVE ||
 			_vm->_dialogs->_pendingDialog == DIALOG_RESTORE) {
-		screenObjects.add(Common::Rect(293, 26, 312, 75), LAYER_GUI, CAT_INV_LIST, 50);
-		screenObjects.add(Common::Rect(293, 78, 312, 127), LAYER_GUI, CAT_INV_LIST, 51);
+		screenObjects.add(Common::Rect(293, 26, 312, 75), SCREENMODE_VGA, CAT_INV_LIST, 50);
+		screenObjects.add(Common::Rect(293, 78, 312, 127), SCREENMODE_VGA, CAT_INV_LIST, 51);
 	}
 }
 
@@ -794,7 +857,7 @@ void GameDialog::show() {
 
 	Scene &scene = _vm->_game->_scene;
 
-	while (_selectedLine < 1 && !_vm->shouldQuit()) {
+	while (_selectedLine == -1 && !_vm->shouldQuit()) {
 		handleEvents();
 		if (_redrawFlag) {
 			if (!_tempLine)
@@ -821,11 +884,21 @@ void GameDialog::handleEvents() {
 		_lines[i]._state = DLGSTATE_UNSELECTED;
 
 	// Process pending events
-	_vm->_events->pollEvents();
+	events.pollEvents();
+
+	if (events.isKeyPressed()) {
+		switch (events.getKey().keycode) {
+		case Common::KEYCODE_ESCAPE:
+			_selectedLine = 0;
+			break;
+		default:
+			break;
+		}
+	}
 
 	// Scan for objects in the dialog
 	Common::Point mousePos = events.currentPos() - Common::Point(0, DIALOG_TOP);
-	int objIndex = screenObjects.scan(mousePos, LAYER_GUI);
+	int objIndex = screenObjects.scan(mousePos, SCREENMODE_VGA);
 
 	if (_movedFlag) {
 		int yp = mousePos.y;
@@ -1000,12 +1073,13 @@ void GameMenuDialog::show() {
 		_vm->_dialogs->_pendingDialog = DIALOG_OPTIONS;
 		_vm->_dialogs->showDialog();
 		break;
+	case 5:
+		_vm->quitGame();
+		break;
 	case 4:
+	default:
 		// Resume game
 		break;
-	case 5:
-	default:
-		_vm->quitGame();
 	}
 }
 
@@ -1018,12 +1092,11 @@ OptionsDialog::OptionsDialog(MADSEngine *vm) : GameDialog(vm) {
 int OptionsDialog::getOptionQuote(int option) {
 	Nebular::GameNebular &game = *(Nebular::GameNebular *)_vm->_game;
 
-	// TODO: Hook the rest of the options to the current config
 	switch (option) {
 	case 17:	// Music
-		return 24;	// 24: ON, 25: OFF
+		return _vm->_musicFlag ? 24 : 25;	// 24: ON, 25: OFF
 	case 18:	// Sound
-		return 26;	// 26: ON, 27: OFF
+		return _vm->_soundFlag ? 26 : 27;	// 26: ON, 27: OFF
 	case 19:	// Interface
 		return !_vm->_easyMouse ? 28 : 29;	// 28: Standard, 29: Easy
 	case 20:	// Inventory
@@ -1066,6 +1139,7 @@ void OptionsDialog::show() {
 	Nebular::GameNebular &game = *(Nebular::GameNebular *)_vm->_game;
 
 	// Previous options, restored when cancel is selected
+	bool prevMusicFlag = _vm->_musicFlag;
 	bool prevEasyMouse = _vm->_easyMouse;
 	bool prevInvObjectsAnimated = _vm->_invObjectsAnimated;
 	bool prevTextWindowStill = _vm->_textWindowStill;
@@ -1073,15 +1147,15 @@ void OptionsDialog::show() {
 	StoryMode prevStoryMode = game._storyMode;
 
 	do {
-		_selectedLine = 0;
+		_selectedLine = -1;
 		GameDialog::show();
 
 		switch (_selectedLine) {
 		case 1:	// Music
-			warning("STUB: Music toggle");
+			_vm->_musicFlag = _vm->_soundFlag = !_vm->_musicFlag;
 			break;
 		case 2:	// Sound
-			warning("STUB: Sound toggle");
+			_vm->_musicFlag = _vm->_soundFlag = !_vm->_musicFlag;
 			break;
 		case 3:	// Interface
 			_vm->_easyMouse = !_vm->_easyMouse;
@@ -1110,24 +1184,22 @@ void OptionsDialog::show() {
 		// Reload menu
 		_lineIndex = -1;
 		clearLines();
+		_vm->_game->_screenObjects.clear();
+		_vm->_game->_scene._spriteSlots.reset();
 		setLines();
-		setClickableLines();
-	} while (_selectedLine <= 7);
-
-	switch (_selectedLine) {
-	case 8:	// Done
-		// New options will be applied
-		break;
-	case 9:	// Cancel
-		// Revert all options from the saved ones
+	} while (!_vm->shouldQuit() && _selectedLine != 0 && _selectedLine <= 7);
+
+	if (_selectedLine == 8) {
+		// OK button, save settings
+		_vm->saveOptions();
+	} else if (_selectedLine == 9) {
+		// Cancel button, revert all options from the saved ones
+		_vm->_musicFlag = _vm->_soundFlag = prevMusicFlag;
 		_vm->_easyMouse = prevEasyMouse;
 		_vm->_invObjectsAnimated = prevInvObjectsAnimated;
 		_vm->_textWindowStill = prevTextWindowStill;
 		_vm->_screenFade = prevScreenFade;
 		game._storyMode = prevStoryMode;
-		break;
-	default:
-		break;
 	}
 }
 
diff --git a/engines/mads/nebular/dialogs_nebular.h b/engines/mads/nebular/dialogs_nebular.h
index 5dbe4da6f0..4935ee4b8c 100644
--- a/engines/mads/nebular/dialogs_nebular.h
+++ b/engines/mads/nebular/dialogs_nebular.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -69,6 +69,7 @@ struct HOGANUS {
 class CopyProtectionDialog : public TextDialog {
 private:
 	HOGANUS _hogEntry;
+	Common::String _textInput;
 
 	/**
 	 * Get a random copy protection entry from the HOGANUS resource
@@ -84,6 +85,8 @@ public:
 	 * Show the dialog
 	 */
 	virtual void show();
+
+	bool isCorrectAnswer();
 };
 
 class PictureDialog : public TextDialog {
diff --git a/engines/mads/nebular/game_nebular.cpp b/engines/mads/nebular/game_nebular.cpp
index fd669bc5cf..8f40bc15c8 100644
--- a/engines/mads/nebular/game_nebular.cpp
+++ b/engines/mads/nebular/game_nebular.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -45,30 +45,90 @@ GameNebular::GameNebular(MADSEngine *vm)
 }
 
 ProtectionResult GameNebular::checkCopyProtection() {
-	/*
-	// DEBUG: Flag copy protection failure
-	_globals[kCopyProtectFailed] = -1;
+	//if (!ConfMan.getBool("copy_protection"))
+	//	return PROTECTION_SUCCEED;
 
-	if (!ConfMan.getBool("copy_protection"))
-	return true;
+	CopyProtectionDialog *dlg;
+	bool correctAnswer;
 
-	* DEBUG: Disabled for now
-	CopyProtectionDialog *dlg = new CopyProtectionDialog(_vm, false);
+	dlg = new CopyProtectionDialog(_vm, false);
 	dlg->show();
+	correctAnswer = dlg->isCorrectAnswer();
 	delete dlg;
-	*/
-	return PROTECTION_SUCCEED;
+
+	if (!correctAnswer && !_vm->shouldQuit()) {
+		dlg = new CopyProtectionDialog(_vm, true);
+		dlg->show();
+		correctAnswer = dlg->isCorrectAnswer();
+		delete dlg;
+	}
+
+	return correctAnswer ? PROTECTION_SUCCEED : PROTECTION_FAIL;
 }
 
 void GameNebular::startGame() {
-	/*
+	// First handle any ending credits from a just finished game session.
+	// Note that, with the exception of the decompression ending, which doesn't
+	// use animations, the remaining animations will automatically launch their
+	// own text view credits when the animation is completed
+	switch (_winStatus) {
+	case 1:
+		// No shields failure ending
+		AnimationView::execute(_vm, "rexend1");
+		break;
+	case 2:
+		// Shields, but no targetting failure ending
+		AnimationView::execute(_vm, "rexend2");
+		break;
+	case 3:
+		// Completed game successfully, so activate quotes item on the main menu
+		ConfMan.setBool("ShowQuotes", true);
+		ConfMan.flushToDisk();
+
+		AnimationView::execute(_vm, "rexend3");
+		break;
+	case 4:
+		// Decompression ending
+		TextView::execute(_vm, "ending4");
+		break;
+	}
+
+	do {
+		checkShowDialog();
+		_winStatus = 0;
+
+		_sectionNumber = 1;
+		initSection(_sectionNumber);
+		_vm->_events->setCursor(CURSOR_ARROW);
+		_statusFlag = true;
+
+		// Show the main menu
+		_vm->_dialogs->_pendingDialog = DIALOG_MAIN_MENU;
+		_vm->_dialogs->showDialog();
+	} while (!_vm->shouldQuit() && _vm->_dialogs->_pendingDialog != DIALOG_NONE);
+
+	if (_vm->shouldQuit())
+		return;
+
+	_priorSectionNumber = 0;
+	_priorSectionNumber = -1;
+	_scene._priorSceneId = 0;
+	_scene._currentSceneId = -1;
+	_scene._nextSceneId = 101;
+
+	initializeGlobals();
+
+	if (_loadGameSlot >= 0)
+		// User selected to resume a savegame
+		return;
+
 	// Check copy protection
 	ProtectionResult protectionResult = checkCopyProtection();
+
 	switch (protectionResult) {
 	case PROTECTION_FAIL:
 		// Copy protection failed
 		_scene._nextSceneId = 804;
-		initializeGlobals();
 		_globals[kCopyProtectFailed] = true;
 		return;
 	case PROTECTION_ESCAPE:
@@ -79,23 +139,6 @@ void GameNebular::startGame() {
 		// Copy protection check succeeded
 		break;
 	}
-	*/
-
-	initSection(_sectionNumber);
-	_statusFlag = true;
-
-	// Show the main menu
-	_vm->_dialogs->_pendingDialog = DIALOG_MAIN_MENU;
-	_vm->_dialogs->showDialog();
-	_vm->_dialogs->_pendingDialog = DIALOG_NONE;
-
-	_priorSectionNumber = 0;
-	_priorSectionNumber = -1;
-	_scene._priorSceneId = 0;
-	_scene._currentSceneId = -1;
-	_scene._nextSceneId = 101;
-
-	initializeGlobals();
 }
 
 void GameNebular::initializeGlobals() {
@@ -245,10 +288,12 @@ void GameNebular::initializeGlobals() {
 	// Final setup based on selected difficulty level
 	switch (_difficulty) {
 	case DIFFICULTY_HARD:
-		_objects.setRoom(OBJ_PLANT_STALK, NOWHERE);
-		_objects.setRoom(OBJ_PENLIGHT, NOWHERE);
+		_objects.setRoom(OBJ_BLOWGUN, NOWHERE);
+		_objects.setRoom(OBJ_NOTE, NOWHERE);
 
-		_globals[kLeavesStatus] = LEAVES_ON_TRAP;
+		_globals[kLeavesStatus] = LEAVES_ON_GROUND;
+		_globals[kDurafailRecharged] = 0;
+		_globals[kPenlightCellStatus] = FIRST_TIME_UNCHARGED_DURAFAIL;
 		break;
 
 	case DIFFICULTY_MEDIUM:
@@ -260,12 +305,10 @@ void GameNebular::initializeGlobals() {
 		break;
 
 	case DIFFICULTY_EASY:
-		_objects.setRoom(OBJ_BLOWGUN, NOWHERE);
-		_objects.setRoom(OBJ_NOTE, NOWHERE);
+		_objects.setRoom(OBJ_PLANT_STALK, NOWHERE);
+		_objects.setRoom(OBJ_PENLIGHT, NOWHERE);
 
-		_globals[kLeavesStatus] = LEAVES_ON_GROUND;
-		_globals[kPenlightCellStatus] = FIRST_TIME_UNCHARGED_DURAFAIL;
-		_globals[kDurafailRecharged] = 0;
+		_globals[kLeavesStatus] = LEAVES_ON_TRAP;
 		break;
 	}
 
@@ -310,32 +353,9 @@ void GameNebular::setSectionHandler() {
 }
 
 void GameNebular::checkShowDialog() {
-	// Handling to start endgame sequences if the win/lose type has been set
-	switch (_winStatus) {
-	case 1:
-		// No shields failure ending
-		AnimationView::execute(_vm, "rexend1");
-		break;
-	case 2:
-		// Shields, but no targetting failure ending
-		AnimationView::execute(_vm, "rexend2");
-		break;
-	case 3:
-		// Completed game successfully, so activate quotes item on the main menu
-		ConfMan.setBool("ShowQuotes", true);
-		ConfMan.flushToDisk();
-
-		AnimationView::execute(_vm, "rexend3");
-		break;
-	case 4:
-		// Decompression ending
-		TextView::execute(_vm, "ending4");
-		break;
-	}
-	_winStatus = 0;
-
 	// Loop for showing dialogs, if any need to be shown
-	if (_vm->_dialogs->_pendingDialog && _player._stepEnabled && !_globals[kCopyProtectFailed]) {
+	if (_vm->_dialogs->_pendingDialog && (_player._stepEnabled || _winStatus) 
+			&& !_globals[kCopyProtectFailed]) {
 		_player.releasePlayerSprites();
 
 		// Make a thumbnail in case it's needed for making a savegame
@@ -454,7 +474,7 @@ void GameNebular::doObjectAction() {
 		dialogs.show(464);
 	} else if (action.isAction(VERB_REFLECT)) {
 		dialogs.show(466);
-	} 	else if (action.isAction(VERB_GAZE_INTO, NOUN_REARVIEW_MIRROR)) {
+	} else if (action.isAction(VERB_GAZE_INTO, NOUN_REARVIEW_MIRROR)) {
 		dialogs.show(467);
 	} else if (action.isAction(VERB_EAT, NOUN_CHICKEN_BOMB)) {
 		dialogs.show(469);
@@ -810,7 +830,7 @@ void GameNebular::step() {
 		(_player._facing == _player._turnToFacing)) {
 		if (_scene._frameStartTime >= *((uint32 *)&_globals[kWalkerTiming])) {
 			if (!_player._stopWalkerIndex) {
-				int randomVal = _vm->getRandomNumber(29999);;
+				int randomVal = _vm->getRandomNumber(29999);
 				if (_globals[kSexOfRex] == REX_MALE) {
 					switch (_player._facing) {
 					case FACING_SOUTHWEST:
diff --git a/engines/mads/nebular/game_nebular.h b/engines/mads/nebular/game_nebular.h
index efa21a2e73..3cf7aefc18 100644
--- a/engines/mads/nebular/game_nebular.h
+++ b/engines/mads/nebular/game_nebular.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -131,6 +131,9 @@ public:
 	virtual void step();
 
 	virtual void synchronize(Common::Serializer &s, bool phase1);
+
+	virtual void setNaughtyMode(bool naughtyMode) { _storyMode = naughtyMode ? STORYMODE_NAUGHTY : STORYMODE_NICE; }
+	virtual bool getNaughtyMode() const { return _storyMode == STORYMODE_NAUGHTY; }
 };
 
 // Section handlers aren't needed in ScummVM implementation
diff --git a/engines/mads/nebular/globals_nebular.cpp b/engines/mads/nebular/globals_nebular.cpp
index 9f8b8a7888..c44506e546 100644
--- a/engines/mads/nebular/globals_nebular.cpp
+++ b/engines/mads/nebular/globals_nebular.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/nebular/globals_nebular.h b/engines/mads/nebular/globals_nebular.h
index bd1c6d84b0..7c7069892e 100644
--- a/engines/mads/nebular/globals_nebular.h
+++ b/engines/mads/nebular/globals_nebular.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -148,9 +148,9 @@ enum GlobalId {
 
 	/* Section #6 Variables */
 	kConvHermit1			= 130,
-	kconvHermit2			= 131,
+	kConvHermit2			= 131,
 	kHasTalkedToHermit		= 132,
-	kExecuted_1_11			= 133,
+	kHermitWantsBatteries	= 133,
 	kHandsetCellStatus		= 134,
 	kBeenInVideoStore		= 135,
 	kDurafailRecharged		= 136,
diff --git a/engines/mads/nebular/menu_nebular.cpp b/engines/mads/nebular/menu_nebular.cpp
index 28de4e5650..6fe17f3beb 100644
--- a/engines/mads/nebular/menu_nebular.cpp
+++ b/engines/mads/nebular/menu_nebular.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -86,7 +86,7 @@ void MainMenu::display() {
 			frame0->_offset.y - frame0->h);
 		screenObjects.add(
 			Common::Rect(pt.x, pt.y + DIALOG_TOP, pt.x + frame0->w,
-			pt.y + frame0->h + DIALOG_TOP), LAYER_GUI, CAT_COMMAND, i);
+			pt.y + frame0->h + DIALOG_TOP), SCREENMODE_VGA, CAT_COMMAND, i);
 	}
 
 	// Set the cursor for when it's shown
@@ -292,7 +292,7 @@ bool MainMenu::onEvent(Common::Event &event) {
 }
 
 int MainMenu::getHighlightedItem(const Common::Point &pt) {
-	return _vm->_game->_screenObjects.scan(pt, LAYER_GUI) - 1;
+	return _vm->_game->_screenObjects.scan(pt, SCREENMODE_VGA) - 1;
 }
 
 void MainMenu::unhighlightItem() {
diff --git a/engines/mads/nebular/menu_nebular.h b/engines/mads/nebular/menu_nebular.h
index 77b8b6fc6e..35af0bb34f 100644
--- a/engines/mads/nebular/menu_nebular.h
+++ b/engines/mads/nebular/menu_nebular.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/nebular/nebular_scenes.cpp b/engines/mads/nebular/nebular_scenes.cpp
index b5e2491624..eb6f7a5610 100644
--- a/engines/mads/nebular/nebular_scenes.cpp
+++ b/engines/mads/nebular/nebular_scenes.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -432,7 +432,7 @@ void SceneTeleporter::teleporterHandleKey() {
 	case 0: {
 		_game._player._stepEnabled = false;
 		Common::Point msgPos = teleporterComputeLocation();
-		_handSequenceId = _scene->_sequences.startReverseCycle(_handSpriteId, false, 4, 2, 0, 0);
+		_handSequenceId = _scene->_sequences.startPingPongCycle(_handSpriteId, false, 4, 2, 0, 0);
 		_scene->_sequences.setPosition(_handSequenceId, msgPos);
 		_scene->_sequences.setDepth(_handSequenceId, 2);
 		_scene->_sequences.addSubEntry(_handSequenceId, SEQUENCE_TRIGGER_LOOP, 0, 1);
@@ -451,7 +451,10 @@ void SceneTeleporter::teleporterHandleKey() {
 				_curCode *= 10;
 				_curCode += _buttonTyped;
 				_digitCount++;
-				_msgText = Common::String::format("%d", _curCode);
+
+				Common::String format = "%01d";
+				format.setChar('0' + _digitCount, 2);
+				_msgText = Common::String::format(format.c_str(), _curCode);
 				if (_digitCount < 4)
 					_msgText += "_";
 
@@ -535,7 +538,7 @@ void SceneTeleporter::teleporterEnter() {
 	_curMessageId        = -1;
 	_msgText = "_";
 
-	if (_scene->_priorSceneId == -2)
+	if (_scene->_priorSceneId == RETURNING_FROM_DIALOG)
 		_scene->_priorSceneId = _globals[kTeleporterDestination];
 
 	if (_scene->_priorSceneId < 101)
diff --git a/engines/mads/nebular/nebular_scenes.h b/engines/mads/nebular/nebular_scenes.h
index cf33b21aad..58a6d1c98f 100644
--- a/engines/mads/nebular/nebular_scenes.h
+++ b/engines/mads/nebular/nebular_scenes.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -106,6 +106,7 @@ enum Verb {
 	VERB_WALK_UP        = 0x227,
 	VERB_WALK_INTO      = 0x242,
 	VERB_EXIT           = 0x298,
+	VERB_WALK_BEHIND    = 0x2A2,
 	VERB_WALK_ONTO      = 0x2B5,
 	VERB_RETURN_TO      = 0x2D5,
 	VERB_CLIMB_INTO     = 0x2F7,
@@ -216,9 +217,9 @@ enum Noun {
 	NOUN_CLEARING_TO_EAST = 0x4B,
 	NOUN_CLEARING_TO_SOUTH = 0x4C,
 	NOUN_CLIFF_FACE = 0x4D,
-	NOUN_CLIMB_DOWN = 0x4E,
-	NOUN_CLIMB_THROUGH = 0x4F,
-	NOUN_CLIMB_UP = 0x50,
+	//NOUN_CLIMB_DOWN = 0x4E,
+	//NOUN_CLIMB_THROUGH = 0x4F,
+	//NOUN_CLIMB_UP = 0x50,
 	NOUN_CLOCK = 0x51,
 	NOUN_CLOSET = 0x52,
 	NOUN_CLOTHESLINE = 0x53,
@@ -397,7 +398,7 @@ enum Noun {
 	NOUN_PALM_TREE = 0x100,
 	NOUN_PASSAGE_WAY_TO_SOUTH = 0x101,
 	NOUN_PASSION_PUSS = 0x102,
-	NOUN_PEER_THROUGH = 0x103,
+	//NOUN_PEER_THROUGH = 0x103,
 	NOUN_PENCIL = 0x104,
 	NOUN_PENDULOUS_CRAG = 0x105,
 	NOUN_PENLIGHT = 0x106,
@@ -812,7 +813,7 @@ enum Noun {
 	NOUN_COUNTER = 0x29F,
 	NOUN_SENSOR = 0x2A0,
 	NOUN_SOFTWARE_INFORMATION = 0x2A1,
-	NOUN_WALK_BEHIND = 0x2A2,
+	//NOUN_WALK_BEHIND = 0x2A2,
 	NOUN_BARGAINS = 0x2A3,
 	NOUN_SCAN_LIGHT = 0x2A4,
 	NOUN_OLD_SOFTWARE_STAND = 0x2A5,
@@ -831,7 +832,7 @@ enum Noun {
 	//NOUN_GAWK_AT = 0x2B2,
 	NOUN_CORRIDOR_TO_SOUTH = 0x2B3,
 	NOUN_CORRIDOR_TO_NORTH = 0x2B4,
-	NOUN_WALK_ONTO = 0x2B5,
+	//NOUN_WALK_ONTO = 0x2B5,
 	NOUN_ROCK_WALL = 0x2B6,
 	NOUN_WOMAN = 0x2B7,
 	NOUN_WOMEN = 0x2B8,
@@ -897,7 +898,7 @@ enum Noun {
 	NOUN_YOUR_STUFF = 0x2F4,
 	NOUN_OTHER_STUFF = 0x2F5,
 	NOUN_LAMP = 0x2F6,
-	NOUN_CLIMB_INTO = 0x2F7,
+	//NOUN_CLIMB_INTO = 0x2F7,
 	NOUN_LIGHT_BULB = 0x2F8,
 	//NOUN_STEP_INTO = 0x2F9,
 	NOUN_ROOM = 0x2FA,
@@ -924,7 +925,6 @@ enum Noun {
 	NOUN_WHISKEY = 0x30F,
 	NOUN_ALCOHOL = 0x310,
 	NOUN_RIM = 0x311,
-	//NOUN_WALK_ALONG = 0x312,
 	NOUN_SUBMERGED_CITY = 0x313,
 	NOUN_GOVERNORS_HOUSE = 0x314,
 	NOUN_RIM_TOWARDS_EAST = 0x315,
@@ -1057,7 +1057,7 @@ enum Noun {
 	NOUN_PAD_TO_EAST = 0x394,
 	NOUN_PAD_TO_WEST = 0x395,
 	NOUN_TOWER = 0x396,
-	NOUN_LOOK_OUT = 0x397,
+	//NOUN_LOOK_OUT = 0x397,
 	NOUN_SERVICE_PANEL = 0x398,
 	NOUN_CRACK = 0x399,
 	NOUN_THROTTLE = 0x39A,
diff --git a/engines/mads/nebular/nebular_scenes1.cpp b/engines/mads/nebular/nebular_scenes1.cpp
index ab072c1d3c..0cb1b11ee9 100644
--- a/engines/mads/nebular/nebular_scenes1.cpp
+++ b/engines/mads/nebular/nebular_scenes1.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * 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.
@@ -84,7 +84,7 @@ void Scene1xx::setPlayerSpritesPrefix() {
 	} else if (_scene->_nextSceneId == 112)
 		_game._player._spritesPrefix = "";
 
-	if (oldName == _game._player._spritesPrefix)
+	if (oldName != _game._player._spritesPrefix)
 		_game._player._spritesChanged = true;
 
 	if (_scene->_nextSceneId == 105 || (_scene->_nextSceneId == 109 && _globals[kHoovicAlive])) {
@@ -134,7 +134,7 @@ void Scene101::sayDang() {
 	switch (_game._trigger) {
 	case 0:
 		_scene->_sequences.remove(_globals._sequenceIndexes[11]);
-		_globals._sequenceIndexes[11] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[11], false, 3, 6, 0, 0);
+		_globals._sequenceIndexes[11] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[11], false, 3, 6, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[11], 17, 21);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 72);
 		_vm->_sound->command(17);
@@ -188,13 +188,13 @@ void Scene101::enter() {
 	_scene->_hotspots.activate(NOUN_SHIELD_MODULATOR, false);
 	_panelOpened = false;
 
-	if (_scene->_priorSceneId != -1)
+	if (_scene->_priorSceneId != RETURNING_FROM_LOADING)
 		_globals[kNeedToStandUp] = false;
 
-	if (_scene->_priorSceneId != -2)
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(100, 152);
 
-	if ((_scene->_priorSceneId == 112) || ((_scene->_priorSceneId == -2) && _sittingFl )) {
+	if ((_scene->_priorSceneId == 112) || ((_scene->_priorSceneId == RETURNING_FROM_DIALOG) && _sittingFl )) {
 		_game._player._visible = false;
 		_sittingFl = true;
 		_game._player._playerPos = Common::Point(161, 123);
@@ -696,7 +696,7 @@ void Scene102::enter() {
 	_globals._spriteIndexes[11] = _scene->_sprites.addSprites("*RXMRC_8");
 	_globals._spriteIndexes[13] = _scene->_sprites.addSprites(formAnimName('x', 0));
 
-	_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 8, 0, 0, 0);
+	_globals._sequenceIndexes[1] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[1], false, 8, 0, 0, 0);
 	_globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 170, 0, 1, 6);
 	_globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 11, 0, 2, 3);
 	_globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 4, 0, 1, 0);
@@ -721,7 +721,7 @@ void Scene102::enter() {
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 70);
 	} else if (_scene->_priorSceneId == 103)
 		_game._player._playerPos = Common::Point(47, 152);
-	else if (_scene->_priorSceneId != -2) {
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._facing = FACING_NORTHWEST;
 		_game._player._playerPos = Common::Point(32, 129);
 	}
@@ -906,7 +906,7 @@ void Scene102::actions() {
 		_fridgeFirstOpenFl = false;
 		int quoteId = _vm->getRandomNumber(59, 63);
 		Common::String curQuote = _game.getQuote(quoteId);
-		int width = _vm->_font->getWidth(curQuote, -1);
+		int width = _scene->_kernelMessages._talkFont->getWidth(curQuote, -1);
 		_scene->_kernelMessages.reset();
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
 		_scene->_kernelMessages.add(Common::Point(210, 60), 0x1110, 0, 73, 120, curQuote);
@@ -1201,7 +1201,7 @@ void Scene102::actions() {
 	if (_action.isAction(VERB_TAKE, NOUN_BINOCULARS) && _game._objects.isInRoom(OBJ_BINOCULARS)) {
 		switch (_game._trigger) {
 		case 0:
-			_globals._sequenceIndexes[11] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[11], false, 3, 1, 0, 0);
+			_globals._sequenceIndexes[11] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[11], false, 3, 1, 0, 0);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[11]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
 			_game._player._visible = false;
@@ -1342,7 +1342,7 @@ void Scene103::enter() {
 		_scene->_hotspots.activate(362, false);
 	}
 
-	if (_scene->_priorSceneId != -2)
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(237, 74);
 
 	if (_scene->_priorSceneId == 102) {
@@ -1433,7 +1433,7 @@ void Scene103::actions() {
 		switch (_vm->_game->_trigger) {
 		case 0:
 			_scene->changeVariant(1);
-			_globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 3, 2);
+			_globals._sequenceIndexes[13] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[13], false, 3, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[13]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_SPRITE, 7, 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -1453,17 +1453,16 @@ void Scene103::actions() {
 			_scene->_hotspots.activate(371, false);
 			_vm->_game->_player._visible = true;
 			_vm->_game->_player._stepEnabled = true;
-			_vm->_dialogs->showItem(OBJ_REBREATHER, 805);
+			_vm->_dialogs->showItem(OBJ_TIMER_MODULE, 805);
 			break;
 
 		default:
 			break;
 		}
-	} else if (_action.isAction(VERB_TAKE, 289, 0) && _game._objects.isInRoom(OBJ_REBREATHER)) {
+	} else if (_action.isAction(VERB_TAKE, NOUN_REBREATHER, 0) && _game._objects.isInRoom(OBJ_REBREATHER)) {
 		switch (_vm->_game->_trigger) {
 		case 0:
-			_scene->changeVariant(1);
-			_globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 3, 2);
+			_globals._sequenceIndexes[12] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[12], false, 3, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[12]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_SPRITE, 6, 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -1621,10 +1620,11 @@ void Scene104::setup() {
 void Scene104::enter() {
 	_globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('h', -1));
 	_globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 14, 0, 0, 1);
+	_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 8);
 
 	if (_scene->_priorSceneId == 105)
 		_game._player._playerPos = Common::Point(302, 107);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(160, 134);
 
 	_loseFl = false;
@@ -1846,7 +1846,7 @@ void Scene105::enter() {
 
 	if (_scene->_priorSceneId == 104)
 		_game._player._playerPos = Common::Point(13, 97);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(116, 147);
 
 	_game.loadQuoteSet(0x4A, 0x4B, 0x4C, 0x35, 0x34, 0);
@@ -2009,7 +2009,7 @@ void Scene106::enter() {
 	}
 
 	_globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('G', -1));
-	_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 21, 0, 0, 0);
+	_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 21, 0, 0, 0);
 	_globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('I', -1));
 	_globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 0, 32, 47);
 
@@ -2020,7 +2020,7 @@ void Scene106::enter() {
 		_game._player._stepEnabled = false;
 		_game._player._facing = FACING_EAST;
 		_game._player._playerPos = Common::Point(106, 69);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		if (_scene->_priorSceneId == 107) {
 			_game._player._playerPos = Common::Point(319, 84);
 			_game._player._facing = _game._player._prepareWalkFacing = FACING_WEST;
@@ -2112,9 +2112,9 @@ void Scene106::step() {
 		}
 
 		if (msgId >= 0) {
-			int nextAbortVal = _game._trigger + 1;
+			int nextTrigger = _game._trigger + 1;
 			_scene->_kernelMessages.add(Common::Point(15, _positionY), 0x1110, 0, 0, 360, _game.getQuote(msgId));
-			_scene->_sequences.addTimer(150, nextAbortVal);
+			_scene->_sequences.addTimer(150, nextTrigger);
 			_positionY += 14;
 		}
 	}
@@ -2239,7 +2239,7 @@ void Scene107::enter() {
 		_game._player._playerPos = Common::Point(132, 47);
 	else if (_scene->_priorSceneId == 106)
 		_game._player._playerPos = Common::Point(20, 91);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(223, 151);
 
 	if (((_scene->_priorSceneId == 105) || (_scene->_priorSceneId == 106)) && (_vm->getRandomNumber(1, 3) == 1)) {
@@ -2351,7 +2351,7 @@ void Scene108::enter() {
 
 	if (_scene->_priorSceneId == 107)
 		_game._player._playerPos = Common::Point(138, 58);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(305, 98);
 
 	_game.loadQuoteSet(0x4A, 0x4B, 0x4C, 0x35, 0x34, 0);
@@ -2458,7 +2458,7 @@ void Scene109::enter() {
 	if (_scene->_priorSceneId == 110) {
 		_game._player._playerPos = Common::Point(248, 38);
 		_globals[kHoovicSated] = 2;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(20, 68);
 		_game._player._facing = FACING_EAST;
 	}
@@ -2502,7 +2502,7 @@ void Scene109::enter() {
 		_globals._spriteIndexes[10] = _scene->_sprites.addSprites(Resources::formatName(105, 'F', 1, EXT_SS, ""));
 		_globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('H', 1));
 
-		_globals._sequenceIndexes[10] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[10], true, 4, 0, 0, 0);
+		_globals._sequenceIndexes[10] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[10], true, 4, 0, 0, 0);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[10], 5);
 		_scene->_sequences.setPosition(_globals._sequenceIndexes[10], Common::Point(126, 39));
 		_scene->_sequences.setMotion(_globals._sequenceIndexes[10], 0, 200, 0);
@@ -2589,8 +2589,8 @@ void Scene109::preActions() {
 		_game._player._walkOffScreenSceneId = 108;
 
 	if ((_action.isAction(VERB_THROW) || _action.isAction(VERB_GIVE) || _action.isAction(VERB_PUT))
-	&& (_action.isObject(NOUN_SMALL_HOLE) || _action.isObject(NOUN_TUNNEL))
-	&& (_action.isObject(NOUN_DEAD_FISH) || _action.isObject(NOUN_STUFFED_FISH) || _action.isObject(NOUN_BURGER))) {
+			&& (_action.isTarget(NOUN_SMALL_HOLE) || _action.isTarget(NOUN_TUNNEL))
+			&& (_action.isObject(NOUN_DEAD_FISH) || _action.isObject(NOUN_STUFFED_FISH) || _action.isObject(NOUN_BURGER))) {
 		int idx = _game._objects.getIdFromDesc(_action._activeAction._objectNameId);
 		if ((idx >= 0) && _game._objects.isInInventory(idx)) {
 			_game._player._prepareWalkPos = Common::Point(106, 38);
@@ -2637,7 +2637,7 @@ void Scene109::actions() {
 							break;
 
 						case OBJ_BURGER:
-							_hoovicDifficultFl = (_game._difficulty == DIFFICULTY_EASY);
+							_hoovicDifficultFl = (_game._difficulty == DIFFICULTY_HARD);
 							_globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('H', (_hoovicDifficultFl ? 3 : 1)));
 							break;
 						}
@@ -2675,7 +2675,7 @@ void Scene109::actions() {
 
 					case 2:
 						if (_hoovicDifficultFl)
-							_globals._sequenceIndexes[8] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[8], false, 4, 2, 0, 0);
+							_globals._sequenceIndexes[8] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[8], false, 4, 2, 0, 0);
 						else
 							_globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 4, 1, 0, 0);
 
@@ -2864,7 +2864,7 @@ void Scene110::enter() {
 		_scene->_dynamicHotspots.setPosition(idx, Common::Point(-1, 0), FACING_NONE);
 		idx = _scene->_dynamicHotspots.add(91, 348, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0));
 		_scene->_dynamicHotspots.setPosition(idx, Common::Point(-1, 0), FACING_NONE);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(194, 23);
 		_game._player._facing = FACING_SOUTH;
 		_game._player._visible = false;
@@ -3007,7 +3007,7 @@ void Scene111::enter() {
 	_launched2Fl = false;
 	_stampedFl = false;
 
-	if ((_scene->_priorSceneId < 201) && (_scene->_priorSceneId != -2)) {
+	if ((_scene->_priorSceneId < 201) && (_scene->_priorSceneId != RETURNING_FROM_DIALOG)) {
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
 		_scene->loadAnimation(Resources::formatName(111, 'A', 0, EXT_AA, ""), 70);
@@ -3018,7 +3018,7 @@ void Scene111::enter() {
 		_launched2Fl = true;
 
 		_vm->_sound->command(36);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(300, 130);
 		_game._player._facing = FACING_WEST;
 	}
diff --git a/engines/mads/nebular/nebular_scenes1.h b/engines/mads/nebular/nebular_scenes1.h
index 1afa7fccc1..d8c9059846 100644
--- a/engines/mads/nebular/nebular_scenes1.h
+++ b/engines/mads/nebular/nebular_scenes1.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/nebular/nebular_scenes2.cpp b/engines/mads/nebular/nebular_scenes2.cpp
index 94e30aa4f2..1cbd6f56ef 100644
--- a/engines/mads/nebular/nebular_scenes2.cpp
+++ b/engines/mads/nebular/nebular_scenes2.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * 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.
@@ -152,7 +152,7 @@ void Scene201::enter() {
 	int idx = _scene->_dynamicHotspots.add(NOUN_BIRDS, 209, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0));
 	_scene->_dynamicHotspots.setPosition(idx, Common::Point(186, 81), FACING_NORTH);
 
-	if ((_scene->_priorSceneId == 202) || (_scene->_priorSceneId == -1)) {
+	if ((_scene->_priorSceneId == 202) || (_scene->_priorSceneId == RETURNING_FROM_LOADING)) {
 		_game._player._playerPos = Common::Point(165, 152);
 	} else {
 		_game._player._playerPos = Common::Point(223, 149);
@@ -165,16 +165,16 @@ void Scene201::enter() {
 		int sepChar = (_globals[kSexOfRex] == SEX_MALE) ? 't' : 'u';
 		// Guess values. What is the default value used by the compiler?
 		int suffixNum = -1;
-		int abortTimers = -1;
+		int endTrigger = -1;
 		switch(_globals[kTeleporterCommand]) {
 		case 1:
 			suffixNum = 3;
-			abortTimers = 76;
+			endTrigger = 76;
 			_globals[kTeleporterUnderstood] = true;
 			break;
 		case 2:
 			suffixNum = 1;
-			abortTimers = 77;
+			endTrigger = 77;
 			break;
 		case 3:
 			_game._player._visible = true;
@@ -183,12 +183,12 @@ void Scene201::enter() {
 			break;
 		case 4:
 			suffixNum = 2;
-			abortTimers = 78;
+			endTrigger = 78;
 			break;
 		}
 		_globals[kTeleporterCommand] = 0;
 		if (suffixNum >= 0)
-			_scene->loadAnimation(formAnimName(sepChar, suffixNum), abortTimers);
+			_scene->loadAnimation(formAnimName(sepChar, suffixNum), endTrigger);
 	}
 
 	if ((_scene->_priorSceneId == 202) && (_globals[kMeteorologistStatus] == METEOROLOGIST_PRESENT) && !_scene->_roomChanged) {
@@ -430,7 +430,7 @@ void Scene202::enter() {
 	if (_scene->_priorSceneId == 201) {
 		_game._player._playerPos = Common::Point(190, 91);
 		_game._player._facing = FACING_SOUTH;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(178, 152);
 		_game._player._facing = FACING_NORTH;
 	}
@@ -446,7 +446,7 @@ void Scene202::enter() {
 	_game.loadQuoteSet(0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x62, 0x63, 0x64, 0x65, 0x66, 0x61, 0);
 	_activeMsgFl = false;
 
-	if (_scene->_priorSceneId == -2) {
+	if (_scene->_priorSceneId == RETURNING_FROM_DIALOG) {
 		if (_waitingMeteoFl) {
 			_globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1);
 			_game._player._visible = false;
@@ -556,7 +556,7 @@ void Scene202::step() {
 	case 90:
 		_vm->_sound->command(41);
 		_scene->_sequences.remove(_globals._sequenceIndexes[10]);
-		_globals._sequenceIndexes[9] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[9], true, 6, 1, 0, 0);
+		_globals._sequenceIndexes[9] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[9], true, 6, 1, 0, 0);
 		_scene->_sequences.setPosition(_globals._sequenceIndexes[9], Common::Point(247, 82));
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[9], 1);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 91);
@@ -811,7 +811,7 @@ void Scene202::actions() {
 			} else {
 				_game._player._stepEnabled = false;
 				_game._player._visible = false;
-				_globals._sequenceIndexes[7] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[7], false, 3, 2, 0, 0);
+				_globals._sequenceIndexes[7] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[7], false, 3, 2, 0, 0);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[7]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_SPRITE, 6, 1);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -1044,7 +1044,7 @@ void Scene203::enter() {
 	} else if (_scene->_priorSceneId == 209) {
 		_game._player._playerPos = Common::Point(308, 117);
 		_game._player._facing = FACING_WEST;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(155, 152);
 		_game._player._facing = FACING_NORTH;
 	}
@@ -1152,8 +1152,9 @@ void Scene205::setup() {
 }
 
 Scene205::Scene205(MADSEngine *vm) : Scene2xx(vm) {
-	_lastFishTime = 0;
-	_chickenTime = 0;
+	_lastFishTime = _scene->_frameStartTime;
+	_chickenTime = _scene->_frameStartTime;
+
 	_beingKicked = false;
 	_kernelMessage = -1;
 }
@@ -1161,8 +1162,6 @@ Scene205::Scene205(MADSEngine *vm) : Scene2xx(vm) {
 void Scene205::synchronize(Common::Serializer &s) {
 	Scene2xx::synchronize(s);
 
-	s.syncAsUint32LE(_lastFishTime);
-	s.syncAsUint32LE(_chickenTime);
 	s.syncAsByte(_beingKicked);
 	s.syncAsSint16LE(_kernelMessage);
 }
@@ -1191,7 +1190,6 @@ void Scene205::enter() {
 	_scene->_sequences.setDepth(_globals._sequenceIndexes[5], 11);
 
 	if (!_game._visitedScenes._sceneRevisited) {
-		_lastFishTime = _scene->_frameStartTime;
 		_globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 7, 1, 0, 0);
 		idx = _scene->_dynamicHotspots.add(269, 13, _globals._sequenceIndexes[6], Common::Rect(0, 0, 0, 0));
 		_scene->_dynamicHotspots.setPosition(idx, Common::Point(49, 86), FACING_NORTH);
@@ -1224,7 +1222,7 @@ void Scene205::enter() {
 			Common::Rect(195, 99, 264, 134), 13, 2, 0xFDFC, 60,
 			108, 108, 109, 109, 110, 110, 111, 108, 0);
 
-	if (_scene->_priorSceneId != -2)
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(99, 152);
 
 	if (_globals[kSexOfRex] != SEX_MALE) {
@@ -1448,8 +1446,9 @@ Scene207::Scene207(MADSEngine *vm) : Scene2xx(vm) {
 	_eyeFl = false;
 	_spiderHotspotId = -1;
 	_vultureHotspotId = -1;
-	_spiderTime = 0;
-	_vultureTime = 0;
+
+	_spiderTime = _game._player._priorTimer;
+	_vultureTime = _game._player._priorTimer;
 }
 
 void Scene207::synchronize(Common::Serializer &s) {
@@ -1461,8 +1460,6 @@ void Scene207::synchronize(Common::Serializer &s) {
 
 	s.syncAsSint32LE(_spiderHotspotId);
 	s.syncAsSint32LE(_vultureHotspotId);
-	s.syncAsSint32LE(_spiderTime);
-	s.syncAsSint32LE(_vultureTime);
 }
 
 void Scene207::setup() {
@@ -1500,8 +1497,7 @@ void Scene207::enter() {
 	_spiderFl = (var2 & 1);
 
 	if (_vultureFl) {
-		_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 30, 0, 0, 400);
-		_vultureTime = _game._player._priorTimer;
+		_globals._sequenceIndexes[1] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[1], false, 30, 0, 0, 400);
 		_vultureHotspotId = _scene->_dynamicHotspots.add(389, 13, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0));
 		_scene->_dynamicHotspots.setPosition(_vultureHotspotId, Common::Point(254, 94), FACING_WEST);
 	}
@@ -1509,7 +1505,6 @@ void Scene207::enter() {
 	if (_spiderFl) {
 		_globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 7, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], -1, -1);
-		_spiderTime = _game._player._priorTimer;
 		_spiderHotspotId = _scene->_dynamicHotspots.add(333, 13, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0));
 		_scene->_dynamicHotspots.setPosition(_spiderHotspotId, Common::Point(59, 132), FACING_SOUTH);
 	}
@@ -1521,7 +1516,7 @@ void Scene207::enter() {
 	} else if (_scene->_priorSceneId == 214) {
 		_game._player._playerPos = Common::Point(164, 117);
 		_game._player._facing = FACING_SOUTH;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(305, 131);
 	}
 
@@ -1549,11 +1544,17 @@ void Scene207::moveSpider() {
 }
 
 void Scene207::step() {
-	if (!_vultureFl)
-		moveVulture();
+	Player &player = _game._player;
+
+	if (_vultureFl) {
+		if (((int32)player._priorTimer - _vultureTime) > 1700)
+			moveVulture();
+	}
 
-	if (_spiderFl)
-		moveSpider();
+	if (_spiderFl) {
+		if (((int32)player._priorTimer - _spiderTime) > 800)
+			moveSpider();
+	}
 
 	if (_game._trigger == 70) {
 		_globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 10, 0, 0, 0);
@@ -1685,18 +1686,18 @@ void Scene208::updateTrap() {
 	}
 
 	switch (_globals[kLeavesStatus]) {
-	case 0: {
+	case LEAVES_ON_GROUND: {
 		_globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 15);
 		int idx = _scene->_dynamicHotspots.add(NOUN_PILE_OF_LEAVES, VERB_WALKTO, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0));
 		_scene->_dynamicHotspots.setPosition(idx, Common::Point(60, 152), FACING_NORTH);
 		}
 		break;
-	case 2: {
+	case LEAVES_ON_TRAP: {
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 15);
 		_globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1);
 		_scene->_hotspots.activate(NOUN_DEEP_PIT, false);
-		int idx = _scene->_dynamicHotspots.add(NOUN_LEAF_COVERED_PIT, VERB_WALKTO, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0));
+		int idx = _scene->_dynamicHotspots.add(NOUN_LEAF_COVERED_PIT, VERB_WALKTO, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0));
 		_scene->_dynamicHotspots.setPosition(idx, Common::Point(100, 146), FACING_NORTH);
 		_scene->_dynamicHotspots[idx]._articleNumber = PREP_ON;
 		}
@@ -1727,7 +1728,7 @@ void Scene208::enter() {
 	} else if (_scene->_priorSceneId == 209) {
 		_game._player._playerPos = Common::Point(307, 123);
 		_game._player._facing = FACING_WEST;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(162, 149);
 		_game._player._facing = FACING_NORTH;
 	}
@@ -1745,7 +1746,8 @@ void Scene208::enter() {
 }
 
 void Scene208::step() {
-	if (_boundingFl && (_rhotundaTime <= _scene->_activeAnimation->getCurrentFrame())) {
+	if (_boundingFl && _scene->_activeAnimation &&
+			(_rhotundaTime <= _scene->_activeAnimation->getCurrentFrame())) {
 		_rhotundaTime = _scene->_activeAnimation->getCurrentFrame();
 
 		if (_rhotundaTime == 125)
@@ -1794,7 +1796,6 @@ void Scene208::preActions() {
 }
 
 void Scene208::subAction(int mode) {
-
 	switch (_game._trigger) {
 	case 0: {
 		_game._player._stepEnabled = false;
@@ -1802,21 +1803,21 @@ void Scene208::subAction(int mode) {
 		_globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 6, 1, 0, 0);
 		_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]);
 
-		int abortVal;
+		int endTrigger;
 		if ((mode == 1) || (mode == 2))
-			abortVal = 1;
+			endTrigger = 1;
 		else
-			abortVal = 2;
+			endTrigger = 2;
 
-		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, abortVal);
+		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, endTrigger);
 		}
 		break;
 	case 1: {
-		int oldVal = _globals._sequenceIndexes[5];
-		_globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 12, 3, 0, 0);
+		int oldSeq = _globals._sequenceIndexes[5];
+		_globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 12, 3, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 3, 4);
 		_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]);
-		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], oldVal);
+		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], oldSeq);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
 		_vm->_sound->command(20);
 		}
@@ -2157,7 +2158,7 @@ void Scene209::handleLookRight() {
 	switch (_game._trigger) {
 	case 151:
 		_scene->_sequences.remove(_globals._sequenceIndexes[3]);
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 8, 2, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 8, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 8, 14);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 152);
 		break;
@@ -2224,7 +2225,7 @@ void Scene209::handleGetBinoculars() {
 
 	case 162: {
 		int oldIdx = _globals._sequenceIndexes[3];
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 8, 6, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 8, 6, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 25);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 163);
@@ -2233,7 +2234,7 @@ void Scene209::handleGetBinoculars() {
 
 	case 163: {
 		int oldIdx = _globals._sequenceIndexes[3];
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 8, 0, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 8, 0, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 24);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx);
 		_scene->_sequences.addTimer(8, 164);
@@ -2257,7 +2258,7 @@ void Scene209::handleBinocularBlink() {
 	case 167: {
 		int oldIdx = _globals._sequenceIndexes[3];
 		_scene->_sequences.remove(_globals._sequenceIndexes[3]);
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 8, 2, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 8, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 25);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 168);
@@ -2266,7 +2267,7 @@ void Scene209::handleBinocularBlink() {
 
 	case 168: {
 		int oldIdx = _globals._sequenceIndexes[3];
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 8, 0, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 8, 0, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 24);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx);
 		_scene->_sequences.addTimer(30, 169);
@@ -2286,7 +2287,7 @@ void Scene209::handleBinocularScan() {
 	case 171: {
 		int oldIdx = _globals._sequenceIndexes[3];
 		_scene->_sequences.remove(_globals._sequenceIndexes[3]);
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 43, 45);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 172);
@@ -2298,10 +2299,10 @@ void Scene209::handleBinocularScan() {
 		int randAction = _vm->getRandomNumber(1,2);
 		switch (randAction) {
 		case 1:
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0);
 			break;
 		case 2:
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 4, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 12, 4, 0, 0);
 			break;
 		}
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 25);
@@ -2312,7 +2313,7 @@ void Scene209::handleBinocularScan() {
 
 	case 173: {
 		int oldIdx = _globals._sequenceIndexes[3];
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 26, 30);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 174);
@@ -2321,7 +2322,7 @@ void Scene209::handleBinocularScan() {
 
 	case 174: {
 		int oldIdx = _globals._sequenceIndexes[3];
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 0, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 12, 0, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 24);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx);
 		_scene->_sequences.addTimer(60, 175);
@@ -2407,7 +2408,7 @@ void Scene209::handleTongue() {
 	case 185: {
 		_vm->_sound->command(18);
 		int oldIdx = _globals._sequenceIndexes[3];
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 6, 20, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 6, 20, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 38, 39);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 186);
@@ -2527,7 +2528,7 @@ void Scene209::handleMonkeyEating() {
 
 	case 200: {
 		int oldIdx = _globals._sequenceIndexes[4];
-		_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 10, 10, 0, 0);
+		_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 10, 10, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 15, 16);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 201);
@@ -2556,14 +2557,14 @@ void Scene209::handleMonkeyEating() {
 
 	case 204:
 		_scene->_sequences.remove(_globals._sequenceIndexes[4]);
-		_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 10, 8, 0, 0);
+		_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 10, 8, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 18, 19);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 205);
 		break;
 
 	case 205: {
 		int oldIdx = _globals._sequenceIndexes[4];
-		_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 10, 8, 0, 0);
+		_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 10, 8, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 20, 21);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 206);
@@ -2588,7 +2589,7 @@ void Scene209::handleMonkeyEating() {
 		 _scene->_kernelMessages.setQuoted(msgIndex, 4, true);
 
 		 int oldIdx = _globals._sequenceIndexes[4];
-		_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 15, 4, 0, 0);
+		_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 15, 4, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 26, 27);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 208);
@@ -2598,7 +2599,7 @@ void Scene209::handleMonkeyEating() {
 	case 208: {
 		_scene->_kernelMessages.add(Common::Point(180, 39), 0xFDFC, 0, 0, 90, _game.getQuote(131));
 		int oldIdx = _globals._sequenceIndexes[4];
-		_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 10, 4, 0, 0);
+		_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 10, 4, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 28, 29);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 209);
@@ -2837,6 +2838,7 @@ void Scene209::enter() {
 	_globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('m', 3));
 	_globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('m', 6));
 	_globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('m', 8));
+	_globals._spriteIndexes[11] = _scene->_sprites.addSprites("*RXMBD_2");
 
 	_game.loadQuoteSet(0x82, 0x83, 0x84, 0x9C, 0x97, 0x95, 0x99, 0x9E, 0x98, 0x9B, 0xA0, 0x96, 0x9F,
 		0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x91, 0x92, 0x93, 0x94, 0x89, 0x85, 0x8A, 0x86, 0x87, 0x88, 0);
@@ -2854,7 +2856,7 @@ void Scene209::enter() {
 	if (_scene->_priorSceneId == 208) {
 		_game._player._playerPos = Common::Point(11, 121);
 		_game._player._facing = FACING_EAST;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(28, 121);
 		_game._player._facing = FACING_SOUTH;
 	}
@@ -3438,10 +3440,9 @@ void Scene209::actions() {
 	if (_action.isAction(VERB_TAKE, NOUN_PLANT_STALK) && (_game._trigger || _game._objects.isInRoom(OBJ_PLANT_STALK))) {
 		switch (_game._trigger) {
 		case 0:
-			_globals._spriteIndexes[11] = _scene->_sprites.addSprites("*RXMBD_2");
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[11] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[11], false, 3, 2, 0, 0);
+			_globals._sequenceIndexes[11] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[11], false, 3, 2, 0, 0);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[11]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_SPRITE, 4, 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -3460,7 +3461,6 @@ void Scene209::actions() {
 			break;
 
 		case 3:
-			_scene->_sprites.remove(_globals._spriteIndexes[11]);
 			break;
 		}
 		_action._inProgress = false;
@@ -3473,7 +3473,7 @@ void Scene209::actions() {
 			_globals._spriteIndexes[10] = _scene->_sprites.addSprites("*RXMBD_8");
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[10] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[10], false, 3, 2, 0, 0);
+			_globals._sequenceIndexes[10] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[10], false, 3, 2, 0, 0);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[10]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[10], SEQUENCE_TRIGGER_SPRITE, 4, 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[10], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -4173,7 +4173,7 @@ void Scene210::enter() {
 		_game._player._playerPos = Common::Point(168, 128);
 		_game._player._facing = FACING_SOUTH;
 		_globals[kCurtainOpen] = true;
-	} else if (_scene->_priorSceneId != -2)
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(308, 132);
 
 	if (!_globals[kCurtainOpen]) {
@@ -4210,7 +4210,7 @@ void Scene210::enter() {
 	_twinkleAnimationType = 0;
 	_twinklesCurrentFrame = 0;
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_shouldMoveHead = false;
 		_shouldFaceRex = false;
 		_shouldTalk = false;
@@ -4647,7 +4647,7 @@ void Scene211::enter() {
 		_game._player._visible = false;
 		_scene->loadAnimation(formAnimName('A', -1), 100);
 		_scene->_activeAnimation->setCurrentFrame(169);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(310, 31);
 		_game._player._facing = FACING_SOUTHWEST;
 	}
@@ -4905,7 +4905,7 @@ void Scene212::enter() {
 	if (_scene->_priorSceneId == 208) {
 		_game._player._playerPos = Common::Point(195, 85);
 		_game._player._facing = FACING_SOUTH;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(67, 117);
 		_game._player._facing = FACING_NORTHEAST;
 	}
@@ -5061,7 +5061,7 @@ void Scene214::enter() {
 		_scene->_hotspots.activate(NOUN_BLOWGUN, false);
 	}
 
-	if (_scene->_priorSceneId != -2)
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(191, 152);
 
 	sceneEntrySound();
@@ -5257,7 +5257,7 @@ void Scene215::enter() {
 		_game._player._stepEnabled = false;
 		_globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1);
 		_scene->_sequences.addTimer(120, 70);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(204, 152);
 		_game._player._facing = FACING_NORTH;
 	}
@@ -5290,7 +5290,7 @@ void Scene215::actions() {
 				if (_globals[kSexOfRex] == REX_MALE) {
 					_game._player._visible = false;
 					_game._player._stepEnabled = false;
-					_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 2, 0, 0);
+					_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 6, 2, 0, 0);
 					_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 4);
 					_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_LOOP, 0, 1);
diff --git a/engines/mads/nebular/nebular_scenes2.h b/engines/mads/nebular/nebular_scenes2.h
index c860db9470..0ea4702eea 100644
--- a/engines/mads/nebular/nebular_scenes2.h
+++ b/engines/mads/nebular/nebular_scenes2.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/nebular/nebular_scenes3.cpp b/engines/mads/nebular/nebular_scenes3.cpp
index bcedf95a27..5a6edbf995 100644
--- a/engines/mads/nebular/nebular_scenes3.cpp
+++ b/engines/mads/nebular/nebular_scenes3.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * 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.
@@ -370,7 +370,7 @@ void Scene304::enter() {
 		_globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('a', 1));
 		_globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('b', 0));
 
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 150, 0, 3, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 150, 0, 3, 0);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 2);
 		_vm->_palette->setEntry(252, 45, 63, 45);
 		_vm->_palette->setEntry(253, 20, 45, 20);
@@ -521,11 +521,11 @@ void Scene307::setup() {
 	setPlayerSpritesPrefix();
 	setAAName();
 	_scene->addActiveVocab(NOUN_AIR_VENT);
-	_scene->addActiveVocab(NOUN_CLIMB_INTO);
+	_scene->addActiveVocab(VERB_CLIMB_INTO);
 }
 
 void Scene307::handleRexDialog(int quote) {
-	Common::String curQuote = _game.getQuote(_action._activeAction._verbId);
+	Common::String curQuote = _game.getQuote(quote);
 	if (_vm->_font->getWidth(curQuote, _scene->_textSpacing) > 200) {
 		Common::String subQuote1;
 		_game.splitQuote(curQuote, subQuote1, _subQuote2);
@@ -769,7 +769,7 @@ void Scene307::enter() {
 		_dialog2.write(0x11E, true);
 
 
-	if (_scene->_priorSceneId == -2) {
+	if (_scene->_priorSceneId == RETURNING_FROM_DIALOG) {
 		if (_grateOpenedFl)
 			_vm->_sound->command(10);
 		else
@@ -953,7 +953,7 @@ void Scene307::actions() {
 
 		case 2: {
 			int oldIdx = _globals._sequenceIndexes[5];
-			_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 12, 6, 0, 0);
+			_globals._sequenceIndexes[5] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[5], false, 12, 6, 0, 0);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 2, 3);
 			_scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], oldIdx);
@@ -992,7 +992,7 @@ void Scene307::actions() {
 			_scene->_sequences.remove(_globals._sequenceIndexes[5]);
 			_grateOpenedFl = true;
 			_scene->_hotspots.activate(17, false);
-			int idx = _scene->_dynamicHotspots.add(17, NOUN_CLIMB_INTO, -1, Common::Rect(117, 67, 117 + 19, 67 + 13));
+			int idx = _scene->_dynamicHotspots.add(17, VERB_CLIMB_INTO, -1, Common::Rect(117, 67, 117 + 19, 67 + 13));
 			int hotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(129, 104), FACING_NORTH);
 			_scene->_dynamicHotspots.setCursor(hotspotId, CURSOR_GO_UP);
 			_game._objects.removeFromInventory(OBJ_SCALPEL, NOWHERE);
@@ -1245,7 +1245,7 @@ void Scene308::step() {
 	switch (_game._trigger) {
 	case 70: {
 		_scene->_sequences.remove(_globals._sequenceIndexes[3]);
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 18, 9, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 18, 9, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, 3);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9);
 		_scene->_kernelMessages.reset();
@@ -1266,7 +1266,7 @@ void Scene308::step() {
 
 	case 72:
 		_scene->_sequences.remove(_globals._sequenceIndexes[3]);
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 20, 5, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 20, 5, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 3, 4);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9);
 		_scene->_kernelMessages.reset();
@@ -1284,7 +1284,7 @@ void Scene308::step() {
 
 	case 74: {
 		_scene->_sequences.remove(_globals._sequenceIndexes[3]);
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 20, 8, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 20, 8, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 6, 7);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9);
 		_scene->_kernelMessages.reset();
@@ -1306,7 +1306,7 @@ void Scene308::step() {
 
 	case 76: {
 		int seqIdx = _globals._sequenceIndexes[3];
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 26, 0, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 26, 0, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, 3);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9);
 		_scene->_kernelMessages.reset();
@@ -1441,7 +1441,7 @@ void Scene309::step() {
 		case 70: {
 			int idx = _scene->_dynamicHotspots.add(689, 690, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0));
 			_scene->_dynamicHotspots.setPosition(idx, Common::Point(142, 146), FACING_NORTHEAST);
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 4, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 7, 4, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, 3);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71);
@@ -1462,7 +1462,7 @@ void Scene309::step() {
 
 		case 72: {
 			int _oldIdx = _globals._sequenceIndexes[3];
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 8, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 7, 8, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 8, 11);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11);
 			_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], _oldIdx);
@@ -1484,7 +1484,7 @@ void Scene309::step() {
 
 		case 74: {
 			int _oldIdx = _globals._sequenceIndexes[3];
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 6, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 7, 6, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 21, 23);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11);
 			_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], _oldIdx);
@@ -1494,7 +1494,7 @@ void Scene309::step() {
 
 		case 75: {
 			int _oldIdx = _globals._sequenceIndexes[3];
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 6, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 12, 6, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 24, 25);
 			_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], _oldIdx);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11);
@@ -1513,7 +1513,7 @@ void Scene309::step() {
 			break;
 
 		case 77: {
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 90, 0, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 90, 0, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 29, 30);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11);
 			int idx = _scene->_kernelMessages.add(Common::Point(15, 46), 0xFDFC, 0, 0, 120, _game.getQuote(247));
@@ -1618,7 +1618,7 @@ void Scene311::enter() {
 	else if (_scene->_priorSceneId == 320) {
 		_game._player._playerPos = Common::Point(129, 113);
 		_game._player._facing = FACING_SOUTH;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._visible = false;
 		_game._player._stepEnabled = false;
 		_scene->loadAnimation(formAnimName('a', -1), 70);
@@ -1749,7 +1749,7 @@ void Scene311::actions() {
 	else if (_checkGuardFl) {
 		_checkGuardFl = false;
 		_scene->_kernelMessages.reset();
-		_scene->_kernelMessages.addQuote(0xFA, 120, 0);
+		_scene->_kernelMessages.addQuote(250, 0, 240);
 	} else if (_action.isAction(VERB_SIT_AT, NOUN_DESK))
 		_scene->_nextSceneId = 320;
 	else if (_action.isAction(VERB_CLIMB_INTO, NOUN_AIR_VENT)) {
@@ -1896,7 +1896,7 @@ void Scene313::enter() {
 	} else if (_scene->_priorSceneId == 388) {
 		_game._player._playerPos = Common::Point(199, 70);
 		_game._player._facing = FACING_WEST;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(234, 70);
 		_game._player._facing = FACING_WEST;
 	}
@@ -1965,7 +1965,7 @@ void Scene316::handleRexInGrate() {
 
 	case 1:
 		_scene->_sequences.setDone(_globals._sequenceIndexes[4]);
-		_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 12, 3, 0, 0);
+		_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 12, 3, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 2, 3);
 		_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -2085,7 +2085,7 @@ void Scene316::handleRoxInGrate() {
 
 	case 1:
 		_scene->_sequences.setDone(_globals._sequenceIndexes[5]);
-		_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 17, 3, 0, 0);
+		_globals._sequenceIndexes[5] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[5], false, 17, 3, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 2, 3);
 		_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -2215,7 +2215,7 @@ void Scene316::enter() {
 		_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[spriteIdx], false, 6, 1, 0, 0);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 60);
-	} else if (_scene->_priorSceneId != -2)
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(291, 126);
 
 	sceneEntrySound();
@@ -2523,7 +2523,7 @@ void Scene318::handleDialog() {
 		case 0x19C:
 		case 0x19D:
 			_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(142, 121));
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 6, 8);
@@ -2581,6 +2581,12 @@ void Scene318::handleInternDialog(int quoteId, int quoteNum, uint32 timeout) {
 	_scene->_kernelMessages.reset();
 	_internTalkingFl = true;
 
+	// WORKAROUND: In case the player launches multiple talk selections with the
+	// intern before previous ones have finished, take care of removing any
+	int seqIndex;
+	while ((seqIndex = _scene->_sequences.findByTrigger(63)) != -1)
+		_scene->_sequences.remove(seqIndex);
+
 	for (int i = 0; i < quoteNum; i++) {
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
 		_scene->_sequences.addTimer(180, 63);
@@ -2611,7 +2617,7 @@ void Scene318::enter() {
 
 	if (_scene->_priorSceneId == 357)
 		_game._player._playerPos = Common::Point(15, 110);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(214, 152);
 
 	_dialog1.setup(0x47, 0x191, 0x192, 0x193, 0x194, 0x195, 0x196, 0x197, 0x198, 0x199, 0x19A, 0x19B, 0x19C, 0x19D, 0);
@@ -2632,7 +2638,7 @@ void Scene318::enter() {
 	_lastFrame = 0;
 	_scene->_hotspots.activate(NOUN_INTERN, false);
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_dialogFl = false;
 		_internWalkingFl = false;
 		_counter= 0;
@@ -2649,7 +2655,8 @@ void Scene318::enter() {
 		0x1C8, 0x1C9, 0x1CA, 0x1CB, 0x1CC, 0x1CD, 0x1CE, 0x1CF, 0x1D0, 0x1D1, 0x1D2, 0x1D3,
 		0x190, 0x19D, 0);
 
-	if ((_scene->_priorSceneId== -2) || (((_scene->_priorSceneId == 318) || (_scene->_priorSceneId == -1)) && (!_globals[kAfterHavoc]))) {
+	if ((_scene->_priorSceneId == RETURNING_FROM_DIALOG) || (((_scene->_priorSceneId == 318) || 
+			(_scene->_priorSceneId == RETURNING_FROM_LOADING)) && (!_globals[kAfterHavoc]))) {
 		if (!_globals[kAfterHavoc]) {
 			_game._player._visible = false;
 			_globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('g', -1));
@@ -2883,7 +2890,7 @@ void Scene318::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 8, 2, 0, 80);
+			_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 8, 2, 0, 80);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(142, 121));
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 2, 5);
@@ -3113,7 +3120,7 @@ void Scene319::enter() {
 	_dialog2.setup(0x44, 0x171, 0x172, 0x173, 0x174, 0x175, 0x176, 0);
 	_dialog3.setup(0x45, 0x17D, 0x17E, 0x17F, 0x180, 0x181, 0x182, 0x183, 0);
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_dialog1.set(0x165, 0x166, 0x167, 0x168, 0);
 		_dialog2.set(0x171, 0x172, 0x173, 0x174, 0);
 		_dialog3.set(0x17D, 0x17E, 0x17F, 0x180, 0);
@@ -3136,7 +3143,7 @@ void Scene319::enter() {
 
 	_scene->loadAnimation(formAnimName('b', 0));
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_animMode = 1;
 		_nextAction1 = 2;
 		_nextAction2 = 2;
@@ -3306,7 +3313,7 @@ void Scene319::step() {
 
 	switch (_game._trigger) {
 	case 70:
-	case 71:
+	case 71: {
 		_animMode = 1;
 		_nextAction1 = _nextAction2;
 		_animFrame = 0;
@@ -3329,7 +3336,14 @@ void Scene319::step() {
 			_scene->_sequences.updateTimeout(_globals._sequenceIndexes[i], oldIdx);
 		}
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[0], SEQUENCE_TRIGGER_EXPIRE, 0, 74);
+
+		// WORKAROUND: This fixes the game sometimes going into an endless waiting
+		// loop even after the doctor has finished hitting Rex. Note sure if it's due
+		// to a bug in room script or in the engine, but this at least fixes it
+		int seqIndex = _scene->_sequences.findByTrigger(2);
+		_scene->_sequences[seqIndex]._doneFlag = false;
 		break;
+	}
 
 	case 72:
 		_vm->_palette->setColorFlags(0xFF, 0, 0);
@@ -3588,7 +3602,7 @@ void Scene320::setLeftView(int view) {
 		_scene->_sequences.remove(_globals._sequenceIndexes[0]);
 
 	if (view != 10) {
-		_globals._sequenceIndexes[0] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[view], false, 6, 0, 0, 18);
+		_globals._sequenceIndexes[0] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[view], false, 6, 0, 0, 18);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[0], 0);
 		if (!_blinkFl)
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[0], 2, 2);
@@ -3752,7 +3766,7 @@ void Scene320::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			handleButtons();
-			_globals._sequenceIndexes[18] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[18], _flippedFl, 4, 2, 0, 0);
+			_globals._sequenceIndexes[18] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[18], _flippedFl, 4, 2, 0, 0);
 			_scene->_sequences.setScale(_globals._sequenceIndexes[18], 60);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[18], Common::Point(_posX, 170));
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[18], 0);
@@ -3825,7 +3839,7 @@ void Scene320::actions() {
 	else if (_action.isAction(VERB_LOOK, NOUN_DOUGHNUT))
 		_vm->_dialogs->show(32006);
 	else if (_action.isAction(VERB_LOOK, NOUN_MAGAZINE))
-		_vm->_dialogs->show(32006);
+		_vm->_dialogs->show(32007);
 	else if (_action.isAction(VERB_LOOK, NOUN_PAPER_FOOTBALL))
 		_vm->_dialogs->show(32008);
 	else if (_action.isAction(VERB_LOOK, NOUN_NEWSPAPER))
@@ -3975,7 +3989,7 @@ void Scene351::enter() {
 
 	if (_scene->_priorSceneId == 352)
 		_game._player._playerPos = Common::Point(148, 152);
-	else if (_scene->_priorSceneId != -2) {
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(207, 81);
 		_game._player._facing = FACING_NORTH;
 	}
@@ -4053,12 +4067,12 @@ void Scene351::actions() {
 				_game._player._stepEnabled = false;
 				_game._player._visible = false;
 				if (_globals[kSexOfRex] == REX_FEMALE) {
-					_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 5, 2, 0, 0);
+					_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 5, 2, 0, 0);
 					_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 5, 1);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
 				} else {
-					_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 5, 2, 0, 0);
+					_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 5, 2, 0, 0);
 					_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 6, 1);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -4152,7 +4166,7 @@ void Scene352::setup() {
 void Scene352::putArmDown(bool corridorExit, bool doorwayExit) {
 	switch (_game._trigger) {
 	case 0:
-		_scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 60, _game.getQuote(0xFF));
+		_scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0xFF));
 		_scene->_sequences.addTimer(48, 1);
 		break;
 
@@ -4160,12 +4174,12 @@ void Scene352::putArmDown(bool corridorExit, bool doorwayExit) {
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
 		if (_globals[kSexOfRex] == REX_FEMALE) {
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 5, 2, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 5, 2, 0, 0);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 5, 2);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 3);
 		} else {
-			_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 5, 2, 0, 0);
+			_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 5, 2, 0, 0);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 6, 2);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 3);
@@ -4197,7 +4211,6 @@ void Scene352::putArmDown(bool corridorExit, bool doorwayExit) {
 
 	case 4:
 		_game._player.walk(Common::Point(116, 107), FACING_NORTH);
-		_game._player._stepEnabled = true;
 		_mustPutArmDownFl = false;
 		_scene->_sequences.addTimer(180, 5);
 		_leaveRoomFl = true;
@@ -4261,7 +4274,7 @@ void Scene352::enter() {
 
 	_vaultOpenFl = false;
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_mustPutArmDownFl = false;
 		if (!_game._visitedScenes._sceneRevisited)
 			_globals[kHaveYourStuff] = false;
@@ -4276,7 +4289,7 @@ void Scene352::enter() {
 
 	if (_scene->_priorSceneId == 353)
 		_game._player._playerPos = Common::Point(171, 155);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(116, 107);
 
 	sceneEntrySound();
@@ -4305,7 +4318,7 @@ void Scene352::preActions() {
 				_game._player._stepEnabled = false;
 				_scene->_sequences.remove(_commonSequenceIdx);
 				_vm->_sound->command(20);
-				_commonSequenceIdx = _scene->_sequences.startReverseCycle(_commonSpriteIndex, false, 6, 1, 0, 0);
+				_commonSequenceIdx = _scene->_sequences.addReverseSpriteCycle(_commonSpriteIndex, false, 6, 1, 0, 0);
 				_scene->_sequences.addSubEntry(_commonSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 1);
 				_scene->_sequences.setDepth(_commonSequenceIdx, 15);
 			}
@@ -4364,7 +4377,7 @@ void Scene352::actions() {
 
 			case 1: {
 				_vm->_sound->command(21);
-				_globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 7, 2, 20, 0);
+				_globals._sequenceIndexes[12] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[12], false, 7, 2, 20, 0);
 				_scene->_sequences.setDepth(_globals._sequenceIndexes[12], FACING_NORTH);
 				int oldIdx = _commonSequenceIdx;
 				_commonSequenceIdx = _scene->_sequences.startCycle(_commonSpriteIndex, false, -2);
@@ -4376,7 +4389,7 @@ void Scene352::actions() {
 			case 2:
 				_vm->_sound->command(22);
 				_scene->_sequences.remove(_commonSequenceIdx);
-				_commonSequenceIdx = _scene->_sequences.startReverseCycle(_commonSpriteIndex, false, 8, 1, 0, 0);
+				_commonSequenceIdx = _scene->_sequences.startPingPongCycle(_commonSpriteIndex, false, 8, 1, 0, 0);
 				_scene->_sequences.setAnimRange(_commonSequenceIdx, 1, 3);
 				_scene->_sequences.addSubEntry(_commonSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 3);
 				break;
@@ -4431,12 +4444,12 @@ void Scene352::actions() {
 				_game._player._stepEnabled = false;
 				_game._player._visible = false;
 				if (_globals[kSexOfRex] == REX_FEMALE) {
-					_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 5, 2, 0, 0);
+					_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 5, 2, 0, 0);
 					_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 5, 1);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
 				} else {
-					_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 5, 2, 0, 0);
+					_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 5, 2, 0, 0);
 					_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 6, 1);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -4478,7 +4491,7 @@ void Scene352::actions() {
 
 			case 1: {
 				_vm->_sound->command(21);
-				_globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 7, 2, 20, 0);
+				_globals._sequenceIndexes[12] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[12], false, 7, 2, 20, 0);
 				_scene->_sequences.setDepth(_globals._sequenceIndexes[12], 8);
 				int oldIdx = _commonSequenceIdx;
 				_commonSequenceIdx = _scene->_sequences.startCycle(_commonSpriteIndex, false, -2);
@@ -4490,7 +4503,7 @@ void Scene352::actions() {
 			case 2:
 				_vm->_sound->command(23);
 				_scene->_sequences.remove(_commonSequenceIdx);
-				_commonSequenceIdx = _scene->_sequences.startReverseCycle(_commonSpriteIndex, false, 8, 1, 0, 0);
+				_commonSequenceIdx = _scene->_sequences.addReverseSpriteCycle(_commonSpriteIndex, false, 8, 1, 0, 0);
 				_scene->_sequences.setAnimRange(_commonSequenceIdx, 1, 4);
 				_scene->_sequences.addSubEntry(_commonSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 3);
 				break;
@@ -4545,13 +4558,13 @@ void Scene352::actions() {
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
 			if (_globals[kSexOfRex] == REX_MALE) {
-				_globals._sequenceIndexes[14] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[14], false, 8, 1, 0, 0);
+				_globals._sequenceIndexes[14] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[14], false, 8, 1, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[14], 1, 2);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[14]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[14], SEQUENCE_TRIGGER_SPRITE, 2, 1);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[14], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
 			} else {
-				_globals._sequenceIndexes[15] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[15], false, 8, 1, 0, 0);
+				_globals._sequenceIndexes[15] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[15], false, 8, 1, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[15], 1, 2);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[15]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[15], SEQUENCE_TRIGGER_SPRITE, 2, 1);
@@ -4592,12 +4605,12 @@ void Scene352::actions() {
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
 			if (_globals[kSexOfRex] == REX_MALE) {
-				_globals._sequenceIndexes[6] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[6], true, 6, 2, 0, 0);
+				_globals._sequenceIndexes[6] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[6], true, 6, 2, 0, 0);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[6]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_SPRITE, 6, 1);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
 			} else {
-				_globals._sequenceIndexes[7] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[7], true, 6, 2, 0, 0);
+				_globals._sequenceIndexes[7] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[7], true, 6, 2, 0, 0);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[7]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_SPRITE, 6, 1);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -4745,7 +4758,7 @@ void Scene354::enter() {
 		_game._player._facing = FACING_NORTH;
 	} else if (_scene->_priorSceneId == 316)
 		_game._player._playerPos = Common::Point(71, 107);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(167, 57);
 
 	sceneEntrySound();
@@ -4812,7 +4825,7 @@ void Scene357::enter() {
 		_game._player._playerPos = Common::Point(298, 142);
 	else if (_scene->_priorSceneId == 313)
 		_game._player._playerPos = Common::Point(127, 101);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(15, 148);
 
 	sceneEntrySound();
@@ -4876,7 +4889,7 @@ void Scene358::enter() {
 
 	if (_scene->_priorSceneId == 357)
 		_game._player._playerPos = Common::Point(305, 142);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(12, 141);
 
 	sceneEntrySound();
@@ -4952,7 +4965,7 @@ void Scene359::enter() {
 
 	if (_scene->_priorSceneId == 358)
 		_game._player._playerPos = Common::Point(301, 141);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(15, 148);
 
 	sceneEntrySound();
@@ -4980,12 +4993,12 @@ void Scene359::actions() {
 				_game._player._visible = false;
 				_vm->_dialogs->show(35920);
 				if (_globals[kSexOfRex] == REX_MALE) {
-					_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 4, 2, 0, 0);
+					_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 4, 2, 0, 0);
 					_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 6, 1);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
 				} else {
-					_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], true, 7, 2, 0, 0);
+					_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], true, 7, 2, 0, 0);
 					_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]);
 					_scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(106, 110));
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 6, 1);
@@ -5075,7 +5088,7 @@ void Scene360::enter() {
 
 	if (_scene->_priorSceneId == 359)
 		_game._player._playerPos = Common::Point(304, 143);
-	else if (_scene->_priorSceneId != -2)
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(13, 141);
 
 	sceneEntrySound();
@@ -5341,7 +5354,7 @@ void Scene361::enter() {
 	else if (_scene->_priorSceneId == 320) {
 		_game._player._playerPos = Common::Point(129, 113);
 		_game._player._facing = FACING_SOUTH;
-	} else if (_scene->_priorSceneId != -2)
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(13, 145);
 
 	_game.loadQuoteSet(0xFB, 0xFC, 0);
@@ -5466,7 +5479,7 @@ void Scene361::actions() {
 		_vm->_dialogs->show(36119);
 	else if (_action.isAction(VERB_SIT_AT, NOUN_DESK)) {
 		_scene->_kernelMessages.reset();
-		_scene->_kernelMessages.addQuote(0xFC, 120, 0);
+		_scene->_kernelMessages.addQuote(252, 0, 120);
 	} else if (_action.isAction(VERB_CLIMB_INTO, NOUN_AIR_VENT)) {
 		if (_globals[kSexOfRex] == REX_FEMALE)
 			handleRoxAction();
diff --git a/engines/mads/nebular/nebular_scenes3.h b/engines/mads/nebular/nebular_scenes3.h
index 9efd38e9a4..cf925b3867 100644
--- a/engines/mads/nebular/nebular_scenes3.h
+++ b/engines/mads/nebular/nebular_scenes3.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/nebular/nebular_scenes4.cpp b/engines/mads/nebular/nebular_scenes4.cpp
index 56f6fb4466..c981f6a6e4 100644
--- a/engines/mads/nebular/nebular_scenes4.cpp
+++ b/engines/mads/nebular/nebular_scenes4.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * 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.
@@ -113,7 +113,7 @@ void Scene401::setup() {
 }
 
 void Scene401::enter() {
-	if (_scene->_priorSceneId != -2)
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_northFl = false;
 
 	_timer = 0;
@@ -125,7 +125,7 @@ void Scene401::enter() {
 		_game._player._playerPos = Common::Point(149, 90);
 		_game._player._facing = FACING_SOUTH;
 		_northFl = true;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(142, 131);
 		_game._player._facing = FACING_NORTH;
 	}
@@ -718,7 +718,7 @@ void Scene402::enter() {
 		_roxOnStool = false;
 		_bartenderDialogNode = 1;
 		_conversationFl = false;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(160, 150);
 		_game._player._facing = FACING_NORTH;
 		_game._objects.addToInventory(OBJ_CREDIT_CHIP);
@@ -962,7 +962,7 @@ void Scene402::step() {
 		}
 
 		if (!_bartenderTalking) {
-			_globals._sequenceIndexes[10] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[10], false, 7, 0, 0, 0);
+			_globals._sequenceIndexes[10] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[10], false, 7, 0, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[10], 3, 4);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[10], 8);
 			int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, VERB_WALKTO, _globals._sequenceIndexes[10], Common::Rect(0, 0, 0, 0));
@@ -1514,7 +1514,7 @@ void Scene402::step() {
 				break;
 
 			case 3:
-				_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0);
+				_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 4, 5);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 32);
 				_rightWomanMoving = true;
@@ -1697,7 +1697,7 @@ void Scene402::step() {
 		_scene->_kernelMessages.add(Common::Point(171, 47), 0xFBFA, 0, 0, 130, _game.getQuote(0x200));
 		_scene->_sequences.addTimer(150, 63);
 		_scene->_sequences.remove(_globals._sequenceIndexes[13]);
-		_globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 30, 4, 0, 0);
+		_globals._sequenceIndexes[13] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[13], false, 30, 4, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 10, 11);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 62);
@@ -1769,7 +1769,7 @@ void Scene402::step() {
 
 	case 69: {
 		int seqIdx = _globals._sequenceIndexes[13];
-		_globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 25, 4, 0, 0);
+		_globals._sequenceIndexes[13] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[13], false, 25, 4, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 10, 11);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx);
@@ -1783,7 +1783,7 @@ void Scene402::step() {
 		break;
 
 	case 70:
-		_globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 25, 4, 0, 0);
+		_globals._sequenceIndexes[13] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[13], false, 25, 4, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 10, 12);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 72);
@@ -1840,7 +1840,7 @@ void Scene402::step() {
 				_cutSceneReady = false;
 				_helgaReady = false;
 				_scene->_sequences.remove(_globals._sequenceIndexes[13]);
-				_globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 15, 2, 0, 0);
+				_globals._sequenceIndexes[13] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[13], false, 15, 2, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 11, 13);
 				_scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 26);
@@ -1860,7 +1860,7 @@ void Scene402::step() {
 				_cutSceneReady = false;
 				_helgaReady = false;
 				_scene->_sequences.remove(_globals._sequenceIndexes[13]);
-				_globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 15, 2, 0, 0);
+				_globals._sequenceIndexes[13] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[13], false, 15, 2, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 14, 15);
 				_scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 26);
@@ -2069,7 +2069,7 @@ void Scene402::actions() {
 		if (_game._trigger == 0) {
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[21] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[21], false, 7, 2, 0, 0);
+			_globals._sequenceIndexes[21] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[21], false, 7, 2, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[21], 1, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[21]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[21], SEQUENCE_TRIGGER_SPRITE, 2, 165);
@@ -2202,7 +2202,7 @@ void Scene402::actions() {
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
-		_globals._sequenceIndexes[22] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[22], false, 7, 2, 0, 0);
+		_globals._sequenceIndexes[22] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[22], false, 7, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[22], 1, 2);
 		_scene->_sequences.setPosition(_globals._sequenceIndexes[22], Common::Point(_game._player._playerPos.x, _game._player._playerPos.y + 1));
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[22], 5);
@@ -2411,7 +2411,7 @@ void Scene405::enter() {
 	} else if (_scene->_priorSceneId == 413) {
 		_game._player._playerPos = Common::Point(284, 109);
 		_game._player._facing = FACING_SOUTH;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(23, 123);
 		_game._player._facing = FACING_EAST;
 	}
@@ -2445,7 +2445,7 @@ void Scene405::step() {
 	if (_game._trigger == 70) {
 		_game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount ;
 		_game._player._visible = true;
-		_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0);
+		_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 71);
 		_vm->_sound->command(19);
 	}
@@ -2495,7 +2495,7 @@ void Scene405::actions() {
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 2, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 7, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 75);
 		Common::Point msgPos = Common::Point(_game._player._playerPos.x, _game._player._playerPos.y + 1);
@@ -2505,7 +2505,7 @@ void Scene405::actions() {
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 2, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 7, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 70);
 		_scene->_sequences.setPosition(_globals._sequenceIndexes[3], _game._player._playerPos);
@@ -2514,7 +2514,7 @@ void Scene405::actions() {
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 2, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 7, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 80);
 		_scene->_sequences.setPosition(_globals._sequenceIndexes[3], _game._player._playerPos);
@@ -2587,7 +2587,7 @@ void Scene406::enter() {
 	} else if (_scene->_priorSceneId == 411) {
 		_game._player._playerPos = Common::Point(153, 108);
 		_game._player._facing = FACING_SOUTH;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(15, 129);
 		_game._player._facing = FACING_EAST;
 	}
@@ -2609,7 +2609,7 @@ void Scene406::enter() {
 	else {
 		_game._player._stepEnabled = false;
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 3, 1, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 3, 1, 0, 0);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 90);
 		_vm->_sound->command(19);
 	}
@@ -2647,7 +2647,7 @@ void Scene406::step() {
 	if (_game._trigger == 70) {
 		_game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount;
 		_game._player._visible = true;
-		_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 4, 1, 0, 0);
+		_globals._sequenceIndexes[1] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[1], false, 4, 1, 0, 0);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 71);
 		_vm->_sound->command(19);
 	}
@@ -2703,7 +2703,7 @@ void Scene406::actions() {
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
-		_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0);
+		_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 75);
 		Common::Point msgPos = Common::Point(_game._player._playerPos.x, _game._player._playerPos.y + 1);
@@ -2713,7 +2713,7 @@ void Scene406::actions() {
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
-		_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0);
+		_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 70);
 		Common::Point msgPos = Common::Point(_game._player._playerPos.x, _game._player._playerPos.y + 1);
@@ -2723,7 +2723,7 @@ void Scene406::actions() {
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
-		_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0);
+		_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 110);
 		_scene->_sequences.setPosition(_globals._sequenceIndexes[2], _game._player._playerPos);
@@ -2791,14 +2791,14 @@ void Scene407::setup() {
 }
 
 void Scene407::enter() {
-	if (_scene->_priorSceneId != -2)
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_fromNorth = false;
 
 	if (_scene->_priorSceneId == 318) {
 		_game._player._playerPos = Common::Point(172, 92);
 		_game._player._facing = FACING_SOUTH;
 		_fromNorth = true;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(172, 132);
 		_game._player._facing = FACING_NORTH;
 	}
@@ -2934,7 +2934,7 @@ void Scene408::actions() {
 			_vm->_sound->command(57);
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], true, 7, 2, 0, 0);
+			_globals._sequenceIndexes[1] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[1], true, 7, 2, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[1]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_SPRITE, 2, 1);
@@ -3118,7 +3118,7 @@ void Scene410::enter() {
 	else
 		_scene->_hotspots.activate(NOUN_CHARGE_CASES, false);
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(155, 150);
 		_game._player._facing = FACING_NORTH;
 	}
@@ -3182,7 +3182,7 @@ void Scene410::actions() {
 			_vm->_sound->command(57);
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 3);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 3, 1);
@@ -3646,7 +3646,7 @@ void Scene411::enter() {
 		_scene->_dynamicHotspots.setPosition(idx, Common::Point(220, 121), FACING_NORTHEAST);
 	}
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(60, 146);
 		_game._player._facing = FACING_NORTHEAST;
 	}
@@ -3842,7 +3842,7 @@ void Scene411::actions() {
 			_vm->_sound->command(57);
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[8] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[8], false, 7, 2, 0, 0);
+			_globals._sequenceIndexes[8] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[8], false, 7, 2, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 1, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[8]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_SPRITE, 2, 1);
@@ -3879,7 +3879,7 @@ void Scene411::actions() {
 			_vm->_sound->command(57);
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[8] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[8], false, 7, 2, 0, 0);
+			_globals._sequenceIndexes[8] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[8], false, 7, 2, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 1, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[8]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_SPRITE, 2, 1);
@@ -4058,7 +4058,7 @@ void Scene413::enter() {
 		_game._player._playerPos = Common::Point(142, 146);
 		_game._player._facing = FACING_NORTH;
 		_game._player._visible = true;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		if (_globals[kSexOfRex] == REX_MALE) {
 			_scene->loadAnimation(Resources::formatName(413, 'd', 1, EXT_AA, ""), 78);
 			_vm->_sound->command(30);
@@ -4078,7 +4078,7 @@ void Scene413::enter() {
 		case 1:
 			_vm->_sound->command(30);
 			_game._player._visible = false;
-			_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 7, 1, 0, 0);
+			_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 7, 1, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 19);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 8);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 76);
diff --git a/engines/mads/nebular/nebular_scenes4.h b/engines/mads/nebular/nebular_scenes4.h
index fbd5ce81f0..de11bd4129 100644
--- a/engines/mads/nebular/nebular_scenes4.h
+++ b/engines/mads/nebular/nebular_scenes4.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/nebular/nebular_scenes5.cpp b/engines/mads/nebular/nebular_scenes5.cpp
index 66d8294fc6..95eb429193 100644
--- a/engines/mads/nebular/nebular_scenes5.cpp
+++ b/engines/mads/nebular/nebular_scenes5.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * 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.
@@ -132,7 +132,7 @@ void Scene501::handleSlotActions() {
 			frameIndex = 2;
 		}
 
-		_mainSequenceId = _scene->_sequences.startReverseCycle(_mainSpriteId, false, numTicks, 1, 0, 0);
+		_mainSequenceId = _scene->_sequences.startPingPongCycle(_mainSpriteId, false, numTicks, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_mainSequenceId, 1, frameIndex);
 		_scene->_sequences.setMsgLayout(_mainSequenceId);
 		_vm->_sound->command(10);
@@ -199,7 +199,7 @@ void Scene501::enter() {
 		_game._player._playerPos = Common::Point(317, 102);
 		_game._player._facing = FACING_SOUTHWEST;
 		_scene->_sequences.addTimer(15, 80);
-	} else if (_scene->_priorSceneId != -2)
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(299, 131);
 
 	if (_scene->_roomChanged) {
@@ -238,7 +238,7 @@ void Scene501::step() {
 			break;
 
 		case 82:
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7);
 			_vm->_sound->command(12);
 			_doorHotspotid = _scene->_dynamicHotspots.add(NOUN_DOOR, VERB_WALK_THROUGH, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0));
@@ -273,7 +273,7 @@ void Scene501::step() {
 
 		case 72:
 			_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 73);
 			break;
@@ -415,7 +415,7 @@ void Scene501::actions() {
 		case 7: {
 			_vm->_sound->command(12);
 			int syncIdx = _globals._sequenceIndexes[3];
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7);
 			_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx);
 			_vm->_sound->command(12);
@@ -563,7 +563,7 @@ void Scene503::enter() {
 		_scene->_dynamicHotspots.setPosition(_detonatorHotspotId, Common::Point(254, 135), FACING_SOUTH);
 	}
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(191, 152);
 		_game._player._facing = FACING_NORTHWEST;
 	}
@@ -581,13 +581,13 @@ void Scene503::actions() {
 				_game._player._stepEnabled = false;
 				_game._player._visible = false;
 				if (_globals[kSexOfRex] == REX_MALE) {
-					_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0);
+					_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0);
 					_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 3);
 					_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 3, 1);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
 				} else {
-					_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], true, 8, 1, 0, 0);
+					_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], true, 8, 1, 0, 0);
 					_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 4);
 					_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 4, 1);
@@ -709,7 +709,7 @@ void Scene504::enter() {
 		_globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('a', 3));
 		_carAnimationMode = 1;
 		_scene->loadAnimation(formAnimName('A', -1));
-		if ((_scene->_priorSceneId != -2) && (_scene->_priorSceneId != 505))
+		if ((_scene->_priorSceneId != RETURNING_FROM_DIALOG) && (_scene->_priorSceneId != 505))
 			_globals[kHoverCarLocation] = _scene->_priorSceneId;
 
 		_globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, 1);
@@ -800,7 +800,7 @@ void Scene504::actions() {
 
 		case 1: {
 			int syncIdx = _globals._sequenceIndexes[3];
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 13);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 6);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -912,8 +912,8 @@ void Scene505::enter() {
 	_globals._spriteIndexes[11] = _scene->_sprites.addSprites(formAnimName('t', -1));
 	_globals._spriteIndexes[12] = _scene->_sprites.addSprites(formAnimName('e', -1));
 
-	if (_scene->_priorSceneId != -2)
-		_globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 6, 1, 0, 0);
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
+		_globals._sequenceIndexes[12] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[12], false, 6, 1, 0, 0);
 
 	_globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 6, 1, 120, 0);
 	_scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 60);
@@ -934,7 +934,7 @@ void Scene505::enter() {
 	for (int i = 0; i < 9; i++) {
 		if (_globals[kHoverCarLocation] == _carLocations[i]) {
 			_homeSelectedId = i;
-			if (_scene->_priorSceneId != -2)
+			if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 				_selectedId = i;
 		}
 	}
@@ -996,7 +996,7 @@ void Scene505::step() {
 					_scene->_sequences.remove(_globals._sequenceIndexes[1]);
 					_scene->_sequences.remove(_globals._sequenceIndexes[0]);
 					_scene->_sequences.remove(_globals._sequenceIndexes[13]);
-					_globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 6, 1, 0, 0);
+					_globals._sequenceIndexes[13] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[13], false, 6, 1, 0, 0);
 					_scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 63);
 					_vm->_sound->command(18);
 				}
@@ -1222,7 +1222,7 @@ void Scene506::enter() {
 		_game._player._facing = FACING_SOUTHEAST;
 		_scene->_sequences.addTimer(60, 80);
 		_game._player._stepEnabled = false;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(138, 116);
 		_game._player._facing = FACING_NORTHEAST;
 		_game._player._visible = false;
@@ -1260,7 +1260,7 @@ void Scene506::step() {
 
 		case 71:
 			_scene->_sequences.remove(_globals._sequenceIndexes[3]);
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 5);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 72);
 			break;
@@ -1317,7 +1317,7 @@ void Scene506::handleDoorSequences() {
 
 	case 82:
 		_scene->_sequences.remove(_doorSequenceIdx);
-		_doorSequenceIdx = _scene->_sequences.startReverseCycle(_doorSpriteIdx, false, 7, 1, 0, 0);
+		_doorSequenceIdx = _scene->_sequences.addReverseSpriteCycle(_doorSpriteIdx, false, 7, 1, 0, 0);
 		_scene->_sequences.setDepth(_doorSequenceIdx, _doorDepth);
 		if (_actionFl)
 			_scene->_sequences.addSubEntry(_doorSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 84);
@@ -1471,7 +1471,7 @@ void Scene507::enter() {
 		_scene->_dynamicHotspots.setPosition(_penlightHotspotId, Common::Point(233, 152), FACING_SOUTHEAST);
 	}
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(121, 147);
 		_game._player._facing = FACING_NORTH;
 	}
@@ -1487,7 +1487,7 @@ void Scene507::actions() {
 			case 0:
 				_game._player._stepEnabled = false;
 				_game._player._visible = false;
-				_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0);
+				_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 5);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 5, 1);
@@ -1547,7 +1547,9 @@ void Scene507::actions() {
 		_vm->_dialogs->show(50724);
 	else if (_action.isAction(VERB_LOOK, NOUN_WINDOW))
 		_vm->_dialogs->show(50725);
-	else if (_action.isAction(VERB_LOOK, NOUN_COUNTER)) {
+	else if (_action.isAction(VERB_WALK_BEHIND, NOUN_COUNTER)) {
+		// WORKAROUND: Empty handling to prevent default "can't do that" dialogs showing
+	} else if (_action.isAction(VERB_LOOK, NOUN_COUNTER)) {
 		if (_game._objects.isInRoom(OBJ_PENLIGHT))
 			_vm->_dialogs->show(50728);
 		else
@@ -1613,7 +1615,7 @@ void Scene508::enter() {
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[4], 11);
 		int idx = _scene->_dynamicHotspots.add(NOUN_LASER_BEAM, VERB_WALKTO, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0));
 		_scene->_dynamicHotspots.setPosition(idx, Common::Point(57, 116), FACING_NORTHEAST);
-		_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 15, 0, 0, 0);
+		_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 15, 0, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 6, 8);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 6);
 		if (_globals[kLaserHoleIsThere]) {
@@ -1628,7 +1630,7 @@ void Scene508::enter() {
 	if (_scene->_priorSceneId == 515) {
 		_game._player._playerPos = Common::Point(57, 116);
 		_game._player._facing = FACING_NORTHEAST;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(289, 139);
 		_game._player._facing = FACING_WEST;
 	}
@@ -1659,7 +1661,7 @@ void Scene508::handlePedestral() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[6] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[6], false, 9, 1, 0, 0);
+			_globals._sequenceIndexes[6] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[6], false, 9, 1, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 1, 4);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[6]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_SPRITE, 4, 1);
@@ -1732,7 +1734,7 @@ void Scene508::actions() {
 				break;
 
 			case 4:
-				_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 15, 0, 0, 0);
+				_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 15, 0, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 6, 8);
 				_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 6);
 				break;
@@ -1866,7 +1868,7 @@ void Scene511::enter() {
 	_globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('c', 0));
 	_globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXCD_6");
 
-	if (_scene->_priorSceneId != -2)
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_handingLine = false;
 
 	if (_globals[kBoatRaised]) {
@@ -1921,7 +1923,7 @@ void Scene511::enter() {
 	if (_scene->_priorSceneId == 512) {
 		_game._player._playerPos = Common::Point(60, 112);
 		_game._player._facing = FACING_SOUTHEAST;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(55, 152);
 		_game._player._facing = FACING_NORTHWEST;
 		_game._player._visible = false;
@@ -2024,7 +2026,7 @@ void Scene511::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_scene->_sequences.remove(_globals._sequenceIndexes[1]);
-			_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0);
+			_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
 			break;
@@ -2064,6 +2066,7 @@ void Scene511::actions() {
 					if (_game._trigger == 0) {
 						_game._player._stepEnabled = false;
 						_game._player._visible = false;
+						_game._player.update();
 						_lineAnimationMode = 1;
 						_lineAnimationPosition = 1;
 						_lineMoving = true;
@@ -2086,7 +2089,8 @@ void Scene511::actions() {
 		} else {
 			_vm->_dialogs->show(51130);
 		}
-	} else if (_action.isAction(VERB_TIE, NOUN_FISHING_LINE, NOUN_BOAT) || _action.isAction(VERB_ATTACH, NOUN_FISHING_LINE, NOUN_BOAT)) {
+	} else if (_action.isAction(VERB_TIE, NOUN_FISHING_LINE, NOUN_BOAT) || 
+			_action.isAction(VERB_ATTACH, NOUN_FISHING_LINE, NOUN_BOAT)) {
 		if (_globals[kBoatRaised])
 			_vm->_dialogs->show(51131);
 		else if (_globals[kLineStatus] == 1)
@@ -2104,7 +2108,6 @@ void Scene511::actions() {
 						_scene->_sequences.addTimer(1, 1);
 					else {
 						_game._player._visible = true;
-						_game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount;
 						_globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, -2);
 						_scene->_sequences.setDepth(_globals._sequenceIndexes[7], 4);
 						int idx = _scene->_dynamicHotspots.add(NOUN_FISHING_LINE, VERB_WALKTO, _globals._sequenceIndexes[7], Common::Rect(0, 0, 0, 0));
@@ -2114,6 +2117,10 @@ void Scene511::actions() {
 						_lineMoving = true;
 						_globals[kLineStatus] = 3;
 						_game._player._stepEnabled = true;
+
+						if (_scene->_activeAnimation)
+							_scene->_activeAnimation->eraseSprites();
+						_game._player.update();
 					}
 				}
 			}
@@ -2240,7 +2247,7 @@ void Scene512::enter() {
 	} else
 		_scene->_hotspots.activate(NOUN_PADLOCK_KEY, false);
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(144, 152);
 		_game._player._facing = FACING_NORTHEAST;
 	}
@@ -2257,7 +2264,7 @@ void Scene512::actions() {
 			case 0:
 				_game._player._stepEnabled = false;
 				_game._player._visible = false;
-				_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0);
+				_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 5, 1);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -2293,7 +2300,7 @@ void Scene512::actions() {
 
 			case 1:
 				_game._player._visible = false;
-				_globals._sequenceIndexes[8] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[8], false, 9, 1, 0, 0);
+				_globals._sequenceIndexes[8] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[8], false, 9, 1, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 1, 3);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[8]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -2326,7 +2333,7 @@ void Scene512::actions() {
 				break;
 
 			case 5:
-				_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 14, 0, 0, 0);
+				_globals._sequenceIndexes[5] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[5], false, 14, 0, 0, 0);
 				_scene->_sequences.setDepth(_globals._sequenceIndexes[5], 3);
 				_scene->_hotspots.activate(NOUN_PADLOCK_KEY, true);
 				_scene->_sequences.addTimer(60, 6);
@@ -2347,7 +2354,7 @@ void Scene512::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 10, 1, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 10, 1, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
@@ -2358,12 +2365,12 @@ void Scene512::actions() {
 			_game._player._visible = true;
 			if (!_game._objects.isInRoom(OBJ_PADLOCK_KEY) || _game._difficulty == DIFFICULTY_EASY) {
 				_scene->_sequences.remove(_globals._sequenceIndexes[3]);
-				_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0);
+				_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0);
 				_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
 			} else {
 				_scene->_sequences.remove(_globals._sequenceIndexes[5]);
-				_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0);
+				_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0);
 				_scene->_sequences.setDepth(_globals._sequenceIndexes[4], 3);
 				_scene->_hotspots.activate(NOUN_PADLOCK_KEY, false);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -2391,7 +2398,7 @@ void Scene512::actions() {
 				else
 					endVal = 2;
 
-				_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 10, 1, 0, 0);
+				_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 10, 1, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, endVal);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, endVal, 1);
@@ -2427,7 +2434,8 @@ void Scene512::actions() {
 		_vm->_dialogs->show(51225);
 	else if (_action.isAction(VERB_LOOK, NOUN_PADLOCK_KEY) && _game._objects.isInRoom(OBJ_PADLOCK_KEY))
 		_vm->_dialogs->show(51215);
-	else if (_action.isAction(VERB_LOOK, NOUN_FISHING_ROD) && (_scene->_activeAnimation->getCurrentFrame() == 4))
+	else if (_action.isAction(VERB_LOOK, NOUN_FISHING_ROD) && (!_scene->_activeAnimation ||
+			_scene->_activeAnimation->getCurrentFrame() == 4))
 		_vm->_dialogs->show(51216);
 	else if (_action.isAction(VERB_LOOK, NOUN_SHIPS_WHEEL))
 		_vm->_dialogs->show(51218);
@@ -2460,7 +2468,9 @@ void Scene512::actions() {
 		_vm->_dialogs->show(51233);
 	else if (_action.isAction(VERB_LOOK, NOUN_LAMP))
 		_vm->_dialogs->show(51234);
-	else if (_action.isAction(VERB_LOOK, NOUN_COUNTER))
+	else if (_action.isAction(VERB_WALK_BEHIND, NOUN_COUNTER)) {
+		// WORKAROUND: Empty handling to prevent default "can't do that" dialogs showing
+	} else if (_action.isAction(VERB_LOOK, NOUN_COUNTER))
 		_vm->_dialogs->show(51235);
 	else if (_action.isAction(VERB_LOOK, NOUN_ICE_CHESTS))
 		_vm->_dialogs->show(51237);
@@ -2505,7 +2515,7 @@ void Scene513::enter() {
 		_game._player._facing = FACING_WEST;
 		_game._player._stepEnabled = false;
 		_scene->_sequences.addTimer(15, 80);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(63, 149);
 		_game._player._facing = FACING_NORTHEAST;
 		_game._player._visible = false;
@@ -2529,7 +2539,7 @@ void Scene513::step() {
 	case 80:
 		_game._player._stepEnabled = false;
 		_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-		_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0);
+		_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2);
 		_vm->_sound->command(24);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 81);
@@ -2588,7 +2598,7 @@ void Scene513::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_scene->_sequences.remove(_globals._sequenceIndexes[1]);
-			_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0);
+			_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
 			break;
@@ -2626,7 +2636,7 @@ void Scene513::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 7, 1, 0, 0);
+			_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 7, 1, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 1, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
@@ -2636,7 +2646,7 @@ void Scene513::actions() {
 			_scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[4]);
 			_game._player._visible = true;
 			_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2);
 			_vm->_sound->command(24);
 			_scene->_kernelMessages.reset();
@@ -2739,7 +2749,7 @@ void Scene551::enter() {
 
 	if (_scene->_priorSceneId == 501)
 		_game._player._playerPos = Common::Point(18, 130);
-	else if (_scene->_priorSceneId != -2) {
+	else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(124, 119);
 		_game._player._facing = FACING_NORTH;
 	}
diff --git a/engines/mads/nebular/nebular_scenes5.h b/engines/mads/nebular/nebular_scenes5.h
index 2face26508..f314ae8513 100644
--- a/engines/mads/nebular/nebular_scenes5.h
+++ b/engines/mads/nebular/nebular_scenes5.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/nebular/nebular_scenes6.cpp b/engines/mads/nebular/nebular_scenes6.cpp
index 679039535f..d97e37ea0b 100644
--- a/engines/mads/nebular/nebular_scenes6.cpp
+++ b/engines/mads/nebular/nebular_scenes6.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * 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.
@@ -112,7 +112,7 @@ void Scene601::enter() {
 		_globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 3);
 		_scene->loadAnimation(formAnimName('R', 1), 70);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(229, 129);
 		_game._player._facing = FACING_SOUTHWEST;
 	}
@@ -130,7 +130,7 @@ void Scene601::step() {
 
 	case 71:
 		_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-		_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0);
+		_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 3);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 72);
 		break;
@@ -293,7 +293,7 @@ void Scene602::enter() {
 	if (_scene->_priorSceneId == 603) {
 		_game._player._playerPos = Common::Point(228, 126);
 		_game._player._facing = FACING_WEST;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(50, 127);
 		_game._player._facing = FACING_EAST;
 	}
@@ -313,7 +313,7 @@ void Scene602::handleSafeActions() {
 	case 0:
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
-		_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], true, 12, 1, 0, 0);
+		_globals._sequenceIndexes[5] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[5], true, 12, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 3);
 		_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_SPRITE, 3, 1);
@@ -348,7 +348,7 @@ void Scene602::handleSafeActions() {
 			else
 				_lastSpriteIdx = _globals._spriteIndexes[3];
 
-			_lastSequenceIdx = _scene->_sequences.startReverseCycle(_lastSpriteIdx, false, 12, 1, 0, 0);
+			_lastSequenceIdx = _scene->_sequences.startPingPongCycle(_lastSpriteIdx, false, 12, 1, 0, 0);
 			_scene->_sequences.setDepth(_lastSequenceIdx, 14);
 			if (_game._objects[OBJ_DOOR_KEY]._roomNumber == _scene->_currentSceneId)
 				_scene->_hotspots.activate(NOUN_DOOR_KEY, false);
@@ -460,7 +460,7 @@ void Scene602::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], true, 8, 1, 0, 0);
+			_globals._sequenceIndexes[5] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[5], true, 8, 1, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 3);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_SPRITE, 3, 1);
@@ -585,7 +585,7 @@ void Scene603::enter() {
 		_scene->_dynamicHotspots.setPosition(_noteHotspotId, Common::Point(242, 118), FACING_NORTHEAST);
 	}
 
-	if (_scene->_priorSceneId != -2)
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG)
 		_game._player._playerPos = Common::Point(113, 134);
 
 	sceneEntrySound();
@@ -600,7 +600,7 @@ void Scene603::actions() {
 			case 0:
 				_game._player._stepEnabled = false;
 				_game._player._visible = false;
-				_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 8, 1, 0, 0);
+				_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 8, 1, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 1, 5);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 5, 1);
@@ -750,7 +750,7 @@ void Scene604::enter() {
 	_vm->_palette->setEntry(253, 45, 24, 17);
 	_animationActiveFl = false;
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(72, 149);
 		_game._player._facing = FACING_NORTHEAST;
 		_game._player._visible = false;
@@ -858,7 +858,7 @@ void Scene604::handleBombActions() {
 	case 0:
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
-		_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 9, 1, 0, 0);
+		_globals._sequenceIndexes[5] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[5], false, 9, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 3);
 		_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]);
 		if (_bombMode == 1)
@@ -908,7 +908,7 @@ void Scene604::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
 			break;
@@ -948,8 +948,14 @@ void Scene604::actions() {
 		_bombMode = 1;
 		if ((_game._difficulty == DIFFICULTY_HARD) || _globals[kWarnedFloodCity])
 			handleBombActions();
-		else if ((_game._objects.isInInventory(OBJ_POLYCEMENT) && _game._objects.isInInventory(OBJ_CHICKEN))
-			 && ((_globals[kLineStatus] == LINE_TIED) || ((_game._difficulty == DIFFICULTY_EASY) && (!_globals[kBoatRaised]))))
+		else if (
+			(_game._objects.isInInventory(OBJ_POLYCEMENT) && (_game._objects.isInInventory(OBJ_CHICKEN) || _game._objects.isInInventory(OBJ_CHICKEN_BOMB)))
+			 && (_globals[kLineStatus] == LINE_TIED || (_game._difficulty == DIFFICULTY_EASY && !_globals[kBoatRaised]))
+			)
+			// The original can get in an impossible state at this point, if the player has
+			// combined the chicken with the bomb before placing the timer bomb on the ledge.
+			// Therefore, we also allow the player to place the bomb if the chicken bomb is
+			// in the inventory.
 			handleBombActions();
 		else if (_game._difficulty == DIFFICULTY_EASY)
 			_vm->_dialogs->show(60424);
@@ -1003,12 +1009,12 @@ void Scene605::enter() {
 	_globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('n', -1));
 	_globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('f', -1));
 
-	_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 15, 0, 0, 0);
-	_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 17, 0, 0, 0);
-	_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 14, 0, 0, 0);
-	_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 13, 0, 0, 0);
-	_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 17, 0, 0, 0);
-	_globals._sequenceIndexes[6] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[6], false, 18, 0, 0, 0);
+	_globals._sequenceIndexes[1] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[1], false, 15, 0, 0, 0);
+	_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 17, 0, 0, 0);
+	_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 14, 0, 0, 0);
+	_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 13, 0, 0, 0);
+	_globals._sequenceIndexes[5] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[5], false, 17, 0, 0, 0);
+	_globals._sequenceIndexes[6] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[6], false, 18, 0, 0, 0);
 
 	_game._player._visible = false;
 	_game._player._stepEnabled = false;
@@ -1106,7 +1112,7 @@ void Scene607::enter() {
 	if (_scene->_priorSceneId == 608) {
 		_game._player._playerPos = Common::Point(297, 50);
 		_game._player._facing = FACING_SOUTHEAST;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(40, 104);
 		_game._player._facing = FACING_SOUTHEAST;
 		_game._player._visible = false;
@@ -1164,7 +1170,7 @@ void Scene607::step() {
 	 && !_dogBarking && (_vm->getRandomNumber(1, 50) == 10)) {
 		_dogBarking = true;
 		_scene->_sequences.remove(_globals._sequenceIndexes[1]);
-		_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 5, 8, 0, 0);
+		_globals._sequenceIndexes[1] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[1], false, 5, 8, 0, 0);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 6);
 		_scene->_kernelMessages.reset();
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_SPRITE, 2, 100);
@@ -1250,7 +1256,7 @@ void Scene607::step() {
 
 		case 61: {
 			int syncIdx = _globals._sequenceIndexes[4];
-			_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 15, 3, 0, 0);
+			_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 15, 3, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 46, -2);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1);
 			_scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx);
@@ -1397,7 +1403,7 @@ void Scene607::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
 			break;
@@ -1778,7 +1784,7 @@ void Scene608::enter() {
 	_vm->_palette->setEntry(252, 63, 44, 30);
 	_vm->_palette->setEntry(253, 63, 20, 22);
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(46, 132);
 		_game._player._facing = FACING_EAST;
 		if (_game._difficulty == DIFFICULTY_HARD) {
@@ -1791,7 +1797,7 @@ void Scene608::enter() {
 		if (!_dogUnderCar)
 			resetDogVariables();
 		else {
-			_globals._sequenceIndexes[10] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[10], false, 9, 0, 0, 0);
+			_globals._sequenceIndexes[10] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[10], false, 9, 0, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[10], 10, 11);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[10], 6);
 		}
@@ -1833,7 +1839,7 @@ void Scene608::step() {
 			if (_vm->getRandomNumber(1, 50) == 10) {
 				_dogBarkingFl = true;
 				_scene->_sequences.remove(_globals._sequenceIndexes[5]);
-				_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 5, 8, 0, 0);
+				_globals._sequenceIndexes[5] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[5], false, 5, 8, 0, 0);
 				_scene->_sequences.setDepth(_globals._sequenceIndexes[5], 4);
 				int idx = _scene->_dynamicHotspots.add(NOUN_OBNOXIOUS_DOG, VERB_WALKTO, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0));
 				_scene->_dynamicHotspots.setPosition(idx, Common::Point(194, 142), FACING_EAST);
@@ -1958,7 +1964,7 @@ void Scene608::step() {
 				_game._player._visible = true;
 				_game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount;
 			} else if (_carFrame == 41) {
-				_globals._sequenceIndexes[10] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[10], false, 9, 0, 0, 0);
+				_globals._sequenceIndexes[10] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[10], false, 9, 0, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[10], 10, 11);
 				_scene->_sequences.setDepth(_globals._sequenceIndexes[10], 6);
 				_dogUnderCar = true;
@@ -2148,7 +2154,7 @@ void Scene608::step() {
 
 		case 82: {
 			int syncIdx = _globals._sequenceIndexes[9];
-			_globals._sequenceIndexes[9] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[9], false, 15, 5, 0, 0);
+			_globals._sequenceIndexes[9] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[9], false, 15, 5, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], 39, 40);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[9], 5);
 			_scene->_sequences.updateTimeout(_globals._sequenceIndexes[9], syncIdx);
@@ -2219,7 +2225,7 @@ void Scene608::actions() {
 			if ((_globals[kCarStatus] == CAR_UP) || (_globals[kCarStatus] == CAR_SQUASHES_DOG) || (_globals[kCarStatus] == CAR_SQUASHES_DOG_AGAIN)) {
 				_game._player._stepEnabled = false;
 				_game._player._visible = false;
-				_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], true, 6, 2, 0, 0);
+				_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], true, 6, 2, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
@@ -2293,7 +2299,7 @@ void Scene608::actions() {
 			if ((_globals[kCarStatus] == CAR_DOWN) || (_globals[kCarStatus] == CAR_DOWN_ON_SQUASHED_DOG)) {
 				_game._player._stepEnabled = false;
 				_game._player._visible = false;
-				_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], true, 6, 2, 0, 0);
+				_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], true, 6, 2, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 3);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
@@ -2379,7 +2385,7 @@ void Scene608::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], true, 6, 2, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], true, 6, 2, 0, 0);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 4, 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -2407,7 +2413,7 @@ void Scene608::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], true, 6, 2, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], true, 6, 2, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 2, 1);
@@ -2535,7 +2541,7 @@ void Scene609::enter() {
 		_game._player._facing = FACING_EAST;
 		_scene->_sequences.addTimer(60, 60);
 		_game._player._stepEnabled = false;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(86, 136);
 		_game._player._facing = FACING_NORTHEAST;
 		_game._player._visible = false;
@@ -2574,7 +2580,7 @@ void Scene609::step() {
 
 	case 62:
 		_scene->_sequences.remove( _globals._sequenceIndexes[2]);
-		_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0);
+		_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0);
 		_scene->_hotspots.activate(NOUN_VIDEO_STORE_DOOR, true);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 63);
@@ -2582,7 +2588,7 @@ void Scene609::step() {
 
 	case 63:
 		if (!_globals[kHasTalkedToHermit] && (_game._difficulty != DIFFICULTY_HARD)) {
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 26, 2, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 26, 2, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[3], Common::Point(287, 73));
 			_scene->_sequences.setScale(_globals._sequenceIndexes[3], 47);
@@ -2605,7 +2611,7 @@ void Scene609::step() {
 
 	case 71:
 		if (!_globals[kHasTalkedToHermit]) {
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 26, 2, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 26, 2, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[3], Common::Point(287, 73));
 			_scene->_sequences.setScale(_globals._sequenceIndexes[3], 47);
@@ -2648,7 +2654,7 @@ void Scene609::enterStore() {
 
 	case 2:
 		_game._player._visible = false;
-		_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], true, 11, 2, 0, 0);
+		_globals._sequenceIndexes[5] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[5], true, 11, 2, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 2);
 		_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 3);
@@ -2690,7 +2696,7 @@ void Scene609::enterStore() {
 
 	case 7:
 		_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-		_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0);
+		_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 8);
 		break;
@@ -2766,7 +2772,7 @@ void Scene609::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_scene->_sequences.remove(_globals._sequenceIndexes[1]);
-			_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0);
+			_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
 			break;
@@ -2884,7 +2890,7 @@ void Scene610::enter() {
 	if (_scene->_roomChanged && _game._difficulty != DIFFICULTY_EASY)
 		_game._objects.addToInventory(OBJ_PENLIGHT);
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(175, 152);
 		_game._player._facing = FACING_NORTHWEST;
 	}
@@ -2922,7 +2928,7 @@ void Scene610::actions() {
 			case 0:
 				_game._player._stepEnabled = false;
 				_game._player._visible = false;
-				_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], true, 8, 1, 0, 0);
+				_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], true, 8, 1, 0, 0);
 				_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2);
 				_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 				_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 2, 1);
@@ -2952,7 +2958,7 @@ void Scene610::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], true, 8, 1, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], true, 8, 1, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 2, 1);
@@ -3253,6 +3259,8 @@ void Scene611::handleSubDialog1() {
 		handleTalking(500);
 		displayHermitQuestions(17);
 		_dialog1.write(0x290, false);
+		_dialog1.write(0x28e, false);
+
 		if (!_dialog1.read(0x28F))
 			_dialog1.write(0x291, true);
 
@@ -3271,8 +3279,9 @@ void Scene611::handleSubDialog1() {
 		if ((_game._objects.isInInventory(OBJ_DURAFAIL_CELLS)) || (_game._objects.isInInventory(OBJ_PHONE_CELLS)))
 			_dialog1.write(0x294, true);
 
-		if (!_game._objects.isInInventory(OBJ_DURAFAIL_CELLS) && !_game._objects.isInInventory(OBJ_PHONE_CELLS))
-			_globals[kExecuted_1_11] = true;
+		// WORKAROUND: Fix bug in the original where the option to give Hermit batteries
+		// would be given before the player even has any batteries
+		_globals[kHermitWantsBatteries] = true;
 
 		setDialogNode(1);
 		break;
@@ -3826,29 +3835,29 @@ void Scene611::displayHermitQuestions(int question) {
 		Common::String curQuote = _game.getQuote(0x2D3);
 		int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing);
 		int quotePosX = _defaultDialogPos.x - (width / 2);
-		_scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 3), 0xFDFC, 0, 0, 9999999, curQuote);
+		_scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 3), 0xFDFC, 0, 0, 800, curQuote);
 
 		curQuote = _game.getQuote(0x2D4);
 		width = _vm->_font->getWidth(curQuote, _scene->_textSpacing);
 		quotePosX = _defaultDialogPos.x - (width / 2);
-		_scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 9999999, curQuote);
+		_scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 800, curQuote);
 
 		curQuote = _game.getQuote(0x2D5);
 		width = _vm->_font->getWidth(curQuote, _scene->_textSpacing);
 		quotePosX = _defaultDialogPos.x - (width / 2);
-		_scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote);
+		_scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 800, curQuote);
 
 		curQuote = _game.getQuote(0x2D6);
 		width = _vm->_font->getWidth(curQuote, _scene->_textSpacing);
 		quotePosX = _defaultDialogPos.x - (width / 2);
-		_scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote);
+		_scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 800, curQuote);
 
 		curQuote = _game.getQuote(0x2D7);
 		width = _vm->_font->getWidth(curQuote, _scene->_textSpacing);
 		quotePosX = _defaultDialogPos.x - (width / 2);
-		_scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote);
-		 }
-		 break;
+		_scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 800, curQuote);
+		}
+		break;
 
 	case 22: {
 		Common::String curQuote = _game.getQuote(0x2D8);
@@ -3921,14 +3930,14 @@ void Scene611::enter() {
 		0x2D9, 0x2DA, 0x2DB, 0x2DC, 0x2DD, 0x2DE, 0x2DF, 0x2E0, 0x2E1, 0x2E2, 0x2E3, 0x2E4, 0x2E5, 0x2E6,
 		0x323, 0x324, 0);
 
-	_dialog1.setup(0x82, 0x287, 0x288, 0x289, 0x28A, 0x28B, 0x28C, 0x28D, 0x28E, 0x28F, 0x290,
+	_dialog1.setup(kConvHermit1, 0x287, 0x288, 0x289, 0x28A, 0x28B, 0x28C, 0x28D, 0x28E, 0x28F, 0x290, 
 		0x291, 0x292, 0x293, 0x294, 0x295, 0x296, 0);
 
-	_dialog2.setup(0x83, 0x29C, 0x29D, 0x29E, 0x29F, 0);
+	_dialog2.setup(kConvHermit2, 0x29C, 0x29D, 0x29E, 0x29F, 0);
 
 	if (!_game._visitedScenes._sceneRevisited) {
-		_dialog1.set(0x82, 0x287, 0x288, 0x296, 0);
-		_dialog2.set(0x83, 0x29F, 0);
+		_dialog1.set(kConvHermit1, 0x287, 0x288, 0x296, 0);
+		_dialog2.set(kConvHermit2, 0x29F, 0);
 	}
 
 	_vm->_palette->setEntry(252, 51, 51, 47);
@@ -3945,7 +3954,7 @@ void Scene611::enter() {
 	_alreadyTalkingFl = false;
 	_startTradingFl = false;
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(22, 132);
 		_game._player._facing = FACING_EAST;
 		_duringDialogFl = false;
@@ -3964,11 +3973,10 @@ void Scene611::enter() {
 		_scene->_hotspots.activate(NOUN_HERMIT, false);
 	}
 
-	// CHECKME: The last line of the block looks extremely useless
-	if (_globals[kExecuted_1_11]) {
-		_dialog1.write(0x294, true);
-		_dialog1.write(0x292, false);
-		_globals[kExecuted_1_11] = true;
+	// WORKAROUND: Fix original adding 'give batteries' option even if you don't have them
+	if (_globals[kHermitWantsBatteries]) {
+		if ((_game._objects.isInInventory(OBJ_DURAFAIL_CELLS)) || (_game._objects.isInInventory(OBJ_PHONE_CELLS)))
+			_dialog1.write(0x294, true);
 	}
 
 	if (_duringDialogFl) {
@@ -4012,7 +4020,7 @@ void Scene611::step() {
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 81);
 	} else if (_game._trigger == 81) {
 		int syncId = _globals._sequenceIndexes[1];
-		_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 20, 0, 0, 0);
+		_globals._sequenceIndexes[1] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[1], false, 20, 0, 0, 0);
 		int idx = _scene->_dynamicHotspots.add(NOUN_RAT, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0));
 		_ratHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(272, 154), FACING_SOUTHEAST);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 9, 10);
@@ -4040,7 +4048,7 @@ void Scene611::step() {
 			break;
 
 		case 6:
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 12, 3, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 12, 3, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 2, 4);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 71);
@@ -4260,7 +4268,7 @@ void Scene611::step() {
 	if (_hermitMode == 6) {
 		if ((_scene->_activeAnimation->getCurrentFrame() == 9) && _check1Fl) {
 			_scene->_sequences.remove(_globals._sequenceIndexes[3]);
-			_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0);
+			_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 112);
@@ -4300,7 +4308,7 @@ void Scene611::step() {
 		_resetBatterieText = true;
 		int syncIdx = _globals._sequenceIndexes[3];
 		_nextFrame = 10;
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx);
 		_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]);
@@ -4488,7 +4496,7 @@ void Scene612::handleWinchMovement() {
 	case 0:
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
-		_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 10, 1, 0, 0);
+		_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 10, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 1, 5);
 		_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 5, 1);
@@ -4506,7 +4514,7 @@ void Scene612::handleWinchMovement() {
 			_globals[kBoatRaised] = false;
 		} else {
 			_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 17, 9, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], false, 17, 9, 0, 0);
 			_vm->_sound->command(18);
 		}
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1);
@@ -4558,7 +4566,7 @@ void Scene612::enter() {
 	_globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, _cycleIndex);
 	_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1);
 
-	if (_scene->_priorSceneId != -2) {
+	if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(280, 75);
 		_game._player._facing = FACING_SOUTHWEST;
 		_game._player._visible = false;
@@ -4608,7 +4616,7 @@ void Scene612::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_scene->_sequences.remove(_globals._sequenceIndexes[1]);
-			_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0);
+			_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0);
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
 			break;
diff --git a/engines/mads/nebular/nebular_scenes6.h b/engines/mads/nebular/nebular_scenes6.h
index c5cac56626..4fc4a2e8ae 100644
--- a/engines/mads/nebular/nebular_scenes6.h
+++ b/engines/mads/nebular/nebular_scenes6.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * 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.
diff --git a/engines/mads/nebular/nebular_scenes7.cpp b/engines/mads/nebular/nebular_scenes7.cpp
index 0f019c4b19..c2a249e5f8 100644
--- a/engines/mads/nebular/nebular_scenes7.cpp
+++ b/engines/mads/nebular/nebular_scenes7.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * 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.
@@ -148,17 +148,20 @@ void Scene701::enter() {
 
 	switch (boatStatus) {
 	case BOAT_TIED_FLOATING:
-		_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 20, 0, 0, 0);
+		_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 20, 0, 0, 0);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[4], 10);
 		break;
 	case BOAT_ADRIFT:
-		_globals._sequenceIndexes[6] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[6], false, 20, 0, 0, 0);
+		_globals._sequenceIndexes[6] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[6], false, 20, 0, 0, 0);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[6], 10);
 		break;
-	case BOAT_TIED:
+	case BOAT_TIED: {
 		_globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9);
+		int idx = _scene->_dynamicHotspots.add(837, 759, _globals._sequenceIndexes[2], Common::Rect());
+		_scene->_dynamicHotspots.setPosition(idx, Common::Point(231, 127), FACING_NORTH);
 		break;
+	}
 	case BOAT_GONE:
 		_scene->_hotspots.activate(NOUN_BOAT, false);
 		break;
@@ -191,7 +194,7 @@ void Scene701::enter() {
 		_game._player._stepEnabled = false;
 		_scene->loadAnimation(formAnimName('B', 1), 80);
 		_vm->_sound->command(28);
-	} else if (_scene->_priorSceneId != -2 && _scene->_priorSceneId != 620) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG && _scene->_priorSceneId != 620) {
 		_game._player._playerPos = Common::Point(22, 131);
 		_game._player._facing = FACING_EAST;
 		_game._player._stepEnabled = false;
@@ -206,7 +209,7 @@ void Scene701::step() {
 	switch(_game._trigger) {
 	case 60:
 		_scene->_sequences.remove(_globals._sequenceIndexes[5]);
-		_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 6, 1, 0, 0);
+		_globals._sequenceIndexes[5] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[5], false, 6, 1, 0, 0);
 		_scene->_sequences.setPosition(_globals._sequenceIndexes[5], Common::Point(155, 129));
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 61);
 		break;
@@ -276,10 +279,8 @@ void Scene701::preActions() {
 }
 
 void Scene701::actions() {
-	if (_action.isAction(VERB_WALK_ALONG, NOUN_PLATFORM))
-		return;
-
-	if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS, NOUN_BUILDING) && _game._objects[OBJ_VASE]._roomNumber == 706) {
+	if (_action.isAction(VERB_WALK_ALONG, NOUN_PLATFORM)) {
+	} else if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS, NOUN_BUILDING) && _game._objects[OBJ_VASE]._roomNumber == 706) {
 		switch (_game._trigger) {
 		case 0:
 			_game._player._stepEnabled = false;
@@ -326,7 +327,7 @@ void Scene701::actions() {
 
 		case 3:
 			_vm->_sound->command(17);
-			_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0);
+			_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136));
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 4);
@@ -415,7 +416,7 @@ void Scene701::actions() {
 			_vm->_dialogs->show(70111);
 	} else if (_action.isAction(VERB_LOOK, NOUN_SUBMERGED_CITY))
 		_vm->_dialogs->show(70112);
-	else if (_action.isAction(VERB_LOOK, 0))
+	else if (_action.isAction(VERB_LOOK, NOUN_ELEVATOR))
 		_vm->_dialogs->show(70113);
 	else if (_action.isAction(VERB_LOOK, NOUN_PLATFORM))
 		_vm->_dialogs->show(70114);
@@ -460,7 +461,7 @@ void Scene702::enter() {
 	if (_scene->_priorSceneId == 701) {
 		_game._player._playerPos = Common::Point(13, 145);
 		_game._player._facing = FACING_EAST;
-	} else if (_scene->_priorSceneId != -2 && _scene->_priorSceneId != 620) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG && _scene->_priorSceneId != 620) {
 		_game._player._playerPos = Common::Point(289, 138);
 		_game._player.walk(Common::Point(262, 148), FACING_WEST);
 		_game._player._facing = FACING_WEST;
@@ -502,7 +503,7 @@ void Scene702::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 5, 2, 0, 0);
+			_globals._sequenceIndexes[12] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[12], false, 5, 2, 0, 0);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[12]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_SPRITE, 4, 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -694,7 +695,7 @@ void Scene703::enter() {
 		_monsterMode = 0;
 		_scene->loadAnimation(formAnimName('A', -1));
 		_scene->_activeAnimation->setCurrentFrame(34);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._stepEnabled = false;
 		_boatDir = 1;
 		if (_globals[kMonsterAlive]) {
@@ -1218,7 +1219,7 @@ void Scene704::handleFillBottle(int quote) {
 void Scene704::enter() {
 	if (_game._objects[OBJ_BOTTLE]._roomNumber == _scene->_currentSceneId) {
 		_globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('b', 0));
-		_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 0, 0, 0);
+		_globals._sequenceIndexes[1] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[1], false, 6, 0, 0, 0);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1);
 		if (_scene->_priorSceneId == 705) {
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(123, 125));
@@ -1241,7 +1242,7 @@ void Scene704::enter() {
 		_boatDirection = 2;
 		_scene->loadAnimation(formAnimName('A', -1));
 		_scene->_activeAnimation->setCurrentFrame(36);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._stepEnabled = false;
 		_boatDirection = 1;
 		_scene->loadAnimation(formAnimName('A', -1));
@@ -1567,7 +1568,7 @@ void Scene705::enter() {
 		_globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 4);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._stepEnabled = false;
 		_scene->_sequences.addTimer(1, 80);
 		_vm->_sound->command(28);
@@ -1585,7 +1586,7 @@ void Scene705::enter() {
 void Scene705::step() {
 	switch (_game._trigger) {
 	case 70:
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 4);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71);
 		break;
@@ -1798,7 +1799,7 @@ void Scene706::handleTakeVase() {
 	case 0:
 		_game._player._stepEnabled = false;
 		_game._player._visible = false;
-		_globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 4, 2, 0, 0);
+		_globals._sequenceIndexes[3] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[3], false, 4, 2, 0, 0);
 		_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 7, 1);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -1854,7 +1855,7 @@ void Scene706::enter() {
 	if (_scene->_priorSceneId == 707) {
 		_game._player._playerPos = Common::Point(277, 103);
 		_game._player._facing = FACING_SOUTHWEST;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(167, 152);
 		_game._player._facing = FACING_NORTH;
 	}
@@ -2087,7 +2088,7 @@ void Scene710::enter() {
 
 	if (_game._objects[OBJ_VASE]._roomNumber == 706) {
 		_globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('g', -1));
-		_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 0, 0, 0);
+		_globals._sequenceIndexes[1] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[1], false, 6, 0, 0, 0);
 	}
 
 	_game._player._visible = false;
@@ -2213,7 +2214,7 @@ void Scene751::enter() {
 		_globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2);
 		_scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(155, 129));
 		_scene->_sequences.addTimer(15, 70);
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(22, 131);
 		_game._player._facing = FACING_EAST;
 		_game._player._stepEnabled = false;
@@ -2248,7 +2249,7 @@ void Scene751::step() {
 	switch (_game._trigger) {
 	case 70:
 		_scene->_sequences.remove(_globals._sequenceIndexes[4]);
-		_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 6, 1, 0, 0);
+		_globals._sequenceIndexes[4] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[4], false, 6, 1, 0, 0);
 		_scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(155, 129));
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 71);
 		break;
@@ -2287,7 +2288,7 @@ void Scene751::step() {
 
 	case 62:
 		_vm->_sound->command(17);
-		_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0);
+		_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0);
 		_scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136));
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 63);
@@ -2329,7 +2330,7 @@ void Scene751::preActions() {
 			_game._player._readyToWalk = false;
 			_game._player._stepEnabled = false;
 			_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 11, 1, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 11, 1, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -1, 7);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1);
 			break;
@@ -2398,7 +2399,7 @@ void Scene751::actions() {
 
 		case 3:
 			_vm->_sound->command(17);
-			_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0);
+			_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136));
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 4);
@@ -2527,7 +2528,7 @@ void Scene752::enter() {
 	if (_scene->_priorSceneId == 751) {
 		_game._player._playerPos = Common::Point(13, 145);
 		_game._player._facing = FACING_EAST;
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(289, 138);
 		_game._player.walk(Common::Point(262, 148), FACING_WEST);
 		_game._player._facing = FACING_WEST;
@@ -2597,7 +2598,7 @@ void Scene752::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 5, 2, 0, 0);
+			_globals._sequenceIndexes[12] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[12], false, 5, 2, 0, 0);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[12]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_SPRITE, 4, 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
@@ -2622,7 +2623,7 @@ void Scene752::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 5, 2, 0, 0);
+			_globals._sequenceIndexes[12] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[12], false, 5, 2, 0, 0);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[12]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_SPRITE, 4, 1);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 2);
diff --git a/engines/mads/nebular/nebular_scenes7.h b/engines/mads/nebular/nebular_scenes7.h
index dfb3c0f16e..b5aeba818c 100644
--- a/engines/mads/nebular/nebular_scenes7.h
+++ b/engines/mads/nebular/nebular_scenes7.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/nebular/nebular_scenes8.cpp b/engines/mads/nebular/nebular_scenes8.cpp
index 62a1a262b0..a904569624 100644
--- a/engines/mads/nebular/nebular_scenes8.cpp
+++ b/engines/mads/nebular/nebular_scenes8.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * 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.
@@ -121,7 +121,7 @@ void Scene801::enter() {
 		_game._player._playerPos = Common::Point(307, 111);
 		_game._player.walk(Common::Point(270, 118), FACING_WEST);
 		_game._player._visible = true;
-	} else if ((_scene->_priorSceneId != -2) && !_globals[kTeleporterCommand]) {
+	} else if ((_scene->_priorSceneId != RETURNING_FROM_DIALOG) && !_globals[kTeleporterCommand]) {
 		_game._player._playerPos = Common::Point(8, 117);
 		_game._player.walk(Common::Point(41, 115), FACING_EAST);
 		_game._player._visible = true;
@@ -145,10 +145,10 @@ void Scene801::enter() {
 		case 2:
 			_game._player._playerPos = Common::Point(8, 117);
 			_globals[kTeleporterUnderstood] = true;
-			_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 8, 1, 0, 0);
+			_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 8, 1, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 13);
 			_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
-			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 8090);
+			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 80);
 			_vm->_sound->command(30);
 			break;
 
@@ -283,7 +283,7 @@ void Scene801::actions() {
 		_globals[kBetweenRooms] = true;
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
 		_scene->_sequences.remove(_globals._sequenceIndexes[2]);
-		_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 4, 1, 0, 0);
+		_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 4, 1, 0, 0);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 90);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 5);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 13);
@@ -346,7 +346,7 @@ void Scene802::enter() {
 		_game._player._playerPos = Common::Point(303, 119);
 		_game._player._facing = FACING_WEST;
 
-	} else if (_scene->_priorSceneId != -2) {
+	} else if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 		_game._player._playerPos = Common::Point(15, 129);
 		_game._player._facing = FACING_EAST;
 	}
@@ -419,7 +419,7 @@ void Scene802::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], true, 7, 2, 0, 0);
+			_globals._sequenceIndexes[2] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[2], true, 7, 2, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 2, 1);
@@ -451,7 +451,7 @@ void Scene802::actions() {
 		case 0:
 			_game._player._stepEnabled = false;
 			_game._player._visible = false;
-			_globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], true, 7, 2, 0, 0);
+			_globals._sequenceIndexes[5] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[5], true, 7, 2, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 4);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_SPRITE, 4, 1);
@@ -557,7 +557,7 @@ void Scene803::enter() {
 
 	if (!_globals[kFromCockpit]) {
 		if (!_globals[kReturnFromCut]) {
-			if (_scene->_priorSceneId != -2) {
+			if (_scene->_priorSceneId != RETURNING_FROM_DIALOG) {
 				_game._player._playerPos = Common::Point(15, 130);
 				_game._player._facing = FACING_EAST;
 			}
@@ -692,7 +692,7 @@ void Scene803::step() {
 
 	if (_game._trigger == 90) {
 		int syncIdx = _globals._sequenceIndexes[4];
-		_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 15, 0, 0, 0);
+		_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 15, 0, 0, 0);
 		_scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 4, 9);
 		if (_globals[kHoppyDead])
@@ -719,14 +719,14 @@ void Scene803::step() {
 			else
 				_game._winStatus = 3;
 
-			_vm->quitGame();
+			return;
 		}
 	}
 
 	if (_game._trigger == 150) {
 		_scene->_sequences.remove(_globals._sequenceIndexes[6]);
 		_vm->_sound->command(18);
-		_globals._sequenceIndexes[6] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[6], false, 8, 1, 0, 0);
+		_globals._sequenceIndexes[6] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[6], false, 8, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 1, 19);
 		_scene->_sequences.setDepth(_globals._sequenceIndexes[6], 4);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 151);
@@ -778,7 +778,7 @@ void Scene803::actions() {
 
 		case 162:
 			_scene->_sequences.remove(_globals._sequenceIndexes[9]);
-			_globals._sequenceIndexes[9] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[9], true, 6, 1, 0, 0);
+			_globals._sequenceIndexes[9] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[9], true, 6, 1, 0, 0);
 			_scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], 1, 4);
 			_scene->_sequences.setMsgLayout(_globals._sequenceIndexes[9]);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 163);
@@ -899,15 +899,17 @@ void Scene804::enter() {
 			_scene->_sequences.addTimer(60, 100);
 		} else {
 			_globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 1);
-			_globals._sequenceIndexes[7] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[7], false, 4, 0, 0, 0);
+			_globals._sequenceIndexes[7] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[7], false, 4, 0, 0, 0);
 			_scene->_sequences.addTimer(160, 70);
 			_game._player._stepEnabled = false;
 		}
 	} else {
-		if (_globals[kBeamIsUp] == 0)
+		if (_globals[kBeamIsUp]) {
 			_globals._sequenceIndexes[8] = _scene->_sequences.startCycle(_globals._spriteIndexes[8], false, 1);
+			_scene->_sequences.setDepth(_globals._sequenceIndexes[8], 7);
+		}
 
-		if (_globals[kWindowFixed] == 0)
+		if (_globals[kWindowFixed])
 			_globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1);
 
 		_globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1);
@@ -955,9 +957,9 @@ void Scene804::step() {
 				_globals[kInSpace] = false;
 				_globals[kBeamIsUp] = true;
 
-				assert(!_globals[kCopyProtectFailed]);
+				//assert(!_globals[kCopyProtectFailed]);
 				_game._winStatus = 4;
-				_vm->quitGame();
+				return;
 			}
 			break;
 
@@ -969,7 +971,7 @@ void Scene804::step() {
 
 				assert(!_globals[kCopyProtectFailed]);
 				_game._winStatus = 4;
-				_vm->quitGame();
+				return;
 			}
 		}
 
@@ -1129,8 +1131,7 @@ void Scene804::actions() {
 		} else {
 			_messWithThrottle = true;
 		}
-	}
-	else if (_action.isAction(VERB_APPLY, NOUN_POLYCEMENT, NOUN_CRACK) ||
+	} else if (_action.isAction(VERB_APPLY, NOUN_POLYCEMENT, NOUN_CRACK) ||
 		_action.isAction(VERB_PUT, NOUN_POLYCEMENT, NOUN_CRACK)) {
 		if (!_globals[kWindowFixed]) {
 			_resetFrame = 2;
@@ -1219,6 +1220,8 @@ void Scene805::enter() {
 }
 
 void Scene805::step() {
+	UserInterface &userInterface = _vm->_game->_scene._userInterface;
+
 	if (_game._trigger == 70) {
 		_scene->_hotspots.activate(OBJ_SHIELD_MODULATOR, false);
 		_globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 25);
@@ -1226,6 +1229,7 @@ void Scene805::step() {
 		_scene->_dynamicHotspots.setPosition(idx, Common::Point(0, 0), FACING_DUMMY);
 		_globals[kShieldModInstalled] = true;
 		_game._objects.setRoom(OBJ_SHIELD_MODULATOR, NOWHERE);
+		userInterface._selectedInvIndex = -1;
 		_game._player._stepEnabled = true;
 		_vm->_sound->command(24);
 	}
@@ -1237,6 +1241,7 @@ void Scene805::step() {
 		_scene->_dynamicHotspots.setPosition(idx, Common::Point(0, 0), FACING_DUMMY);
 		_globals[kTargetModInstalled] = true;
 		_game._objects.setRoom(OBJ_TARGET_MODULE, NOWHERE);
+		userInterface._selectedInvIndex = -1;
 		_game._player._stepEnabled = true;
 		_vm->_sound->command(24);
 	}
@@ -1278,14 +1283,14 @@ void Scene805::actions() {
 	} else if (_action.isAction(VERB_REMOVE, NOUN_SHIELD_MODULATOR) && _globals[kShieldModInstalled]) {
 		_scene->_sequences.remove(_globals._sequenceIndexes[1]);
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
-		_globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 7, 1, 0, 0);
+		_globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 7, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], -1, -2);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 71);
 		_game._player._stepEnabled = false;
 	} else if (_action.isAction(VERB_REMOVE, NOUN_TARGET_MODULE) && _globals[kTargetModInstalled]) {
 		_scene->_sequences.remove(_globals._sequenceIndexes[2]);
 		_game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON;
-		_globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0);
+		_globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0);
 		_scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -1, -2);
 		_scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 81);
 		_game._player._stepEnabled = false;
@@ -1434,7 +1439,7 @@ void Scene808::actions() {
 				_vm->_sound->command(20);
 				_vm->_sound->command(25);
 			}
-			_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0);
+			_globals._sequenceIndexes[4] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(248, 211));
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 71);
@@ -1469,7 +1474,7 @@ void Scene808::actions() {
 				_vm->_sound->command(20);
 			}
 			_globals[kTopButtonPushed] = false;
-			_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0);
+			_globals._sequenceIndexes[4] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(248, 186));
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 91);
@@ -1500,7 +1505,7 @@ void Scene808::actions() {
 				_vm->_sound->command(20);
 			 }
 			_globals[kTopButtonPushed] = true;
-			_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0);
+			_globals._sequenceIndexes[4] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(248, 163));
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 81);
@@ -1517,7 +1522,7 @@ void Scene808::actions() {
 		switch (_game._trigger) {
 		case 0:
 			_game._player._stepEnabled = false;
-			_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 2, 0, 0);
+			_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 4, 2, 0, 0);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(168, 211));
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 70);
@@ -1534,7 +1539,7 @@ void Scene808::actions() {
 		switch (_game._trigger) {
 		case 0:
 			_game._player._stepEnabled = false;
-			_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 2, 0, 0);
+			_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 4, 2, 0, 0);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(172, 163));
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 80);
@@ -1551,7 +1556,7 @@ void Scene808::actions() {
 		switch (_game._trigger) {
 		case 0:
 			_game._player._stepEnabled = false;
-			_globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 2, 0, 0);
+			_globals._sequenceIndexes[4] = _scene->_sequences.startPingPongCycle(_globals._spriteIndexes[4], false, 4, 2, 0, 0);
 			_scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(172, 186));
 			_scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2);
 			_scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 90);
@@ -1601,7 +1606,8 @@ void Scene810::enter() {
 }
 
 void Scene810::step() {
-	if ((_scene->_activeAnimation->getCurrentFrame() == 200) && _moveAllowed) {
+	if (_scene->_activeAnimation && (_scene->_activeAnimation->getCurrentFrame() == 200) 
+			&& _moveAllowed) {
 		_scene->_sequences.addTimer(100, 70);
 		_moveAllowed = false;
 	}
diff --git a/engines/mads/nebular/nebular_scenes8.h b/engines/mads/nebular/nebular_scenes8.h
index 7f2c34a843..439815f05c 100644
--- a/engines/mads/nebular/nebular_scenes8.h
+++ b/engines/mads/nebular/nebular_scenes8.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/nebular/sound_nebular.cpp b/engines/mads/nebular/sound_nebular.cpp
index 0a054440b2..ab6bd8215c 100644
--- a/engines/mads/nebular/sound_nebular.cpp
+++ b/engines/mads/nebular/sound_nebular.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -21,6 +21,7 @@
  */
 
 #include "audio/audiostream.h"
+#include "audio/fmopl.h"
 #include "audio/decoders/raw.h"
 #include "common/algorithm.h"
 #include "common/debug.h"
@@ -36,6 +37,7 @@ namespace Nebular {
 bool AdlibChannel::_channelsEnabled;
 
 AdlibChannel::AdlibChannel() {
+	_owner = nullptr;
 	_activeCount = 0;
 	_field1 = 0;
 	_field2 = 0;
@@ -43,6 +45,7 @@ AdlibChannel::AdlibChannel() {
 	_field4 = 0;
 	_sampleIndex = 0;
 	_volume = 0;
+	_volumeOffset = 0;
 	_field7 = 0;
 	_field8 = 0;
 	_field9 = 0;
@@ -55,11 +58,11 @@ AdlibChannel::AdlibChannel() {
 	_pSrc = nullptr;
 	_ptr3 = nullptr;
 	_ptr4 = nullptr;
+	_ptrEnd = nullptr;
 	_field17 = 0;
 	_field19 = 0;
 	_soundData = nullptr;
 	_field1D = 0;
-	_field1E = 0;
 	_field1F = 0;
 
 	_field20 = 0;
@@ -95,6 +98,7 @@ void AdlibChannel::setPtr2(byte *pData) {
 void AdlibChannel::load(byte *pData) {
 	_ptr1 = _pSrc = _ptr3 = pData;
 	_ptr4 = _soundData = pData;
+	_volumeOffset = 0;
 	_fieldA = 0xFF;
 	_activeCount = 1;
 	_fieldD = 64;
@@ -102,17 +106,20 @@ void AdlibChannel::load(byte *pData) {
 	_field1F = 0;
 	_field2 = _field3 = 0;
 	_volume = _field7 = 0;
-	_field1D = _field1E = 0;
+	_field1D = 0;
 	_fieldE = 0;
 	_field9 = 0;
 	_fieldB = 0;
 	_field17 = 0;
 	_field19 = 0;
+
+	CachedDataEntry &cacheEntry = _owner->getCachedData(pData);
+	_ptrEnd = cacheEntry._dataEnd;
 }
 
 void AdlibChannel::check(byte *nullPtr) {
 	if (_activeCount && _fieldE) {
-		if (!_field1E) {
+		if (!_volumeOffset) {
 			_pSrc = nullPtr;
 			_fieldE = 0;
 		} else {
@@ -150,7 +157,7 @@ AdlibSample::AdlibSample(Common::SeekableReadStream &s) {
 
 /*-----------------------------------------------------------------------*/
 
-ASound::ASound(Audio::Mixer *mixer, FM_OPL *opl, const Common::String &filename, int dataOffset) {
+ASound::ASound(Audio::Mixer *mixer, OPL::OPL *opl, const Common::String &filename, int dataOffset) {
 	// Open up the appropriate sound file
 	if (!_soundFile.open(filename))
 		error("Could not open file - %s", filename.c_str());
@@ -161,6 +168,7 @@ ASound::ASound(Audio::Mixer *mixer, FM_OPL *opl, const Common::String &filename,
 	_samplePtr = nullptr;
 	_frameCounter = 0;
 	_isDisabled = false;
+	_masterVolume = 255;
 	_v1 = 0;
 	_v2 = 0;
 	_activeChannelNumber = 0;
@@ -181,17 +189,15 @@ ASound::ASound(Audio::Mixer *mixer, FM_OPL *opl, const Common::String &filename,
 	_randomSeed = 1234;
 	_amDep = _vibDep = _splitPoint = true;
 
-	_samplesTillCallback = 0;
-	_samplesTillCallbackRemainder = 0;
-	_samplesPerCallback = getRate() / CALLBACKS_PER_SECOND;
-	_samplesPerCallbackRemainder = getRate() % CALLBACKS_PER_SECOND;
-
 	for (int i = 0; i < 11; ++i) {
 		_channelData[i]._field0 = 0;
 		_channelData[i]._freqMask = 0;
 		_channelData[i]._freqBase = 0;
 		_channelData[i]._field6 = 0;
 	}
+	
+	for (int i = 0; i < ADLIB_CHANNEL_COUNT; ++i)
+		_channels[i]._owner = this;
 
 	AdlibChannel::_channelsEnabled = false;
 
@@ -200,23 +206,21 @@ ASound::ASound(Audio::Mixer *mixer, FM_OPL *opl, const Common::String &filename,
 	_mixer = mixer;
 	_opl = opl;
 
-	_opl->init(getRate());
-	_mixer->playStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1,
-		Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
-
 	// Initialize the Adlib
 	adlibInit();
 
 	// Reset the adlib
 	command0();
+
+	_opl->start(new Common::Functor0Mem<void, ASound>(this, &ASound::onTimer), CALLBACKS_PER_SECOND);
 }
 
 ASound::~ASound() {
+	_opl->stop();
+
 	Common::List<CachedDataEntry>::iterator i;
 	for (i = _dataCache.begin(); i != _dataCache.end(); ++i)
 		delete[] (*i)._data;
-
-	_mixer->stopHandle(_soundHandle);
 }
 
 void ASound::validate() {
@@ -283,6 +287,17 @@ void ASound::noise() {
 	}
 }
 
+CachedDataEntry &ASound::getCachedData(byte *pData) {
+	Common::List<CachedDataEntry>::iterator i;
+	for (i = _dataCache.begin(); i != _dataCache.end(); ++i) {
+		CachedDataEntry &e = *i;
+		if (e._data == pData)
+			return e;
+	}
+
+	error("Could not find previously loaded data");
+}
+
 void ASound::write(int reg, int val) {
 	_queue.push(RegisterValue(reg, val));
 }
@@ -331,6 +346,7 @@ byte *ASound::loadData(int offset, int size) {
 	CachedDataEntry rec;
 	rec._offset = offset;
 	rec._data = new byte[size];
+	rec._dataEnd = rec._data + size - 1;
 	_soundFile.seek(_dataOffset + offset);
 	_soundFile.read(rec._data, size);
 	_dataCache.push_back(rec);
@@ -449,6 +465,10 @@ void ASound::pollActiveChannel() {
 					warning("pollActiveChannel(): No data found for sound channel");
 					break;
 				}
+				if (pSrc > chan->_ptrEnd) {
+					warning("Read beyond end of loaded sound data");
+				}
+
 				if (!(*pSrc & 0x80) || (*pSrc <= 0xF0)) {
 					if (updateFlag)
 						updateActiveChannel();
@@ -516,7 +536,7 @@ void ASound::pollActiveChannel() {
 						chan->_field1 = 0;
 						chan->_field2 = chan->_field3 = 0;
 						chan->_volume = chan->_field7 = 0;
-						chan->_field1D = chan->_field1E = 0;
+						chan->_field1D = chan->_volumeOffset = 0;
 						chan->_field8 = 0;
 						chan->_field9 = 0;
 						chan->_fieldB = 0;
@@ -570,7 +590,7 @@ void ASound::pollActiveChannel() {
 						break;
 
 					case 8:
-						chan->_field1D = *++pSrc;
+						chan->_field1D = (int8)*++pSrc;
 						chan->_pSrc += 2;
 						break;
 
@@ -591,7 +611,7 @@ void ASound::pollActiveChannel() {
 						if (chan->_fieldE) {
 							chan->_pSrc += 2;
 						} else {
-							chan->_field1E = *pSrc >> 1;
+							chan->_volumeOffset = *pSrc >> 1;
 							updateFlag = true;
 							chan->_pSrc += 2;
 						}
@@ -635,7 +655,7 @@ void ASound::pollActiveChannel() {
 			if (!--chan->_field9) {
 				chan->_field9 = chan->_fieldA;
 				if (chan->_field2) {
-					int8 newVal = (int8)chan->_field2 + (int8)chan->_field1E;
+					int8 newVal = (int8)chan->_field2 + (int8)chan->_volumeOffset;
 					if (newVal < 0) {
 						chan->_field9 = 0;
 						newVal = 0;
@@ -644,7 +664,7 @@ void ASound::pollActiveChannel() {
 						newVal = 63;
 					}
 
-					chan->_field1E = newVal;
+					chan->_volumeOffset = newVal;
 					updateFlag = true;
 				}
 			}
@@ -709,8 +729,8 @@ void ASound::updateChannelState() {
 		resultCheck();
 	} else {
 		int reg = 0xA0 + _activeChannelNumber;
-		int vTimes = (_activeChannelPtr->_field4 + _activeChannelPtr->_field1F) / 12;
-		int vOffset = (_activeChannelPtr->_field4 + _activeChannelPtr->_field1F) % 12;
+		int vTimes = (byte)(_activeChannelPtr->_field4 + _activeChannelPtr->_field1F) / 12;
+		int vOffset = (byte)(_activeChannelPtr->_field4 + _activeChannelPtr->_field1F) % 12;
 		int val = _vList1[vOffset] + _activeChannelPtr->_field1D;
 		write2(8, reg, val & 0xFF);
 
@@ -727,32 +747,18 @@ static const int outputIndexes[] = {
 static const int outputChannels[] = {
 	0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 16, 17, 18, 19, 20, 21, 0
 };
-static const int volumeList[] = {
-	0x3F, 0x3F, 0x36, 0x31, 0x2D, 0x2A, 0x28, 0x26, 0x24, 0x22, 0x21, 0x20, 0x1F, 0x1E, 0x1D, 0x1C,
-	0x1B, 0x1A, 0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x13, 0x12, 0x12,
-	0x11, 0x11, 0x10, 0x10, 0x0F, 0x0F, 0x0E, 0x0E, 0x0D, 0x0D, 0x0C, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A,
-	0x0A, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07,
-	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04,
-	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01,
-	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
 
 void ASound::updateActiveChannel() {
 	int reg = 0x40 + outputChannels[outputIndexes[_activeChannelNumber * 2 + 1]];
 	int portVal = _ports[reg] & 0xFFC0;
-	int newVolume = CLIP(_activeChannelPtr->_volume + _activeChannelPtr->_field1E, 0, 63);
+	int newVolume = CLIP(_activeChannelPtr->_volume + _activeChannelPtr->_volumeOffset, 0, 63);
+	newVolume = newVolume * _masterVolume / 255;
 
 	// Note: Original had a whole block not seeming to be used, since the initialisation
 	// sets a variable to 5660h, and doesn't change it, so the branch is never taken
-	int val = CLIP(newVolume - volumeList[_activeChannelPtr->_fieldD], 0, 63);
-	val = (63 - val) | portVal;
+	portVal |= 63 - newVolume;
 
-	int val2 = CLIP(newVolume - volumeList[-(_activeChannelPtr->_fieldD - 127)], 0, 63);
-	val2 = (63 - val2) | portVal;
-	write2(0, reg, val);
-	write2(2, reg, val2);
+	write2(8, reg, portVal);
 }
 
 void ASound::loadSample(int sampleIndex) {
@@ -820,32 +826,16 @@ void ASound::updateFNumber() {
 	write2(8, hiReg, val2);
 }
 
-int ASound::readBuffer(int16 *buffer, const int numSamples) {
+void ASound::onTimer() {
 	Common::StackLock slock(_driverMutex);
+	poll();
+	flush();
+}
 
-	int32 samplesLeft = numSamples;
-	memset(buffer, 0, sizeof(int16) * numSamples);
-	while (samplesLeft) {
-		if (!_samplesTillCallback) {
-			poll();
-			flush();
-
-			_samplesTillCallback = _samplesPerCallback;
-			_samplesTillCallbackRemainder += _samplesPerCallbackRemainder;
-			if (_samplesTillCallbackRemainder >= CALLBACKS_PER_SECOND) {
-				_samplesTillCallback++;
-				_samplesTillCallbackRemainder -= CALLBACKS_PER_SECOND;
-			}
-		}
-
-		int32 render = MIN<int>(samplesLeft, _samplesTillCallback);
-		samplesLeft -= render;
-		_samplesTillCallback -= render;
-
-		_opl->readBuffer(buffer, render);
-		buffer += render;
-	}
-	return numSamples;
+void ASound::setVolume(int volume) {
+	_masterVolume = volume;
+	if (!volume)
+		command0();
 }
 
 int ASound::command0() {
@@ -966,7 +956,7 @@ const ASound1::CommandPtr ASound1::_commandList[42] = {
 	&ASound1::command40, &ASound1::command41
 };
 
-ASound1::ASound1(Audio::Mixer *mixer, FM_OPL *opl)
+ASound1::ASound1(Audio::Mixer *mixer, OPL::OPL *opl)
 	: ASound(mixer, opl, "asound.001", 0x1520) {
 	_cmd23Toggle = false;
 
@@ -1005,22 +995,22 @@ int ASound1::command10() {
 
 int ASound1::command11() {
 	command111213();
-	_channels[0]._field1E = 0;
-	_channels[1]._field1E = 0;
+	_channels[0]._volumeOffset = 0;
+	_channels[1]._volumeOffset = 0;
 	return 0;
 }
 
 int ASound1::command12() {
 	command111213();
-	_channels[0]._field1E = 40;
-	_channels[1]._field1E = 0;
+	_channels[0]._volumeOffset = 40;
+	_channels[1]._volumeOffset = 0;
 	return 0;
 }
 
 int ASound1::command13() {
 	command111213();
-	_channels[0]._field1E = 40;
-	_channels[1]._field1E = 50;
+	_channels[0]._volumeOffset = 40;
+	_channels[1]._volumeOffset = 50;
 	return 0;
 }
 
@@ -1267,7 +1257,7 @@ const ASound2::CommandPtr ASound2::_commandList[44] = {
 	&ASound2::command40, &ASound2::command41, &ASound2::command42, &ASound2::command43
 };
 
-ASound2::ASound2(Audio::Mixer *mixer, FM_OPL *opl) : ASound(mixer, opl, "asound.002", 0x15E0) {
+ASound2::ASound2(Audio::Mixer *mixer, OPL::OPL *opl) : ASound(mixer, opl, "asound.002", 0x15E0) {
 	_command12Param = 0xFD;
 
 	// Load sound samples
@@ -1638,7 +1628,7 @@ const ASound3::CommandPtr ASound3::_commandList[61] = {
 	&ASound3::command60
 };
 
-ASound3::ASound3(Audio::Mixer *mixer, FM_OPL *opl) : ASound(mixer, opl, "asound.003", 0x15B0) {
+ASound3::ASound3(Audio::Mixer *mixer, OPL::OPL *opl) : ASound(mixer, opl, "asound.003", 0x15B0) {
 	_command39Flag = false;
 
 	// Load sound samples
@@ -2042,7 +2032,7 @@ const ASound4::CommandPtr ASound4::_commandList[61] = {
 	&ASound4::command60
 };
 
-ASound4::ASound4(Audio::Mixer *mixer, FM_OPL *opl) : ASound(mixer, opl, "asound.004", 0x14F0) {
+ASound4::ASound4(Audio::Mixer *mixer, OPL::OPL *opl) : ASound(mixer, opl, "asound.004", 0x14F0) {
 	// Load sound samples
 	_soundFile.seek(_dataOffset + 0x122);
 	for (int i = 0; i < 210; ++i)
@@ -2298,7 +2288,7 @@ const ASound5::CommandPtr ASound5::_commandList[42] = {
 	&ASound5::command40, &ASound5::command41
 };
 
-ASound5::ASound5(Audio::Mixer *mixer, FM_OPL *opl) : ASound(mixer, opl, "asound.002", 0x15E0) {
+ASound5::ASound5(Audio::Mixer *mixer, OPL::OPL *opl) : ASound(mixer, opl, "asound.002", 0x15E0) {
 	// Load sound samples
 	_soundFile.seek(_dataOffset + 0x144);
 	for (int i = 0; i < 164; ++i)
@@ -2539,7 +2529,7 @@ const ASound6::CommandPtr ASound6::_commandList[30] = {
 	&ASound6::nullCommand, &ASound6::command29
 };
 
-ASound6::ASound6(Audio::Mixer *mixer, FM_OPL *opl) : ASound(mixer, opl, "asound.006", 0x1390) {
+ASound6::ASound6(Audio::Mixer *mixer, OPL::OPL *opl) : ASound(mixer, opl, "asound.006", 0x1390) {
 	// Load sound samples
 	_soundFile.seek(_dataOffset + 0x122);
 	for (int i = 0; i < 200; ++i)
@@ -2695,7 +2685,7 @@ const ASound7::CommandPtr ASound7::_commandList[38] = {
 	&ASound7::command36, &ASound7::command37
 };
 
-ASound7::ASound7(Audio::Mixer *mixer, FM_OPL *opl) : ASound(mixer, opl, "asound.007", 0x1460) {
+ASound7::ASound7(Audio::Mixer *mixer, OPL::OPL *opl) : ASound(mixer, opl, "asound.007", 0x1460) {
 	// Load sound samples
 	_soundFile.seek(_dataOffset + 0x122);
 	for (int i = 0; i < 214; ++i)
@@ -2901,7 +2891,7 @@ const ASound8::CommandPtr ASound8::_commandList[38] = {
 	&ASound8::command36, &ASound8::command37
 };
 
-ASound8::ASound8(Audio::Mixer *mixer, FM_OPL *opl) : ASound(mixer, opl, "asound.008", 0x1490) {
+ASound8::ASound8(Audio::Mixer *mixer, OPL::OPL *opl) : ASound(mixer, opl, "asound.008", 0x1490) {
 	// Load sound samples
 	_soundFile.seek(_dataOffset + 0x122);
 	for (int i = 0; i < 174; ++i)
@@ -3157,7 +3147,7 @@ const ASound9::CommandPtr ASound9::_commandList[52] = {
 	&ASound9::command48, &ASound9::command49, &ASound9::command50, &ASound9::command51
 };
 
-ASound9::ASound9(Audio::Mixer *mixer, FM_OPL *opl) : ASound(mixer, opl, "asound.009", 0x16F0) {
+ASound9::ASound9(Audio::Mixer *mixer, OPL::OPL *opl) : ASound(mixer, opl, "asound.009", 0x16F0) {
 	_v1 = _v2 = 0;
 	_soundPtr = nullptr;
 
diff --git a/engines/mads/nebular/sound_nebular.h b/engines/mads/nebular/sound_nebular.h
index ccfd40ad52..2b80b08d89 100644
--- a/engines/mads/nebular/sound_nebular.h
+++ b/engines/mads/nebular/sound_nebular.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -28,20 +28,27 @@
 #include "common/mutex.h"
 #include "common/queue.h"
 #include "audio/audiostream.h"
-#include "audio/fmopl.h"
 #include "audio/mixer.h"
 
+namespace OPL {
+class OPL;
+}
+
 namespace MADS {
 
 class SoundManager;
 
 namespace Nebular {
 
+class ASound;
+
 /**
  * Represents the data for a channel on the Adlib
  */
 class AdlibChannel {
 public:
+	ASound *_owner;
+
 	int _activeCount;
 	int _field1;
 	int _field2;
@@ -61,11 +68,12 @@ public:
 	byte *_pSrc;
 	byte *_ptr3;
 	byte *_ptr4;
+	byte *_ptrEnd;
 	int _field17;
 	int _field19;
 	byte *_soundData;
 	int _field1D;
-	int _field1E;
+	int _volumeOffset;
 	int _field1F;
 
 	// TODO: Only used by asound.003. Figure out usage
@@ -128,17 +136,20 @@ struct RegisterValue {
 #define ADLIB_CHANNEL_MIDWAY 5
 #define CALLBACKS_PER_SECOND 60
 
+struct CachedDataEntry {
+	int _offset;
+	byte *_data;
+	byte *_dataEnd;
+};
+
 /**
  * Base class for the sound player resource files
  */
-class ASound : public Audio::AudioStream {
+class ASound {
 private:
-	struct CachedDataEntry {
-		int _offset;
-		byte *_data;
-	};
 	Common::List<CachedDataEntry> _dataCache;
 	uint16 _randomSeed;
+	int _masterVolume;
 
 	/**
 	 * Does the initial Adlib initialisation
@@ -184,6 +195,11 @@ private:
 	void processSample();
 
 	void updateFNumber();
+
+	/**
+	 * Timer function for OPL
+	 */
+	void onTimer();
 protected:
 	int _commandParam;
 
@@ -265,8 +281,7 @@ protected:
 	int nullCommand() { return 0; }
 public:
 	Audio::Mixer *_mixer;
-	FM_OPL *_opl;
-	Audio::SoundHandle _soundHandle;
+	OPL::OPL *_opl;
 	AdlibChannel _channels[ADLIB_CHANNEL_COUNT];
 	AdlibChannel *_activeChannelPtr;
 	AdlibChannelData _channelData[11];
@@ -298,10 +313,6 @@ public:
 	int _activeChannelReg;
 	int _v11;
 	bool _amDep, _vibDep, _splitPoint;
-	int _samplesPerCallback;
-	int _samplesPerCallbackRemainder;
-	int _samplesTillCallback;
-	int _samplesTillCallbackRemainder;
 public:
 	/**
 	 * Constructor
@@ -310,7 +321,7 @@ public:
 	 * @param filename		Specifies the adlib sound player file to use
 	 * @param dataOffset	Offset in the file of the data segment
 	 */
-	ASound(Audio::Mixer *mixer, FM_OPL *opl, const Common::String &filename, int dataOffset);
+	ASound(Audio::Mixer *mixer, OPL::OPL *opl, const Common::String &filename, int dataOffset);
 
 	/**
 	 * Destructor
@@ -350,26 +361,15 @@ public:
 	 */
 	int getFrameCounter() { return _frameCounter; }
 
-	// AudioStream interface
-	/**
-	 * Main buffer read
-	 */
-	virtual int readBuffer(int16 *buffer, const int numSamples);
-
-	/**
-	 * Mono sound only
-	 */
-	virtual bool isStereo() const { return false; }
-
 	/**
-	 * Data is continuously pushed, so definitive end
+	 * Return the cached data block record for previously loaded sound data
 	 */
-	virtual bool endOfData() const { return false; }
+	CachedDataEntry &getCachedData(byte *pData);
 
 	/**
-	 * Return sample rate
+	 * Set the volume
 	 */
-	virtual int getRate() const { return 11025; }
+	void setVolume(int volume);
 };
 
 class ASound1 : public ASound {
@@ -415,7 +415,7 @@ private:
 	void command111213();
 	int command2627293032();
 public:
-	ASound1(Audio::Mixer *mixer, FM_OPL *opl);
+	ASound1(Audio::Mixer *mixer, OPL::OPL *opl);
 
 	virtual int command(int commandId, int param);
 };
@@ -467,7 +467,7 @@ private:
 	void command9Randomize();
 	void command9Apply(byte *data, int val, int incr);
 public:
-	ASound2(Audio::Mixer *mixer, FM_OPL *opl);
+	ASound2(Audio::Mixer *mixer, OPL::OPL *opl);
 
 	virtual int command(int commandId, int param);
 };
@@ -527,7 +527,7 @@ private:
 	void command9Randomize();
 	void command9Apply(byte *data, int val, int incr);
 public:
-	ASound3(Audio::Mixer *mixer, FM_OPL *opl);
+	ASound3(Audio::Mixer *mixer, OPL::OPL *opl);
 
 	virtual int command(int commandId, int param);
 };
@@ -565,7 +565,7 @@ private:
 
 	void method1();
 public:
-	ASound4(Audio::Mixer *mixer, FM_OPL *opl);
+	ASound4(Audio::Mixer *mixer, OPL::OPL *opl);
 
 	virtual int command(int commandId, int param);
 };
@@ -611,7 +611,7 @@ private:
 	int command42();
 	int command43();
 public:
-	ASound5(Audio::Mixer *mixer, FM_OPL *opl);
+	ASound5(Audio::Mixer *mixer, OPL::OPL *opl);
 
 	virtual int command(int commandId, int param);
 };
@@ -640,7 +640,7 @@ private:
 	int command25();
 	int command29();
 public:
-	ASound6(Audio::Mixer *mixer, FM_OPL *opl);
+	ASound6(Audio::Mixer *mixer, OPL::OPL *opl);
 
 	virtual int command(int commandId, int param);
 };
@@ -672,7 +672,7 @@ private:
 	int command36();
 	int command37();
 public:
-	ASound7(Audio::Mixer *mixer, FM_OPL *opl);
+	ASound7(Audio::Mixer *mixer, OPL::OPL *opl);
 
 	virtual int command(int commandId, int param);
 };
@@ -715,7 +715,7 @@ private:
 	void method1(byte *pData);
 	void adjustRange(byte *pData, byte v, int incr);
 public:
-	ASound8(Audio::Mixer *mixer, FM_OPL *opl);
+	ASound8(Audio::Mixer *mixer, OPL::OPL *opl);
 
 	virtual int command(int commandId, int param);
 };
@@ -774,7 +774,7 @@ private:
 	int command59();
 	int command60();
 public:
-	ASound9(Audio::Mixer *mixer, FM_OPL *opl);
+	ASound9(Audio::Mixer *mixer, OPL::OPL *opl);
 
 	virtual int command(int commandId, int param);
 };
diff --git a/engines/mads/palette.cpp b/engines/mads/palette.cpp
index 836d04f7c0..7651fe8e65 100644
--- a/engines/mads/palette.cpp
+++ b/engines/mads/palette.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -178,31 +178,29 @@ int PaletteUsage::process(Common::Array<RGB6> &palette, uint flags) {
 		}
 
 		if (!changed && !noUsageFlag) {
-			int var2 = (palette[palIndex]._flags & 0x20) ||
-				(((flags & 0x2000) || (palette[palIndex]._flags & 0x4000)) &&
+			int bestHash = (palette[palIndex]._flags & 0x20) ||
+				(((flags & 0x2000) || (palette[palIndex]._flags & 0x40)) &&
 				((flags & 0x1000) || (palCount == 0))) ? 0x7fff : 1;
 			int var36 = (palette[palIndex]._flags & 0x80) ? 0 : 2;
 
 			for (int idx = palLow; idx < palIdx; ++idx) {
 				uint32 v = _vm->_palette->_palFlags[idx];
 				if ((v & var3A) && !(v & var36)) {
-					int var10;
-
-					if (var2 > 1) {
-						var10 = rgbFactor(&_vm->_palette->_mainPalette[idx * 3], palette[palIndex]);
-					}
-					else if (_vm->_palette->_mainPalette[idx * 3] != palette[palIndex].r ||
+					int hash;
+					if (bestHash > 1) {
+						hash = rgbFactor(&_vm->_palette->_mainPalette[idx * 3], palette[palIndex]);
+					} else if (_vm->_palette->_mainPalette[idx * 3] != palette[palIndex].r ||
 							_vm->_palette->_mainPalette[idx * 3 + 1] != palette[palIndex].g ||
 							_vm->_palette->_mainPalette[idx * 3 + 2] != palette[palIndex].b) {
-						var10 = 1;
+						hash = 1;
 					} else {
-						var10 = 0;
+						hash = 0;
 					}
 
-					if (var2 > var10) {
+					if (bestHash > hash) {
 						changed = true;
 						newPalIndex = idx;
-						var2 = var10;
+						bestHash = hash;
 					}
 				}
 			}
@@ -430,6 +428,14 @@ void Fader::grabPalette(byte *colors, uint start, uint num) {
 	g_system->getPaletteManager()->grabPalette(colors, start, num);
 }
 
+void Fader::getFullPalette(byte palette[PALETTE_SIZE]) {
+	grabPalette(&palette[0], 0, PALETTE_COUNT);
+}
+
+void Fader::setFullPalette(byte palette[PALETTE_SIZE]) {
+	setPalette(&palette[0], 0, PALETTE_COUNT);
+}
+
 void Fader::fadeOut(byte palette[PALETTE_SIZE], byte *paletteMap,
 		int baseColor, int numColors, int baseGrey, int numGreys,
 		int tickDelay, int steps) {
@@ -491,7 +497,7 @@ void Fader::fadeIn(byte palette[PALETTE_SIZE], byte destPalette[PALETTE_SIZE],
 	int baseColor, int numColors, int baseGrey, int numGreys,
 	int tickDelay, int steps) {
 	GreyEntry map[PALETTE_COUNT];
-	byte tempPal[PALETTE_SIZE];;
+	byte tempPal[PALETTE_SIZE];
 	int8 signs[PALETTE_COUNT][3];
 	byte palIndex[PALETTE_COUNT][3];
 	int intensity;
@@ -505,16 +511,12 @@ void Fader::fadeIn(byte palette[PALETTE_SIZE], byte destPalette[PALETTE_SIZE],
 		for (int colorCtr = 0; colorCtr < 3; ++colorCtr) {
 			if (_colorFlags[colorCtr]) {
 				int shiftSign = _colorValues[colorCtr];
-				if (shiftSign >= 0) {
+				if (shiftSign >= 0)
 					intensity = map[index]._intensity << shiftSign;
-				}
-				else {
+				else
 					intensity = map[index]._intensity >> abs(shiftSign);
-				}
-			}
-			else {
+			} else
 				intensity = _colorValues[colorCtr];
-			}
 
 			int diff = _rgb64Map[destPalette[palCtr * 3 + colorCtr]] - intensity;
 			palIndex[palCtr][colorCtr] = (byte)ABS(diff);
@@ -891,4 +893,30 @@ void Palette::refreshSceneColors() {
 	setPalette(_mainPalette + (val * 3), val, 256 - val);
 }
 
+int Palette::closestColor(const byte *matchColor, const byte *refPalette,
+		int paletteInc, int count) {
+	int bestColor = 0;
+	int bestDistance = 0x7fff;
+
+	for (int idx = 0; idx < count; ++idx) {
+		// Figure out figure for 'distance' between two colors
+		int distance = 0;
+		for (int rgbIdx = 0; rgbIdx < RGB_SIZE; ++rgbIdx) {
+			int diff = refPalette[rgbIdx] - matchColor[rgbIdx];
+			distance += diff * diff;
+		}
+
+		// If the given color is a closer match to our color, store the index
+		if (distance <= bestDistance) {
+			bestDistance = distance;
+			bestColor = idx;
+		}
+
+		refPalette += paletteInc;
+	}
+
+	return bestColor;
+}
+
+
 } // End of namespace MADS
diff --git a/engines/mads/palette.h b/engines/mads/palette.h
index 27d25f266b..6c98947384 100644
--- a/engines/mads/palette.h
+++ b/engines/mads/palette.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -36,6 +36,7 @@ class MADSEngine;
 #define PALETTE_RESERVED_HIGH_COUNT 10
 
 #define PALETTE_COUNT 256
+#define RGB_SIZE 3
 #define PALETTE_SIZE (256 * 3)
 
 /**
@@ -212,16 +213,12 @@ public:
 	/**
 	* Gets the entire palette at once
 	*/
-	void getFullPalette(byte palette[PALETTE_SIZE]) {
-		grabPalette(&palette[0], 0, PALETTE_COUNT);
-	}
+	void getFullPalette(byte palette[PALETTE_SIZE]);
 
 	/**
 	* Sets the entire palette at once
 	*/
-	void setFullPalette(byte palette[PALETTE_SIZE]) {
-		setPalette(&palette[0], 0, PALETTE_COUNT);
-	}
+	void setFullPalette(byte palette[PALETTE_SIZE]);
 
 	/**
 	* Calculates a merge/hash for a given palette entry
@@ -318,6 +315,9 @@ public:
 	void unlock();
 
 	void refreshSceneColors();
+
+	static int closestColor(const byte *matchColor, const byte *refPalette, 
+		int paletteInc, int count);
 };
 
 } // End of namespace MADS
diff --git a/engines/mads/phantom/game_phantom.cpp b/engines/mads/phantom/game_phantom.cpp
index 0b2531ef65..592a108aea 100644
--- a/engines/mads/phantom/game_phantom.cpp
+++ b/engines/mads/phantom/game_phantom.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -28,7 +28,7 @@
 #include "mads/msurface.h"
 #include "mads/phantom/game_phantom.h"
 //#include "mads/nebular/dialogs_nebular.h"
-//#include "mads/nebular/globals_nebular.h"
+#include "mads/phantom/globals_phantom.h"
 #include "mads/phantom/phantom_scenes.h"
 
 namespace MADS {
@@ -52,29 +52,74 @@ void GamePhantom::startGame() {
 void GamePhantom::initializeGlobals() {
 	_globals.reset();
 
-	warning("TODO: sub_316DA()");
+	// TODO: Catacombs setup
 
 	_player._facing = FACING_NORTH;
 	_player._turnToFacing = FACING_NORTH;
 
-	/* Section #1 variables */
-	// TODO
-
-	/* Section #2 variables */
-	// TODO
-
-	/* Section #3 variables */
-	// TODO
-
-	/* Section #4 variables */
-	// TODO
-
-	/* Section #5 variables */
-	// TODO
-
-	/* Section #9 variables */
-	// TODO
-
+	_globals[kTempVar]                 = false;
+	_globals[kRoom103104Transition]    = 1;		// new room
+	_globals[kCurrentYear]             = 1993;
+	_globals[kTrapDoorStatus]          = 0;		// open
+	_globals[kChristineDoorStatus]     = 0;		// Christine is in her room
+	_globals[kSandbagStatus]           = 0;		// sandbag is secure
+	_globals[kJacquesStatus]           = 0;		// alive
+	_globals[kChrisFStatus]            = 1;		// Christine F. is alive in 1993
+	_globals[kBrieTalkStatus]          = 0;		// before Brie motions
+	_globals[kPanelIn206]              = 0;		// not discovered
+	_globals[kFightStatus]             = 0;
+	_globals[kJuliesDoor]              = 1;		// cracked open
+	_globals[kPrompterStandStatus]     = 0;
+	_globals[kChrisDStatus]            = 0;		// before love
+	_globals[kJulieNameIsKnown]        = 0;
+	_globals[kDoorsIn205]              = 0;		// both locked
+	_globals[kMadameGiryLocation]      = 1;		// middle
+	_globals[kTicketPeoplePresent]     = 0;
+	_globals[kCoffinStatus]            = 0;		// closed and locked
+	_globals[kDoneBrieConv203]         = 0;
+	_globals[kFlorentNameIsKnown]      = 0;
+	_globals[kDegasNameIsKnown]        = 0;
+	_globals[kMadameGiryShowsUp]       = false;
+	_globals[kJacquesNameIsKnown]      = 0;
+	_globals[kCharlesNameIsKnown]      = false;
+	_globals[kTopFloorLocked]          = true;
+	_globals[kMadameNameIsKnown]       = 0;
+	_globals[kChrisKickedRaoulOut]     = false;
+	_globals[kLookedAtCase]            = false;
+	_globals[kRingIsOnFinger]          = false;
+	_globals[kHeListened]              = false;
+	_globals[kKnockedOverHead]         = false;
+	_globals[kObservedPhan104]         = false;
+	_globals[kReadBook]                = false;
+	_globals[kCanFindBookInLibrary]    = false;
+	_globals[kLookedAtSkullFace]       = false;
+	_globals[kScannedBookcase]         = false;
+	_globals[kRanConvIn205]            = false;
+	_globals[kDoneRichConv203]         = false;
+	_globals[kHintThatDaaeIsHome1]     = false;
+	_globals[kHintThatDaaeIsHome2]     = false;
+	_globals[kMakeBrieLeave203]        = false;
+	_globals[kMakeRichLeave203]        = false;
+	_globals[kCameFromFade]            = false;
+	_globals[kChristineToldEnvelope]   = false;
+	_globals[kLeaveAngelMusicOn]       = false;
+	_globals[kDoorIn409IsOpen]         = false;
+	_globals[kUnknown]                 = false;
+	_globals[kCobwebIsCut]             = false;
+	_globals[kChristineIsInBoat]       = false;
+	_globals[kRightDoorIsOpen504]      = false;
+	_globals[kChrisLeft505]            = false;
+	_globals[kChrisWillTakeSeat]       = true;
+	_globals[kFlickedLever1]           = 0;
+	_globals[kFlickedLever2]           = 0;
+	_globals[kFlickedLever3]           = 0;
+	_globals[kFlickedLever4]           = 0;
+	_globals[kPlayerScore]             = 0;
+	_globals[kPlayerScoreFlags]        = 0;
+
+	_globals[kMusicSelected] = _vm->getRandomNumber(1, 4);
+
+	_player._spritesPrefix = "RAL";	// Fixed prefix
 	Player::preloadSequences("RAL", 1);
 }
 
@@ -106,6 +151,11 @@ void GamePhantom::checkShowDialog() {
 	// TODO: Copied from Nebular
 	if (_vm->_dialogs->_pendingDialog && _player._stepEnabled && !_globals[5]) {
 		_player.releasePlayerSprites();
+
+		// HACK: Skip the main menu (since it'll then try to show Rex's main menu)
+		if (_vm->_dialogs->_pendingDialog == DIALOG_MAIN_MENU)
+			_vm->_dialogs->_pendingDialog = DIALOG_NONE;
+
 		_vm->_dialogs->showDialog();
 		_vm->_dialogs->_pendingDialog = DIALOG_NONE;
 	}
diff --git a/engines/mads/phantom/game_phantom.h b/engines/mads/phantom/game_phantom.h
index 99cc2c1230..44b2321f42 100644
--- a/engines/mads/phantom/game_phantom.h
+++ b/engines/mads/phantom/game_phantom.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -26,7 +26,7 @@
 #include "common/scummsys.h"
 #include "mads/game.h"
 #include "mads/globals.h"
-//#include "mads/nebular/globals_nebular.h"
+#include "mads/phantom/globals_phantom.h"
 
 namespace MADS {
 
@@ -64,15 +64,6 @@ enum InventoryObject {
 	OBJ_OAR = 24
 };
 
-// HACK: A stub for now, remove from here once it's implemented properly
-class PhantomGlobals : public Globals {
-public:
-	PhantomGlobals() {
-		resize(210);	// Rex has 210 globals
-	}
-	virtual ~PhantomGlobals() {}
-};
-
 class GamePhantom : public Game {
 	friend class Game;
 protected:
diff --git a/engines/mads/phantom/globals_phantom.cpp b/engines/mads/phantom/globals_phantom.cpp
new file mode 100644
index 0000000000..e0db0a1bb0
--- /dev/null
+++ b/engines/mads/phantom/globals_phantom.cpp
@@ -0,0 +1,49 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/config-manager.h"
+#include "mads/phantom/globals_phantom.h"
+
+namespace MADS {
+
+namespace Phantom {
+
+PhantomGlobals::PhantomGlobals()
+	: Globals() {
+	// Initialize lists
+	resize(210);
+	_spriteIndexes.resize(30);
+	_sequenceIndexes.resize(30);
+}
+
+void PhantomGlobals::synchronize(Common::Serializer &s) {
+	Globals::synchronize(s);
+
+	_spriteIndexes.synchronize(s);
+	_sequenceIndexes.synchronize(s);
+}
+
+
+} // End of namespace Phantom
+
+} // End of namespace MADS
diff --git a/engines/mads/phantom/globals_phantom.h b/engines/mads/phantom/globals_phantom.h
new file mode 100644
index 0000000000..c23b53cdf5
--- /dev/null
+++ b/engines/mads/phantom/globals_phantom.h
@@ -0,0 +1,143 @@
+/* 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 MADS_GLOBALS_PHANTOM_H
+#define MADS_GLOBALS_PHANTOM_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "mads/game.h"
+#include "mads/resources.h"
+
+namespace MADS {
+
+namespace Phantom {
+
+enum GlobalId {
+	// Global variables
+
+	kWalkerTiming           = 0,
+	kWalkerTiming2			= 1,
+	kStopWalkerDisabled		= 2,	// disable walker idle animations
+	kTempInterface          = 3,
+	kWalkerConverse         = 4,	// conversation started with an NPC
+	kWalkerConverseState    = 5,
+	kWalkerConverseNow      = 6,
+
+	kCurrentYear            = 10,	// current year (1881 or 1993)
+	kMusicSelected          = 11,
+	kPlayerScore            = 12,
+	kPlayerScoreFlags       = 13,
+	kDoneBrieConv203        = 14,
+	kLanternStatus          = 15,
+
+	// Section #1 variables
+	kLeaveAngelMusicOn      = 19,
+	kTrapDoorStatus         = 20,
+	kChristineDoorStatus    = 21,
+	kSandbagStatus          = 22,
+	kChrisFStatus           = 23,
+	kBrieTalkStatus         = 24,
+	kJuliesDoor             = 25,
+	kPrompterStandStatus    = 26,
+	kChrisDStatus           = 27,
+	kJulieNameIsKnown       = 28,
+	kChrisKickedRaoulOut    = 29,
+	kJacquesNameIsKnown     = 30,
+	kJacquesStatus          = 31,
+	kFlorentNameIsKnown     = 32,
+	kCharlesNameIsKnown     = 33,
+	kRoom103104Transition   = 34,
+	kObservedPhan104        = 35,
+	kDeathLocation          = 36,
+	kMakeBrieLeave203       = 37,
+	kHintThatDaaeIsHome1    = 38,
+	kHintThatDaaeIsHome2    = 39,
+
+	// Section #2 variables
+	kChristineToldEnvelope  = 40,
+	kReadBook               = 41,
+	kScannedBookcase        = 42,
+	kRanConvIn205           = 43,
+	kDoorsIn205             = 44,
+	kPanelIn206             = 45,
+	kMadameNameIsKnown      = 46,
+	kMadameGiryLocation     = 47,
+	kLookedAtCase           = 48,
+	kMadameGiryShowsUp      = 49,
+	kDoneRichConv203        = 50,
+	kCameFromFade           = 51,
+	kTicketPeoplePresent    = 52,
+	kDegasNameIsKnown       = 53,
+	kTempVar                = 54,
+	kFlickedLever1          = 55,
+	kFlickedLever2          = 56,
+	kFlickedLever3          = 57,
+	kFlickedLever4          = 58,
+
+	// Section #3 Variables
+	kTopFloorLocked         = 60,
+
+	// Section #4 Variables
+	kCatacombsRoom          = 80,
+	// TODO
+	kDoorIn409IsOpen        = 93,
+	kUnknown                = 94,	// TODO
+	kCobwebIsCut            = 95,
+
+	// Section #5 Variables
+	kChristineIsInBoat      = 100,
+	kChrisWillTakeSeat      = 101,
+	kRightDoorIsOpen504     = 102,
+	kCoffinStatus           = 103,
+	kChrisLeft505           = 104,
+	kKnockedOverHead        = 105,
+	kFightStatus            = 106,
+	kHeListened             = 107,
+	kCanFindBookInLibrary   = 108,
+	kRingIsOnFinger         = 109,
+	kLookedAtSkullFace      = 110,
+	kCableHookWasSeparate   = 111,
+	kMakeRichLeave203       = 112
+};
+
+class PhantomGlobals : public Globals {
+public:
+	SynchronizedList _spriteIndexes;
+	SynchronizedList _sequenceIndexes;
+public:
+	/**
+	 * Constructor
+	 */
+	PhantomGlobals();
+
+	/**
+	* Synchronize the globals data
+	*/
+	virtual void synchronize(Common::Serializer &s);
+};
+
+} // End of namespace Phantom
+
+} // End of namespace MADS
+
+#endif /* MADS_GLOBALS_PHANTOM_H */
diff --git a/engines/mads/phantom/phantom_scenes.cpp b/engines/mads/phantom/phantom_scenes.cpp
index 7fd7ce642d..f7f4d154df 100644
--- a/engines/mads/phantom/phantom_scenes.cpp
+++ b/engines/mads/phantom/phantom_scenes.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -28,6 +28,7 @@
 #include "mads/scene.h"
 #include "mads/phantom/game_phantom.h"
 #include "mads/phantom/phantom_scenes.h"
+#include "mads/phantom/phantom_scenes1.h"
 
 namespace MADS {
 
@@ -42,9 +43,9 @@ SceneLogic *SceneFactory::createScene(MADSEngine *vm) {
 	switch (scene._nextSceneId) {
 	// Scene group #1 (theater, stage and dressing rooms)
 	case 101:	// seats
-		return new DummyScene(vm);	// TODO
+		return new Scene101(vm);
 	case 102:	// music stands
-		return new DummyScene(vm);	// TODO
+		return new Scene102(vm);
 	case 103:	// below stage
 		return new DummyScene(vm);	// TODO
 	case 104:	// stage
@@ -169,6 +170,10 @@ Common::String PhantomScene::formAnimName(char sepChar, int suffixNum) {
 /*------------------------------------------------------------------------*/
 
 void SceneInfoPhantom::loadCodes(MSurface &depthSurface, int variant) {
+	// The intro scenes do not have any codes
+	if (_sceneId >= 900)
+		return;
+
 	Common::String ext = Common::String::format(".WW%d", variant);
 	File f(Resources::formatName(RESPREFIX_RM, _sceneId, ext));
 	MadsPack codesPack(&f);
diff --git a/engines/mads/phantom/phantom_scenes.h b/engines/mads/phantom/phantom_scenes.h
index cd295a28b6..c0a823ae06 100644
--- a/engines/mads/phantom/phantom_scenes.h
+++ b/engines/mads/phantom/phantom_scenes.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -34,20 +34,40 @@ namespace MADS {
 
 namespace Phantom {
 
+enum Verb {
+	VERB_LOOK = 0x3,
+	VERB_TAKE = 0x4,
+	VERB_PUSH = 0x5,
+	VERB_OPEN = 0x6,
+	VERB_PUT = 0x7,
+	VERB_TALK_TO = 0x8,
+	VERB_GIVE = 0x9,
+	VERB_PULL = 0xA,
+	VERB_CLOSE = 0xB,
+	VERB_THROW = 0xC,
+	VERB_WALK_TO = 0xD,
+	VERB_CLIMB_DOWN = 0x21,
+	VERB_CLIMB_INTO = 0x22,
+	VERB_CLIMB_THROUGH = 0x23,
+	VERB_EXIT_TO = 0x37,
+	VERB_JUMP_INTO = 0x53,
+	VERB_LOOK_AT = 0x60,
+	VERB_LOOK_THROUGH = 0x61,
+	VERB_TURN_OFF = 0x95,
+	VERB_TURN_ON = 0x96,
+	VERB_UNLOCK = 0x97,
+	VERB_WALK_ACROSS = 0x99,
+	VERB_WALK_DOWN = 0x9A,
+	VERB_WALK_THROUGH = 0x9B,
+	VERB_WALK_UP = 0x9C,
+	VERB_CLIMB_UP = 0xA5,
+	VERB_WALK_ONTO = 0xA6,
+	VERB_WALK = 0xA7
+};
+
 enum Noun {
 	NOUN_GAME = 0x1,
 	NOUN_QSAVE = 0x2,
-	NOUN_LOOK = 0x3,
-	NOUN_TAKE = 0x4,
-	NOUN_PUSH = 0x5,
-	NOUN_OPEN = 0x6,
-	NOUN_PUT = 0x7,
-	NOUN_TALK_TO = 0x8,
-	NOUN_GIVE = 0x9,
-	NOUN_PULL = 0xA,
-	NOUN_CLOSE = 0xB,
-	NOUN_THROW = 0xC,
-	NOUN_WALK_TO = 0xD,
 	NOUN_ = 0xE,
 	NOUN_IN_ONE = 0xF,
 	NOUN_IN_TWO = 0x10,
@@ -67,9 +87,6 @@ enum Noun {
 	NOUN_CEILING = 0x1E,
 	NOUN_CHAIR = 0x1F,
 	NOUN_CIRCULAR_STAIRCASE = 0x20,
-	NOUN_CLIMB_DOWN = 0x21,
-	NOUN_CLIMB_INTO = 0x22,
-	NOUN_CLIMB_THROUGH = 0x23,
 	NOUN_COLUMN_PROP = 0x24,
 	NOUN_CONDUCTORS_STAND = 0x25,
 	NOUN_CORRIDOR = 0x26,
@@ -89,7 +106,6 @@ enum Noun {
 	NOUN_EXIT = 0x34,
 	NOUN_EXIT_DOWN = 0x35,
 	NOUN_EXIT_SIGN = 0x36,
-	NOUN_EXIT_TO = 0x37,
 	NOUN_EXIT_TO_BACKSTAGE = 0x38,
 	NOUN_EXIT_TO_CELLAR = 0x39,
 	NOUN_EXIT_TO_CORRIDOR = 0x3A,
@@ -117,7 +133,6 @@ enum Noun {
 	NOUN_HOUSE = 0x50,
 	NOUN_IN_ONE2 = 0x51,
 	NOUN_IN_TWO2 = 0x52,
-	NOUN_JUMP_INTO = 0x53,
 	NOUN_JUNK = 0x54,
 	NOUN_KEY = 0x55,
 	NOUN_LAMP = 0x56,
@@ -130,8 +145,6 @@ enum Noun {
 	NOUN_LOCK = 0x5D,
 	NOUN_LOCKING_RAIL = 0x5E,
 	NOUN_LOCKRAIL = 0x5F,
-	NOUN_LOOK_AT = 0x60,
-	NOUN_LOOK_THROUGH = 0x61,
 	NOUN_MANNEQUINS = 0x62,
 	NOUN_MIRROR = 0x63,
 	NOUN_MUMMY_PROP = 0x64,
@@ -183,14 +196,7 @@ enum Noun {
 	NOUN_TICKET = 0x92,
 	NOUN_TRAP_CEILING = 0x93,
 	NOUN_TRAP_DOOR = 0x94,
-	NOUN_TURN_OFF = 0x95,
-	NOUN_TURN_ON = 0x96,
-	NOUN_UNLOCK = 0x97,
 	NOUN_URN = 0x98,
-	NOUN_WALK_ACROSS = 0x99,
-	NOUN_WALK_DOWN = 0x9A,
-	NOUN_WALK_THROUGH = 0x9B,
-	NOUN_WALK_UP = 0x9C,
 	NOUN_WALL = 0x9D,
 	NOUN_WARDROBE = 0x9E,
 	NOUN_WASTE_BASKET = 0x9F,
@@ -199,9 +205,6 @@ enum Noun {
 	NOUN_WEDDING_RING = 0xA2,
 	NOUN_YELLOW_FRAME = 0xA3,
 	NOUN_PROP = 0xA4,
-	NOUN_CLIMB_UP = 0xA5,
-	NOUN_WALK_ONTO = 0xA6,
-	NOUN_WALK = 0xA7,
 	NOUN_LEFT_DOOR = 0xA8,
 	NOUN_RIGHT_DOOR = 0xA9,
 	NOUN_DOOR_TO_PIT = 0xAA,
@@ -482,27 +485,6 @@ protected:
 };
 
 // TODO: Temporary, remove once implemented properly
-class Scene1xx : public PhantomScene {
-protected:
-	/**
-	 * Plays an appropriate sound when entering a scene
-	 */
-	void sceneEntrySound() {}
-
-	/**
-	 *Sets the AA file to use for the scene
-	 */
-	void setAAName() {}
-
-	/**
-	 * Updates the prefix used for getting player sprites for the scene
-	 */
-	void setPlayerSpritesPrefix() {}
-public:
-	Scene1xx(MADSEngine *vm) : PhantomScene(vm) {}
-};
-
-// TODO: Temporary, remove once implemented properly
 class DummyScene : public PhantomScene {
 public:
 	DummyScene(MADSEngine *vm) : PhantomScene(vm) {
diff --git a/engines/mads/phantom/phantom_scenes1.cpp b/engines/mads/phantom/phantom_scenes1.cpp
new file mode 100644
index 0000000000..2d991fd3bc
--- /dev/null
+++ b/engines/mads/phantom/phantom_scenes1.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 "common/scummsys.h"
+#include "mads/mads.h"
+#include "mads/scene.h"
+#include "mads/phantom/phantom_scenes.h"
+#include "mads/phantom/phantom_scenes1.h"
+
+namespace MADS {
+
+namespace Phantom {
+
+void Scene1xx::setAAName() {
+	// TODO
+	//int idx = 0;
+	//_game._aaName = Resources::formatAAName(idx);
+}
+
+void Scene1xx::sceneEntrySound() {
+	// TODO
+}
+
+/*------------------------------------------------------------------------*/
+
+Scene101::Scene101(MADSEngine *vm) : Scene1xx(vm) {
+
+}
+
+void Scene101::synchronize(Common::Serializer &s) {
+	Scene1xx::synchronize(s);
+
+}
+
+void Scene101::setup() {
+	//setPlayerSpritesPrefix();
+	setAAName();
+}
+
+void Scene101::enter() {
+	// TODO
+
+	if (_globals[kCurrentYear] == 1993) {
+		_globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('z', -1));
+		// TODO
+		//_scene->_sequences.setDepth(_globals._sequenceIndexes[0], 14);
+	} else {
+		// TODO
+	}
+
+	// TODO
+}
+
+void Scene101::step() {
+	// TODO
+}
+
+void Scene101::preActions() {
+	if (_action.isAction(VERB_EXIT_TO, NOUN_ORCHESTRA_PIT)) {
+		// TODO: Handle Brie
+		_game._player._walkOffScreenSceneId = 102;
+	} else if (_action.isAction(VERB_EXIT_TO, NOUN_GRAND_FOYER)) {
+		// TODO: Handle Brie
+		_game._player._walkOffScreenSceneId = 202;
+	} else if (_action.isAction(VERB_TAKE, NOUN_MONSIEUR_BRIE)) {
+		_vm->_dialogs->show(10121);
+	} else if (_action.isAction(VERB_TALK_TO, NOUN_MONSIEUR_BRIE)) {
+		if (_globals[kBrieTalkStatus] == 2)
+			_game._player._needToWalk = false;
+	}
+
+	// TODO
+}
+
+void Scene101::actions() {
+	// TODO: Brie conversation
+
+	// TODO: Look around
+
+	if (_action.isAction(VERB_LOOK) || _action.isAction(VERB_LOOK_AT)) {
+		if (_action.isObject(NOUN_AISLE)) {
+			_vm->_dialogs->show(10112);
+		} else if (_action.isObject(NOUN_CHANDELIER)) {
+			_vm->_dialogs->show(10113);
+		} else if (_action.isObject(NOUN_BACK_WALL)) {
+			_vm->_dialogs->show(10114);
+		} else if (_action.isObject(NOUN_SIDE_WALL)) {
+			_vm->_dialogs->show(10115);
+		} else if (_action.isObject(NOUN_SEATS)) {
+			// TODO: Finish this
+			_vm->_dialogs->show(10116);
+		} else if (_action.isObject(NOUN_GRAND_FOYER)) {
+			_vm->_dialogs->show(10117);
+		} else if (_action.isObject(NOUN_ORCHESTRA_PIT)) {
+			_vm->_dialogs->show(10118);
+		} else if (_action.isObject(NOUN_MONSIEUR_BRIE)) {
+			_vm->_dialogs->show(10120);
+		}
+
+		_game._player._stepEnabled = true;
+	} else if (_action.isAction(VERB_TALK_TO, NOUN_MONSIEUR_BRIE)) {
+		if (_globals[kBrieTalkStatus] == 2)
+			_vm->_dialogs->show(10122);
+		_game._player._stepEnabled = true;
+	} else if (_action.isAction(VERB_TAKE, NOUN_MONSIEUR_BRIE)) {
+		_game._player._stepEnabled = true;
+	}
+}
+
+/*------------------------------------------------------------------------*/
+
+Scene102::Scene102(MADSEngine *vm) : Scene1xx(vm) {
+	_animRunningFl = false;
+}
+
+void Scene102::synchronize(Common::Serializer &s) {
+	Scene1xx::synchronize(s);
+
+	s.syncAsByte(_animRunningFl);
+}
+
+void Scene102::setup() {
+	//setPlayerSpritesPrefix();
+	setAAName();
+}
+
+void Scene102::enter() {
+	_animRunningFl = false;
+
+	_globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 0));
+	_globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RAL86");
+
+	if (_globals[kCurrentYear] == 1993) {
+		_globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('z', -1));
+		// TODO
+		//_scene->_sequences.setDepth(_globals._sequenceIndexes[0], 14);
+	} else {
+		// TODO
+	}
+
+	if (_scene->_priorSceneId == 101) {
+		_game._player._playerPos = Common::Point(97, 79);
+		_game._player._facing = FACING_SOUTHEAST;
+		// TODO
+		_game._player.walk(Common::Point(83, 87), FACING_SOUTHEAST);
+		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 14);
+	} else if (_scene->_priorSceneId == 104) {
+		// Player fell from pit -> death
+		// TODO
+	} else if (_scene->_priorSceneId == 103 || _scene->_priorSceneId != -1) {
+		_game._player._playerPos = Common::Point(282, 145);
+		_game._player._facing = FACING_WEST;
+		_animRunningFl = true;
+		// TODO: Door closing animation
+	} else if (_scene->_priorSceneId == -1) {
+		// TODO
+		_scene->_sequences.setDepth(_globals._sequenceIndexes[2], 14);
+	}
+
+	sceneEntrySound();
+}
+
+void Scene102::step() {
+	if (_game._trigger == 60) {		// Door closes
+		// TODO
+		_animRunningFl = false;
+	} else if (_game._trigger == 65) {		// Death
+		// TODO
+		_scene->_currentSceneId = 104;
+	}
+}
+
+void Scene102::preActions() {
+	if (_action.isAction(VERB_OPEN, NOUN_ORCHESTRA_DOOR) || _action.isAction(VERB_PUSH, NOUN_ORCHESTRA_DOOR)) {
+		_game._player.walk(Common::Point(282, 145), FACING_EAST);
+	}
+}
+
+void Scene102::actions() {
+	if (_action.isAction(VERB_WALK_DOWN, NOUN_AISLE)) {
+		_scene->_nextSceneId = 101;
+		_game._player._stepEnabled = true;
+	}
+
+	if (_action.isAction(VERB_WALK_THROUGH, NOUN_ORCHESTRA_DOOR) ||
+		_action.isAction(VERB_PUSH, NOUN_ORCHESTRA_DOOR) ||
+		_action.isAction(VERB_OPEN, NOUN_ORCHESTRA_DOOR)) {
+		if (_animRunningFl) {
+			// TODO
+		} else {
+			_scene->_nextSceneId = 103;		// FIXME: temporary HACK - remove!
+
+			switch (_game._trigger) {
+			case 70:	// try again
+			case 0:
+				// TODO
+				break;
+			case 1:
+				_scene->_nextSceneId = 103;
+				break;
+			}
+		}
+
+		_game._player._stepEnabled = true;
+	}
+
+	// TODO: Look around
+
+	if (_action.isAction(VERB_LOOK) || _action.isAction(VERB_LOOK_AT)) {
+		if (_action.isObject(NOUN_PIT))
+			_vm->_dialogs->show(10211);
+		else if (_action.isObject(NOUN_SEATS))
+			if (_globals[kCurrentYear] == 1881)
+				_vm->_dialogs->show(10212);
+			else
+				_vm->_dialogs->show(10230);
+		else if (_action.isObject(NOUN_ORCHESTRA_DOOR))
+			_vm->_dialogs->show(10213);
+		else if (_action.isObject(NOUN_CONDUCTORS_STAND))
+			_vm->_dialogs->show(10214);
+		else if (_action.isObject(NOUN_MUSIC_STAND) || _action.isObject(NOUN_MUSIC_STANDS))
+			_vm->_dialogs->show(10215);
+		else if (_action.isObject(NOUN_PROMPTERS_BOX))
+			_vm->_dialogs->show(10217);
+		else if (_action.isObject(NOUN_STAGE))
+			_vm->_dialogs->show(10218);
+		else if (_action.isObject(NOUN_APRON))
+			_vm->_dialogs->show(10219);
+		else if (_action.isObject(NOUN_SIDE_WALL))
+			_vm->_dialogs->show(10220);
+		else if (_action.isObject(NOUN_FOLDING_CHAIRS))
+			_vm->_dialogs->show(10221);
+		else if (_action.isObject(NOUN_AISLE))
+			_vm->_dialogs->show(10222);
+		else if (_action.isObject(NOUN_PROSCENIUM_ARCH))
+			_vm->_dialogs->show(10223);
+		else if (_action.isObject(NOUN_ACT_CURTAIN))
+			_vm->_dialogs->show(10224);
+		else if (_action.isObject(NOUN_IN_ONE))
+			_vm->_dialogs->show(10225);
+		else if (_action.isObject(NOUN_IN_TWO))
+			_vm->_dialogs->show(10226);
+		else if (_action.isObject(NOUN_LEG))
+			_vm->_dialogs->show(10227);
+		else if (_action.isObject(NOUN_CHANDELIER))
+			_vm->_dialogs->show(10231);
+		else
+			return;
+
+		_game._player._stepEnabled = true;
+	}
+
+	if (_action.isAction(VERB_CLOSE, NOUN_ORCHESTRA_DOOR)) {
+		_vm->_dialogs->show(10228);
+		_game._player._stepEnabled = true;
+	}
+}
+
+
+/*------------------------------------------------------------------------*/
+
+} // End of namespace Phantom
+} // End of namespace MADS
diff --git a/engines/mads/phantom/phantom_scenes1.h b/engines/mads/phantom/phantom_scenes1.h
new file mode 100644
index 0000000000..0f5f56a4cf
--- /dev/null
+++ b/engines/mads/phantom/phantom_scenes1.h
@@ -0,0 +1,89 @@
+/* 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 MADS_PHANTOM_SCENES1_H
+#define MADS_PHANTOM_SCENES1_H
+
+#include "common/scummsys.h"
+#include "common/serializer.h"
+#include "mads/game.h"
+#include "mads/scene.h"
+#include "mads/phantom/phantom_scenes.h"
+
+namespace MADS {
+
+namespace Phantom {
+
+class Scene1xx : public PhantomScene {
+protected:
+	/**
+	 * Plays an appropriate sound when entering a scene
+	 */
+	void sceneEntrySound();
+
+	/**
+	 *Sets the AA file to use for the scene
+	 */
+	void setAAName();
+
+	/**
+	 * Updates the prefix used for getting player sprites for the scene
+	 */
+	void setPlayerSpritesPrefix();
+public:
+	Scene1xx(MADSEngine *vm) : PhantomScene(vm) {}
+};
+
+class Scene101 : public Scene1xx {
+private:
+	// TODO
+
+public:
+	Scene101(MADSEngine *vm);
+	virtual void synchronize(Common::Serializer &s);
+
+	virtual void setup();
+	virtual void enter();
+	virtual void step();
+	virtual void preActions();
+	virtual void actions();
+};
+
+class Scene102 : public Scene1xx {
+private:
+	bool _animRunningFl;
+
+public:
+	Scene102(MADSEngine *vm);
+	virtual void synchronize(Common::Serializer &s);
+
+	virtual void setup();
+	virtual void enter();
+	virtual void step();
+	virtual void preActions();
+	virtual void actions();
+};
+
+} // End of namespace Phantom
+} // End of namespace MADS
+
+#endif /* MADS_PHANTOM_SCENES1_H */
diff --git a/engines/mads/player.cpp b/engines/mads/player.cpp
index bde313af8d..bb747f4b52 100644
--- a/engines/mads/player.cpp
+++ b/engines/mads/player.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -235,12 +235,18 @@ void Player::selectSeries() {
 
 void Player::updateFrame() {
 	// WORKAROUND: Prevent character info being referenced when not present
-	if ((_spritesStart + _spritesIdx) < 0 || !_spriteSetsPresent[_spritesStart + _spritesIdx])
+	int idx = _spritesStart + _spritesIdx;
+	if (idx < 0 || (idx < PLAYER_SPRITES_FILE_COUNT && !_spriteSetsPresent[idx]))
 		return;
 
 	Scene &scene = _vm->_game->_scene;
-	SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx];
-	assert(spriteSet._charInfo);
+	assert(scene._sprites[idx] != nullptr);
+	SpriteAsset &spriteSet = *scene._sprites[idx];
+	
+	// WORKAROUND: Certain cutscenes set up player sprites that don't have any 
+	// character info. In such cases, simply ignore player updates
+	if (!spriteSet._charInfo)
+		return;
 
 	if (!spriteSet._charInfo->_numEntries) {
 		_frameNumber = 1;
@@ -509,12 +515,12 @@ void Player::idle() {
 		return;
 	}
 
-	if ((_spritesStart + _spritesIdx) < 0 || !_spriteSetsPresent[_spritesStart + _spritesIdx])
+	int idx = _spritesStart + _spritesIdx;
+	if (idx < 0 || (idx < PLAYER_SPRITES_FILE_COUNT && !_spriteSetsPresent[idx]))
 		return;
 
-	SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx];
-	assert(spriteSet._charInfo);
-	if (spriteSet._charInfo->_numEntries == 0)
+	SpriteAsset &spriteSet = *scene._sprites[idx];
+	if (spriteSet._charInfo == nullptr || spriteSet._charInfo->_numEntries == 0)
 		// No entries, so exit immediately
 		return;
 
@@ -528,11 +534,11 @@ void Player::idle() {
 		_frameNumber += direction;
 		_forceRefresh = true;
 
-		if (spriteSet._charInfo->_stopFrames[frameIndex] < _frameNumber) {
+		if (_frameNumber > spriteSet._charInfo->_stopFrames[frameIndex]) {
 			_trigger = _upcomingTrigger;
 			updateFrame();
 		}
-		if (spriteSet._charInfo->_startFrames[frameIndex] < _frameNumber) {
+		if (_frameNumber < spriteSet._charInfo->_startFrames[frameIndex]) {
 			_trigger = _upcomingTrigger;
 			updateFrame();
 		}
@@ -658,7 +664,7 @@ void Player::startMovement() {
 	_deltaDistance = (majorChange == 0) ? 0 : _totalDistance / majorChange;
 
 	if (_playerPos.x > _targetPos.x)
-		_pixelAccum = MAX(_posChange.x, _posChange.y);
+		_pixelAccum = MIN(_posChange.x, _posChange.y);
 	else
 		_pixelAccum = 0;
 
@@ -703,7 +709,7 @@ void Player::releasePlayerSprites() {
 	_spritesLoaded = false;
 	_spritesChanged = true;
 
-	if (scene._sprites._assetCount > 0) {
+	if (scene._sprites.size() > 0) {
 		warning("Player::releasePlayerSprites(): leftover sprites remain, clearing list");
 		scene._sprites.clear();
 	}
@@ -779,14 +785,14 @@ void Player::removePlayerSprites() {
 	int heroSpriteId = _spritesStart;
 	for (int i = 0; i < 8; i++) {
 		if (_spriteSetsPresent[i]) {
-			scene._sprites.remove(heroSpriteId++);
+			delete scene._sprites[heroSpriteId];
+			scene._sprites[heroSpriteId] = nullptr;
 			_spriteSetsPresent[i] = false;
+			++heroSpriteId;
 		}
 	}
 
-	if (scene._activeAnimation != nullptr)
-		scene._activeAnimation->resetSpriteSetsCount();
-
+	scene._spriteSlots.clear();
 	scene._spriteSlots.fullRefresh();
 	_visible = false;
 }
diff --git a/engines/mads/player.h b/engines/mads/player.h
index 671ac9d16e..e5765a9bca 100644
--- a/engines/mads/player.h
+++ b/engines/mads/player.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/rails.cpp b/engines/mads/rails.cpp
index 322e6e7cb3..9b2ec71de6 100644
--- a/engines/mads/rails.cpp
+++ b/engines/mads/rails.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/rails.h b/engines/mads/rails.h
index e6cab08f85..c95f5c47a6 100644
--- a/engines/mads/rails.h
+++ b/engines/mads/rails.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/resources.cpp b/engines/mads/resources.cpp
index 1fb75e6ba2..d5352fb205 100644
--- a/engines/mads/resources.cpp
+++ b/engines/mads/resources.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/resources.h b/engines/mads/resources.h
index 8d9ab1e39f..95ea17d3c4 100644
--- a/engines/mads/resources.h
+++ b/engines/mads/resources.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/scene.cpp b/engines/mads/scene.cpp
index d2b4b29622..ee5f1a5440 100644
--- a/engines/mads/scene.cpp
+++ b/engines/mads/scene.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -52,7 +52,7 @@ Scene::Scene(MADSEngine *vm)
 	_activeAnimation = nullptr;
 	_textSpacing = -1;
 	_frameStartTime = 0;
-	_layer = LAYER_GUI;
+	_mode = SCREENMODE_VGA;
 	_lookFlag = false;
 	_bandsRange = 0;
 	_scaleRange = 0;
@@ -500,14 +500,12 @@ void  Scene::drawElements(ScreenTransition transitionType, bool surfaceFlag) {
 	_dirtyAreas.copy(&_backgroundSurface, &_vm->_screen, _posAdjust);
 
 	// Handle dirty areas for foreground objects
-	if (_vm->getGameID() == GType_RexNebular)	// TODO: Implement for V2 games
-		_spriteSlots.setDirtyAreas();
+	_spriteSlots.setDirtyAreas();
 	_textDisplay.setDirtyAreas2();
 	_dirtyAreas.merge(1, DIRTY_AREAS_SIZE);
 
 	// Draw sprites that have changed
-	if (_vm->getGameID() == GType_RexNebular)	// TODO: Implement for V2 games
-		_spriteSlots.drawSprites(&_sceneSurface);
+	_spriteSlots.drawSprites(&_sceneSurface);
 
 	// Draw text elements onto the view
 	_textDisplay.draw(&_vm->_screen);
@@ -592,12 +590,14 @@ void Scene::doSceneStep() {
 }
 
 void Scene::checkKeyboard() {
-	if (_vm->_events->isKeyPressed()) {
-		Common::Event evt = _vm->_events->_pendingKeys.pop();
+	EventsManager &events = *_vm->_events;
+
+	if (events.isKeyPressed()) {
+		Common::KeyState evt = events.getKey();
 		_vm->_game->handleKeypress(evt);
 	}
 
-	if ((_vm->_events->_mouseStatus & 3) == 3 && _vm->_game->_player._stepEnabled) {
+	if ((events._mouseStatus & 3) == 3 && _vm->_game->_player._stepEnabled) {
 		_reloadSceneFlag = true;
 		_vm->_dialogs->_pendingDialog = DIALOG_GAME_MENU;
 		_action.clear();
@@ -664,6 +664,7 @@ void Scene::freeCurrentScene() {
 	}
 
 	_vm->_palette->_paletteUsage.load(nullptr);
+	_cyclingActive = false;
 	_hotspots.clear();
 	_backgroundSurface.free();
 	_depthSurface.free();
diff --git a/engines/mads/scene.h b/engines/mads/scene.h
index 9fd99ad8e5..c0784c3812 100644
--- a/engines/mads/scene.h
+++ b/engines/mads/scene.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -40,6 +40,8 @@
 
 namespace MADS {
 
+enum { RETURNING_FROM_DIALOG = -2, RETURNING_FROM_LOADING = -1 };
+
 class Scene {
 private:
 	/**
@@ -121,7 +123,7 @@ public:
 	bool _reloadSceneFlag;
 	Common::Point _posAdjust;
 	uint32 _frameStartTime;
-	Layer _layer;
+	ScreenMode _mode;
 	bool _lookFlag;
 	Common::Point _customDest;
 	Common::Array<PaletteUsage::UsageEntry> _paletteUsageF;
diff --git a/engines/mads/scene_data.cpp b/engines/mads/scene_data.cpp
index b5e219ed04..e48bcd8c6f 100644
--- a/engines/mads/scene_data.cpp
+++ b/engines/mads/scene_data.cpp
@@ -86,7 +86,8 @@ void ARTHeader::load(Common::SeekableReadStream *f, bool isV2) {
 void SceneInfo::SpriteInfo::load(Common::SeekableReadStream *f) {
 	f->skip(3);
 	_spriteSetIndex = f->readByte();
-	f->skip(2);
+	_frameNumber = f->readSByte();
+	f->skip(1);
 	_position.x = f->readSint16LE();
 	_position.y = f->readSint16LE();
 	_depth = f->readByte();
@@ -263,9 +264,9 @@ void SceneInfo::load(int sceneId, int variant, const Common::String &resName,
 		SpriteAsset *asset = spriteSets[si._spriteSetIndex];
 		assert(asset && _depthStyle != 2);
 
-		MSprite *spr = asset->getFrame(asset->getCount() - 1);
+		MSprite *spr = asset->getFrame(si._frameNumber);
 		bgSurface.copyFrom(spr, si._position, si._depth, &depthSurface,
-			si._scale, spr->getTransparencyIndex());
+			si._scale, false, spr->getTransparencyIndex());
 	}
 
 	// Free the sprite sets
@@ -468,6 +469,7 @@ void SceneInfo::loadMadsV2Background(int sceneId, const Common::String &resName,
 			for (int i = 0; i < tileIndex; i++)
 				++tile;
 			((*tile).get())->copyTo(&bgSurface, Common::Point(x * tileWidth, y * tileHeight));
+			((*tile).get())->free();
 		}
 	}
 	tileSet.clear();
diff --git a/engines/mads/scene_data.h b/engines/mads/scene_data.h
index 41e094b8f5..41a08f74eb 100644
--- a/engines/mads/scene_data.h
+++ b/engines/mads/scene_data.h
@@ -144,6 +144,7 @@ class SceneInfo {
 	public:
 		int _spriteSetIndex;
 		Common::Point _position;
+		int _frameNumber;
 		int _depth;
 		int _scale;
 
diff --git a/engines/mads/screen.cpp b/engines/mads/screen.cpp
index c9a0863d85..3c27001ae0 100644
--- a/engines/mads/screen.cpp
+++ b/engines/mads/screen.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -244,7 +244,7 @@ void DirtyAreas::reset() {
 ScreenObject::ScreenObject() {
 	_category = CAT_NONE;
 	_descId = 0;
-	_layer = 0;
+	_mode = 0;
 	_active = false;
 }
 
@@ -265,17 +265,17 @@ ScreenObjects::ScreenObjects(MADSEngine *vm) : _vm(vm) {
 	_baseTime = 0;
 }
 
-void ScreenObjects::add(const Common::Rect &bounds, Layer layer, ScrCategory category, int descId) {
-	//assert(size() < 100);
-
+ScreenObject *ScreenObjects::add(const Common::Rect &bounds, ScreenMode mode, ScrCategory category, int descId) {
 	ScreenObject so;
 	so._bounds = bounds;
 	so._category = category;
 	so._descId = descId;
-	so._layer = layer;
+	so._mode = mode;
 	so._active = true;
 
 	push_back(so);
+
+	return &(*this)[size()];
 }
 
 void ScreenObjects::check(bool scanFlag) {
@@ -288,7 +288,7 @@ void ScreenObjects::check(bool scanFlag) {
 	if ((_vm->_events->_mouseMoved || userInterface._scrollbarActive
 			|| _v8332A || _forceRescan) && scanFlag) {
 		_category = CAT_NONE;
-		_selectedObject = scanBackwards(_vm->_events->currentPos(), LAYER_GUI);
+		_selectedObject = scanBackwards(_vm->_events->currentPos(), SCREENMODE_VGA);
 		if (_selectedObject > 0) {
 			ScreenObject &scrObject = (*this)[_selectedObject];
 			_category = (ScrCategory)(scrObject._category & 7);
@@ -308,10 +308,10 @@ void ScreenObjects::check(bool scanFlag) {
 		}
 
 		//_released = _vm->_events->_mouseReleased;
-		if (_vm->_events->_vD2 || (_vm->_easyMouse && !_vm->_events->_mouseStatusCopy))
+		if (_vm->_events->_mouseButtons || (_vm->_easyMouse && !_vm->_events->_mouseStatusCopy))
 			scene._userInterface._category = _category;
 
-		if (!_vm->_events->_mouseButtons || _vm->_easyMouse) {
+		if (_vm->_events->_mouseButtons || _vm->_easyMouse) {
 			if (userInterface._category >= CAT_COMMAND && userInterface._category <= CAT_TALK_ENTRY) {
 				elementHighlighted();
 			}
@@ -365,7 +365,7 @@ void ScreenObjects::check(bool scanFlag) {
 int ScreenObjects::scan(const Common::Point &pt, int layer) {
 	for (uint i = 1; i <= size(); ++i) {
 		ScreenObject &sObj = (*this)[i];
-		if (sObj._active && sObj._bounds.contains(pt) && sObj._layer == layer)
+		if (sObj._active && sObj._bounds.contains(pt) && sObj._mode == layer)
 			return i;
 	}
 
@@ -376,7 +376,7 @@ int ScreenObjects::scan(const Common::Point &pt, int layer) {
 int ScreenObjects::scanBackwards(const Common::Point &pt, int layer) {
 	for (int i = (int)size(); i >= 1; --i) {
 		ScreenObject &sObj = (*this)[i];
-		if (sObj._active && sObj._bounds.contains(pt) && sObj._layer == layer)
+		if (sObj._active && sObj._bounds.contains(pt) && sObj._mode == layer)
 			return i;
 	}
 
@@ -526,7 +526,7 @@ void ScreenObjects::elementHighlighted() {
 	action._pickedWord = newIndex;
 
 	if (_category == CAT_INV_LIST || _category == CAT_INV_ANIM) {
-		if (action._interAwaiting == 1 && newIndex >= 0 && _released &&
+		if (action._interAwaiting == AWAITING_COMMAND && newIndex >= 0 && _released &&
 				(!_vm->_events->_mouseReleased || !_vm->_easyMouse))
 			newIndex = -1;
 	}
@@ -540,7 +540,7 @@ void ScreenObjects::elementHighlighted() {
 }
 
 void ScreenObjects::setActive(ScrCategory category, int descId, bool active) {
-	for (uint idx = 1; idx < size(); ++idx) {
+	for (uint idx = 1; idx <= size(); ++idx) {
 		ScreenObject &sObj = (*this)[idx];
 		if (sObj._category == category && sObj._descId == descId)
 			sObj._active = active;
@@ -571,7 +571,7 @@ void ScreenSurface::init() {
 }
 
 ScreenSurface::~ScreenSurface() {
-	delete[] _surfacePixels;
+	::free(_surfacePixels);
 }
 
 void ScreenSurface::copyRectToScreen(const Common::Rect &bounds) {
@@ -609,9 +609,10 @@ void ScreenSurface::updateScreen() {
 
 void ScreenSurface::transition(ScreenTransition transitionType, bool surfaceFlag) {
 	Palette &pal = *_vm->_palette;
+	Scene &scene = _vm->_game->_scene;
 	byte palData[PALETTE_SIZE];
 
-	switch (transitionType) {
+ 	switch (transitionType) {
 	case kTransitionFadeIn:
 	case kTransitionFadeOutIn:
 		Common::fill(&pal._colorValues[0], &pal._colorValues[3], 0);
@@ -641,8 +642,9 @@ void ScreenSurface::transition(ScreenTransition transitionType, bool surfaceFlag
 
 	case kTransitionPanLeftToRight:
 	case kTransitionPanRightToLeft:
-		warning("TODO: pan transition");
-		transition(kTransitionFadeIn, surfaceFlag);
+		panTransition(scene._backgroundSurface, pal._mainPalette,
+			transitionType - kTransitionPanLeftToRight,
+			Common::Point(0, 0), scene._posAdjust, THROUGH_BLACK2, true, 1);
 		break;
 
 	case kTransitionCircleIn1:
@@ -653,8 +655,10 @@ void ScreenSurface::transition(ScreenTransition transitionType, bool surfaceFlag
 		transition(kTransitionFadeIn, surfaceFlag);
 		break;
 
-	case kCenterVertTransition:
-		warning("TODO: center vert transition");
+	case kNullPaletteCopy:
+		// Original temporarily set the palette to black, copied the scene to the
+		// screen, and then restored the palette. We can give a similiar effect
+		// by doing a standard quick palette fade in
 		transition(kTransitionFadeIn, surfaceFlag);
 		break;
 
@@ -674,5 +678,143 @@ void ScreenSurface::resetClipBounds() {
 	setClipBounds(Common::Rect(0, 0, MADS_SCREEN_WIDTH, MADS_SCREEN_HEIGHT));
 }
 
+void ScreenSurface::panTransition(MSurface &newScreen, byte *palData, int entrySide,
+		const Common::Point &srcPos, const Common::Point &destPos,
+		ThroughBlack throughBlack, bool setPalette, int numTicks) {
+	EventsManager &events = *_vm->_events;
+	Palette &palette = *_vm->_palette;
+	Common::Point size;
+	int y1, y2;
+	int startX = 0;
+	int deltaX;
+	int xAt;
+	int loopStart;
+//	uint32 baseTicks, currentTicks;
+	byte paletteMap[256];
+
+	size.x = MIN(newScreen.w, (uint16)MADS_SCREEN_WIDTH);
+	size.y = newScreen.h;
+	if (newScreen.h >= MADS_SCREEN_HEIGHT)
+		size.y = MADS_SCENE_HEIGHT;
+
+	// Set starting position and direction delta for the transition
+	if (entrySide == 1)
+		// Right to left
+		startX = size.x - 1;
+	deltaX = startX ? -1 : 1;
+
+	if (setPalette & !throughBlack)
+		palette.setFullPalette(palData);
+
+	// TODO: Original uses a different frequency ticks counter. Need to
+	// confirm frequency and see whether we need to implement it, or
+	// if the current frame ticks can substitute for it
+//	baseTicks = events.getFrameCounter();
+
+	y1 = 0;
+	y2 = size.y - 1;
+//	sizeY = y2 - y1 + 1;
+
+	if (throughBlack == THROUGH_BLACK2)
+		swapForeground(palData, &paletteMap[0]);
+
+	loopStart = throughBlack == THROUGH_BLACK1 ? 0 : 1;
+	for (int loop = loopStart; loop < 2; ++loop) {
+		xAt = startX;
+		for (int xCtr = 0; xCtr < size.x; ++xCtr, xAt += deltaX) {
+			if (!loop) {
+				fillRect(Common::Rect(xAt + destPos.x, y1 + destPos.y,
+					xAt + destPos.x + 1, y2 + destPos.y), 0);
+			} else if (throughBlack == THROUGH_BLACK2) {
+				copyRectTranslate(newScreen, paletteMap,
+					Common::Point(xAt, destPos.y),
+					Common::Rect(srcPos.x + xAt, srcPos.y,
+					srcPos.x + xAt + 1, srcPos.y + size.y));
+			} else {
+				newScreen.copyRectToSurface(*this, xAt, destPos.y,
+					Common::Rect(srcPos.x + xAt, srcPos.y, 
+					srcPos.x + xAt + 1, srcPos.y + size.y));
+			}
+
+			copyRectToScreen(Common::Rect(xAt, destPos.y, xAt + 1, destPos.y + size.y));
+
+			// Slight delay
+			events.pollEvents();
+			g_system->delayMillis(1);
+		}
+
+		if ((setPalette && !loop) || throughBlack == THROUGH_BLACK2)
+			palette.setFullPalette(palData);
+	}
+
+	if (throughBlack == THROUGH_BLACK2) {
+		Common::Rect r(srcPos.x, srcPos.y, srcPos.x + size.x, srcPos.y + size.y);
+		copyRectToSurface(newScreen, destPos.x, destPos.y, r);
+		copyRectToScreen(r);
+	}
+}
+
+/**
+ * Translates the current screen from the old palette to the new palette
+ */
+void ScreenSurface::swapForeground(byte newPalette[PALETTE_SIZE], byte *paletteMap) {
+	Palette &palette = *_vm->_palette;
+	byte oldPalette[PALETTE_SIZE];
+	byte oldMap[PALETTE_COUNT];
+
+	palette.getFullPalette(oldPalette);
+	swapPalette(oldPalette, oldMap, true);
+	swapPalette(newPalette, paletteMap, false);
+
+	// Transfer translated foreground colors. Since foregrounds are interleaved
+	// with background, we only copy over each alternate RGB tuplet
+	const byte *srcP = &newPalette[RGB_SIZE];
+	byte *destP = &oldPalette[RGB_SIZE];
+	while (destP < &oldPalette[PALETTE_SIZE]) {
+		Common::copy(srcP, srcP + RGB_SIZE, destP);
+		srcP += 2 * RGB_SIZE;
+		destP += 2 * RGB_SIZE;
+	}
+
+	Common::Rect oldClip = _clipBounds;
+	resetClipBounds();
+	
+	copyRectTranslate(*this, oldMap, Common::Point(0, 0), 
+		Common::Rect(0, 0, MADS_SCREEN_WIDTH, MADS_SCREEN_HEIGHT));
+	palette.setFullPalette(oldPalette);
+
+	setClipBounds(oldClip);
+}
+
+/**
+ * Translates a given palette into a mapping table.
+ * Palettes consist of 128 RGB entries for the foreground and background
+ * respectively, with the two interleaved together. So the start 
+ */
+void ScreenSurface::swapPalette(const byte *palData, byte swapTable[PALETTE_COUNT], 
+		bool foreground) {
+	int start = foreground ? 1 : 0;
+	const byte *dynamicList = &palData[start * RGB_SIZE];
+	int staticStart = 1 - start;
+	const byte *staticList = &palData[staticStart * RGB_SIZE];
+	const int PALETTE_START = 1;
+	const int PALETTE_END = 252;
+
+	// Set initial index values
+	for (int idx = 0; idx < PALETTE_COUNT; ++idx)
+		swapTable[idx] = idx;
+
+	// Handle the 128 palette entries for the foreground or background
+	for (int idx = 0; idx < (PALETTE_COUNT / 2); ++idx) {
+		if (start >= PALETTE_START && start <= PALETTE_END) {
+			swapTable[start] = Palette::closestColor(dynamicList, staticList, 
+				2 * RGB_SIZE, PALETTE_COUNT / 2) * 2 + staticStart;
+		}
+
+		dynamicList += 2 * RGB_SIZE;
+		start += 2;
+	}
+}
+
 
 } // End of namespace MADS
diff --git a/engines/mads/screen.h b/engines/mads/screen.h
index 9d01ca82e3..d910e88633 100644
--- a/engines/mads/screen.h
+++ b/engines/mads/screen.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -33,8 +33,8 @@ namespace MADS {
 #define MADS_SCREEN_WIDTH 320
 #define MADS_SCREEN_HEIGHT 200
 
-enum Layer {
-	LAYER_GUI = 19
+enum ScreenMode {
+	SCREENMODE_VGA = 19
 };
 
 enum ScreenTransition {
@@ -47,7 +47,7 @@ enum ScreenTransition {
 	kTransitionCircleIn3, kTransitionCircleIn4,
 	kVertTransition1, kVertTransition2, kVertTransition3,
 	kVertTransition4, kVertTransition5, kVertTransition6,
-	kVertTransition7, kCenterVertTransition
+	kVertTransition7, kNullPaletteCopy
 };
 
 enum InputMode {
@@ -56,6 +56,11 @@ enum InputMode {
 	kInputLimitedSentences = 2		// Use only scene hotspots
 };
 
+enum ThroughBlack {
+	THROUGH_BLACK1 = 1,
+	THROUGH_BLACK2 = 2
+};
+
 class SpriteSlot;
 class TextDisplay;
 class UISlot;
@@ -130,7 +135,7 @@ public:
 	Common::Rect _bounds;
 	ScrCategory _category;
 	int _descId;
-	int _layer;
+	int _mode;
 
 	ScreenObject();
 };
@@ -162,7 +167,7 @@ public:
 	/**
 	* Add a new item to the list
 	*/
-	void add(const Common::Rect &bounds, Layer layer, ScrCategory category, int descId);
+	ScreenObject *add(const Common::Rect &bounds, ScreenMode mode, ScrCategory category, int descId);
 
 	/**
 	 * Check objects on the screen
@@ -207,6 +212,14 @@ private:
 	uint16 _random;
 	byte *_surfacePixels;
 	Common::Rect _clipBounds;
+
+	void panTransition(MSurface &newScreen, byte *palData, int entrySide,
+		const Common::Point &srcPos, const Common::Point &destPos,
+		ThroughBlack throughBlack, bool setPalette, int numTicks);
+
+	void swapForeground(byte newPalette[PALETTE_SIZE], byte *paletteMap);
+
+	void swapPalette(const byte palData[PALETTE_SIZE], byte swapTable[PALETTE_COUNT], bool foreground);
 public:
 	int _shakeCountdown;
 public:
diff --git a/engines/mads/sequence.cpp b/engines/mads/sequence.cpp
index 05f00afb5a..e5bf1631c2 100644
--- a/engines/mads/sequence.cpp
+++ b/engines/mads/sequence.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -95,8 +95,8 @@ bool SequenceList::addSubEntry(int index, SequenceTrigger mode, int frameIndex,
 }
 
 int SequenceList::add(int spriteListIndex, bool flipped, int frameIndex, int triggerCountdown, int delayTicks, int extraTicks, int numTicks,
-	int msgX, int msgY, bool nonFixed, int scale, int depth, int frameInc, SpriteAnimType animType, int numSprites,
-	int frameStart) {
+		int msgX, int msgY, bool nonFixed, int scale, int depth, int frameInc, SpriteAnimType animType, int numSprites,
+		int frameStart) {
 	Scene &scene = _vm->_game->_scene;
 
 	// Find a free slot
@@ -144,7 +144,7 @@ int SequenceList::add(int spriteListIndex, bool flipped, int frameIndex, int tri
 	return seqIndex;
 }
 
-int SequenceList::addTimer(int timeout, int abortVal) {
+int SequenceList::addTimer(int timeout, int endTrigger) {
 	Scene &scene = _vm->_game->_scene;
 	uint seqIndex;
 	for (seqIndex = 0; seqIndex < _entries.size(); ++seqIndex) {
@@ -164,7 +164,7 @@ int SequenceList::addTimer(int timeout, int abortVal) {
 	se._entries._count = 0;
 	se._triggerMode = _vm->_game->_triggerSetupMode;
 	se._actionNouns = _vm->_game->_scene._action._activeAction;
-	addSubEntry(seqIndex, SEQUENCE_TRIGGER_EXPIRE, 0, abortVal);
+	addSubEntry(seqIndex, SEQUENCE_TRIGGER_EXPIRE, 0, endTrigger);
 
 	return seqIndex;
 }
@@ -181,6 +181,19 @@ void SequenceList::remove(int seqIndex) {
 	scene._spriteSlots.deleteTimer(seqIndex);
 }
 
+int SequenceList::findByTrigger(int trigger) {
+	for (uint idx = 0; idx < _entries.size(); ++idx) {
+		if (_entries[idx]._active) {
+			for (int subIdx = 0; subIdx < _entries[idx]._entries._count; ++subIdx) {
+				if (_entries[idx]._entries._trigger[subIdx] == trigger)
+					return idx;
+			}
+		}
+	}
+
+	return -1;
+}
+
 void SequenceList::setSpriteSlot(int seqIndex, SpriteSlot &spriteSlot) {
 	Scene &scene = _vm->_game->_scene;
 	SequenceEntry &timerEntry = _entries[seqIndex];
@@ -466,28 +479,28 @@ int SequenceList::startCycle(int srcSpriteIndex, bool flipped, int cycleIndex) {
 	return result;
 }
 
-int SequenceList::startReverseCycle(int srcSpriteIndex, bool flipped, int numTicks,
+int SequenceList::startPingPongCycle(int srcSpriteIndex, bool flipped, int numTicks,
 		int triggerCountdown, int timeoutTicks, int extraTicks) {
 	SpriteAsset *sprites = _vm->_game->_scene._sprites[srcSpriteIndex];
 	MSprite *frame = sprites->getFrame(0);
 	int depth = _vm->_game->_scene._depthSurface.getDepth(Common::Point(
 		frame->_offset.x + frame->w / 2, frame->_offset.y + frame->h / 2));
 
-	return add(srcSpriteIndex, flipped, sprites->getCount(), triggerCountdown, timeoutTicks,
-		extraTicks, numTicks, 0, 0, true, 100, depth - 1, -1, ANIMTYPE_REVERSIBLE, 0, 0);
+	return add(srcSpriteIndex, flipped, 1, triggerCountdown, timeoutTicks,
+		extraTicks, numTicks, 0, 0, true, 100, depth - 1, 1, ANIMTYPE_PING_PONG, 0, 0);
 }
 
-void SequenceList::updateTimeout(int spriteIdx, int seqIndex) {
+void SequenceList::updateTimeout(int srcSeqIndex, int destSeqIndex) {
 	Player &player = _vm->_game->_player;
 	int timeout;
 
-	if (spriteIdx >= 0)
-		timeout = _entries[spriteIdx]._timeout;
+	if (srcSeqIndex >= 0)
+		timeout = _entries[srcSeqIndex]._timeout;
 	else
 		timeout = player._priorTimer + player._ticksAmount;
 
-	if (seqIndex >= 0)
-		_entries[seqIndex]._timeout = timeout;
+	if (destSeqIndex >= 0)
+		_entries[destSeqIndex]._timeout = timeout;
 	else
 		player._priorTimer = timeout - player._ticksAmount;
 
@@ -526,8 +539,7 @@ void SequenceList::setMotion(int seqIndex, int flags, int deltaX, int deltaY) {
 
 	if (deltaY > 0) {
 		se._posSign.y = 1;
-	}
-	else if (deltaY < 0) {
+	} else if (deltaY < 0) {
 		se._posSign.y = -1;
 	} else {
 		se._posSign.y = 0;
diff --git a/engines/mads/sequence.h b/engines/mads/sequence.h
index ee587ff02d..c3a277c5a5 100644
--- a/engines/mads/sequence.h
+++ b/engines/mads/sequence.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -38,7 +38,7 @@ enum SequenceTrigger {
 	SEQUENCE_TRIGGER_SPRITE = 2		// Trigger when sequence reaches specific sprite
 };
 
-enum SpriteAnimType { ANIMTYPE_NONE = 0, ANIMTYPE_CYCLED = 1, ANIMTYPE_REVERSIBLE = 2 };
+enum SpriteAnimType { ANIMTYPE_NONE = 0, ANIMTYPE_CYCLED = 1, ANIMTYPE_PING_PONG = 2 };
 
 #define SEQUENCE_ENTRY_SUBSET_MAX 5
 
@@ -101,8 +101,9 @@ public:
 		int extraTicks, int numTicks, int msgX, int msgY, bool nonFixed, int scale, int depth,
 		int frameInc, SpriteAnimType animType, int numSprites, int frameStart);
 
-	int addTimer(int timeout, int abortVal);
+	int addTimer(int timeout, int endTrigger);
 	void remove(int seqIndex);
+	int findByTrigger(int trigger);
 	void setSpriteSlot(int seqIndex, SpriteSlot &spriteSlot);
 	bool loadSprites(int seqIndex);
 	void tick();
@@ -117,9 +118,9 @@ public:
 		int triggerCountdown = 0, int timeoutTicks = 0, int extraTicks = 0);
 
 	int startCycle(int srcSpriteIdx, bool flipped, int cycleIndex);
-	int startReverseCycle(int srcSpriteIndex, bool flipped, int numTicks,
+	int startPingPongCycle(int srcSpriteIndex, bool flipped, int numTicks,
 		int triggerCountdown = 0, int timeoutTicks = 0, int extraTicks = 0);
-	void updateTimeout(int spriteIdx, int seqIndex);
+	void updateTimeout(int destSeqIndex, int srcSeqIndex);
 	void setScale(int spriteIdx, int scale);
 	void setMsgLayout(int seqIndex);
 	void setDone(int seqIndex);
diff --git a/engines/mads/sound.cpp b/engines/mads/sound.cpp
index 1652550ba3..4a35edb80f 100644
--- a/engines/mads/sound.cpp
+++ b/engines/mads/sound.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -21,6 +21,7 @@
  */
 
 #include "audio/audiostream.h"
+#include "audio/fmopl.h"
 #include "audio/decoders/raw.h"
 #include "common/memstream.h"
 #include "mads/sound.h"
@@ -36,9 +37,10 @@ SoundManager::SoundManager(MADSEngine *vm, Audio::Mixer *mixer) {
 	_pollSoundEnabled = false;
 	_soundPollFlag = false;
 	_newSoundsPaused = false;
+	_masterVolume = 255;
 
 	_opl = OPL::Config::create();
-	_opl->init(11025);
+	_opl->init();
 
 	// Validate sound files
 	switch (_vm->getGameID()) {
@@ -62,6 +64,9 @@ SoundManager::~SoundManager() {
 void SoundManager::init(int sectionNumber) {
 	assert(sectionNumber > 0 && sectionNumber < 10);
 
+	if (_driver != nullptr)
+		delete _driver;
+
 	switch (_vm->getGameID()) {
 	case GType_RexNebular:
 		switch (sectionNumber) {
@@ -94,15 +99,18 @@ void SoundManager::init(int sectionNumber) {
 			break;
 		default:
 			_driver = nullptr;
-			break;
+			return;
 		}
 		break;
 
 	default:
 		warning("SoundManager: Unknown game");
 		_driver = nullptr;
-		break;
+		return;
 	}
+
+	// Set volume for newly loaded driver
+	_driver->setVolume(_masterVolume);
 }
 
 void SoundManager::closeDriver() {
@@ -138,12 +146,22 @@ void SoundManager::startQueuedCommands() {
 	}
 }
 
+void SoundManager::setVolume(int volume) {
+	_masterVolume = volume;
+
+	if (_driver)
+		_driver->setVolume(volume);
+}
+
 void SoundManager::command(int commandId, int param) {
 	if (_newSoundsPaused) {
 		if (_queuedCommands.size() < 8)
 			_queuedCommands.push(commandId);
 	} else if (_driver) {
-		_driver->command(commandId, param);
+		// Note: I don't know any way to identify music commands versus sfx
+		// commands, so if sfx is mute, then so is music
+		if (_vm->_soundFlag)
+			_driver->command(commandId, param);
 	}
 }
 
diff --git a/engines/mads/sound.h b/engines/mads/sound.h
index 72bb21a812..9882f65e5a 100644
--- a/engines/mads/sound.h
+++ b/engines/mads/sound.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -37,12 +37,13 @@ class SoundManager {
 private:
 	MADSEngine *_vm;
 	Audio::Mixer *_mixer;
-	FM_OPL *_opl;
+	OPL::OPL *_opl;
 	Nebular::ASound *_driver;
 	bool _pollSoundEnabled;
 	bool _soundPollFlag;
 	bool _newSoundsPaused;
 	Common::Queue<int> _queuedCommands;
+	int _masterVolume;
 public:
 	SoundManager(MADSEngine *vm, Audio::Mixer *mixer);
 	~SoundManager();
@@ -78,6 +79,11 @@ public:
 	 */
 	void startQueuedCommands();
 
+	/**
+	 * Set the master volume
+	 */
+	void setVolume(int volume);
+
 	//@{
 	/**
 	 * Executes a command on the sound driver
diff --git a/engines/mads/sprites.cpp b/engines/mads/sprites.cpp
index fd73930475..0a1c0b710d 100644
--- a/engines/mads/sprites.cpp
+++ b/engines/mads/sprites.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -347,8 +347,10 @@ void SpriteSlots::drawSprites(MSurface *s) {
 				spr->copyTo(s, Common::Point(xp, yp), sprite->getTransparencyIndex());
 
 				// Free sprite if it was a flipped one
-				if (flipped)
+				if (flipped) {
+					spr->free();
 					delete spr;
+				}
 			}
 		}
 	}
@@ -368,22 +370,18 @@ SpriteSets::~SpriteSets() {
 }
 
 int SpriteSets::add(SpriteAsset *asset, int idx) {
-	if (idx)
-		idx = idx + 49;
-	else
-		idx = size();
-
-	if (idx >= (int)size())
-		resize(idx + 1);
+	if (idx) {
+		assert(idx == 1);
+		delete _uiSprites;
+		_uiSprites = asset;
 
-	if ((*this)[idx]) {
-		delete (*this)[idx];
+		return SPRITE_SLOTS_MAX_SIZE;
 	} else {
-		++_assetCount;
-	}
+		assert(size() < SPRITE_SLOTS_MAX_SIZE);
+		push_back(asset);
 
-	(*this)[idx] = asset;
-	return idx;
+		return (int)size() - 1;
+	}
 }
 
 int SpriteSets::addSprites(const Common::String &resName, int flags) {
@@ -393,25 +391,32 @@ int SpriteSets::addSprites(const Common::String &resName, int flags) {
 void SpriteSets::clear() {
 	for (uint i = 0; i < size(); ++i)
 		delete (*this)[i];
-
-	_assetCount = 0;
 	Common::Array<SpriteAsset *>::clear();
+
+	delete _uiSprites;
+	_uiSprites = nullptr;
 }
 
 void SpriteSets::remove(int idx) {
-	if (idx >= 0) {
+	if (idx == SPRITE_SLOTS_MAX_SIZE) {
+		delete _uiSprites;
+		_uiSprites = nullptr;
+	} else if (idx >= 0 && idx < (int)size()) {
+		delete (*this)[idx];
+
 		if (idx < ((int)size() - 1)) {
-			delete (*this)[idx];
 			(*this)[idx] = nullptr;
 		} else {
 			do {
 				remove_at(size() - 1);
 			} while (size() > 0 && (*this)[size() - 1] == nullptr);
 		}
-
-		if (_assetCount > 0)
-			--_assetCount;
 	}
 }
 
+SpriteAsset *&SpriteSets::operator[](int idx) {
+	return (idx == SPRITE_SLOTS_MAX_SIZE) ? _uiSprites :
+		Common::Array<SpriteAsset *>::operator[](idx);
+}
+
 } // End of namespace MADS
diff --git a/engines/mads/sprites.h b/engines/mads/sprites.h
index 6ea3c9e52e..3db922c40b 100644
--- a/engines/mads/sprites.h
+++ b/engines/mads/sprites.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -202,12 +202,12 @@ class SpriteSets : public Common::Array<SpriteAsset *> {
 private:
 	MADSEngine *_vm;
 public:
-	int _assetCount;
-
+	SpriteAsset *_uiSprites;
+public:
 	/**
 	 * Constructor
 	 */
-	SpriteSets(MADSEngine *vm) : _vm(vm), _assetCount(0) {}
+	SpriteSets(MADSEngine *vm) : _vm(vm), _uiSprites(nullptr) {}
 
 	/**
 	 * Destructor
@@ -233,6 +233,8 @@ public:
 	 * Remove an asset from the list
 	 */
 	void remove(int idx);
+
+	SpriteAsset *&operator[](int idx);
 };
 
 } // End of namespace MADS
diff --git a/engines/mads/staticres.cpp b/engines/mads/staticres.cpp
index 189e5f72e7..b659d9a27c 100644
--- a/engines/mads/staticres.cpp
+++ b/engines/mads/staticres.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/staticres.h b/engines/mads/staticres.h
index 560fd12e67..b805729327 100644
--- a/engines/mads/staticres.h
+++ b/engines/mads/staticres.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
diff --git a/engines/mads/user_interface.cpp b/engines/mads/user_interface.cpp
index 1f8d5037bc..62fd036c03 100644
--- a/engines/mads/user_interface.cpp
+++ b/engines/mads/user_interface.cpp
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -164,6 +164,7 @@ void UISlots::draw(bool updateFlag, bool delFlag) {
 						MSurface *spr = sprite->flipHorizontal();
 						userInterface.mergeFrom(spr, spr->getBounds(), slot._position,
 							sprite->getTransparencyIndex());
+						spr->free();
 						delete spr;
 					} else {
 						userInterface.mergeFrom(sprite, sprite->getBounds(), slot._position,
@@ -410,13 +411,21 @@ void UserInterface::setup(InputMode inputMode) {
 }
 
 void UserInterface::drawTextElements() {
-	if (_vm->_game->_screenObjects._inputMode) {
-		drawConversationList();
-	} else {
+	switch (_vm->_game->_screenObjects._inputMode) {
+	case kInputBuildingSentences:
 		// Draw the actions
 		drawActions();
 		drawInventoryList();
 		drawItemVocabList();
+		break;
+
+	case kInputConversation:
+		drawConversationList();
+		break;
+
+	case kInputLimitedSentences:
+	default:
+		break;
 	}
 }
 
@@ -495,7 +504,6 @@ void UserInterface::drawScroller() {
 
 void UserInterface::updateInventoryScroller() {
 	ScreenObjects &screenObjects = _vm->_game->_screenObjects;
-	Common::Array<int> &inventoryList = _vm->_game->_objects._inventoryList;
 
 	if (screenObjects._inputMode != kInputBuildingSentences)
 		return;
@@ -515,48 +523,11 @@ void UserInterface::updateInventoryScroller() {
 				uint32 timeInc = _scrollbarQuickly ? 100 : 380;
 
 				if (_vm->_events->_mouseStatus && (_scrollbarMilliTime + timeInc) <= currentMilli) {
-					_scrollbarQuickly = _vm->_events->_vD2 < 1;
+					_scrollbarQuickly = _vm->_events->_strokeGoing < 1;
 					_scrollbarMilliTime = currentMilli;
 
-					switch (_scrollbarStrokeType) {
-					case SCROLLBAR_UP:
-						// Scroll up
-						if (_inventoryTopIndex > 0 && inventoryList.size() > 0) {
-							--_inventoryTopIndex;
-							_inventoryChanged = true;
-						}
-						break;
-
-					case SCROLLBAR_DOWN:
-						// Scroll down
-						if (_inventoryTopIndex < ((int)inventoryList.size() - 1) && inventoryList.size() > 1) {
-							++_inventoryTopIndex;
-							_inventoryChanged = true;
-						}
-						break;
-
-					case SCROLLBAR_ELEVATOR: {
-						// Inventory slider
-						int newIndex = CLIP((int)_vm->_events->currentPos().y - 170, 0, 17)
-							* inventoryList.size() / 10;
-						if (newIndex >= (int)inventoryList.size())
-							newIndex = inventoryList.size() - 1;
-
-						if (inventoryList.size() > 0) {
-							_inventoryChanged = newIndex != _inventoryTopIndex;
-							_inventoryTopIndex = newIndex;
-						}
-						break;
-					}
-
-					default:
-						break;
-					}
-
-					if (_inventoryChanged) {
-						int dummy;
-						updateSelection(CAT_INV_LIST, 0, &dummy);
-					}
+					// Change the scrollbar and visible inventory list
+					changeScrollBar();
 				}
 			}
 		}
@@ -569,6 +540,54 @@ void UserInterface::updateInventoryScroller() {
 	_scrollbarOldElevator = _scrollbarElevator;
 }
 
+void UserInterface::changeScrollBar() {
+	Common::Array<int> &inventoryList = _vm->_game->_objects._inventoryList;
+	ScreenObjects &screenObjects = _vm->_game->_screenObjects;
+
+	if (screenObjects._inputMode != kInputBuildingSentences)
+		return;
+
+	switch (_scrollbarStrokeType) {
+	case SCROLLBAR_UP:
+		// Scroll up
+		if (_inventoryTopIndex > 0 && inventoryList.size() > 0) {
+			--_inventoryTopIndex;
+			_inventoryChanged = true;
+		}
+		break;
+
+	case SCROLLBAR_DOWN:
+		// Scroll down
+		if (_inventoryTopIndex < ((int)inventoryList.size() - 1) && inventoryList.size() > 1) {
+			++_inventoryTopIndex;
+			_inventoryChanged = true;
+		}
+		break;
+
+	case SCROLLBAR_ELEVATOR: {
+		// Inventory slider
+		int newIndex = CLIP((int)_vm->_events->currentPos().y - 170, 0, 17)
+			* inventoryList.size() / 10;
+		if (newIndex >= (int)inventoryList.size())
+			newIndex = inventoryList.size() - 1;
+
+		if (inventoryList.size() > 0) {
+			_inventoryChanged = newIndex != _inventoryTopIndex;
+			_inventoryTopIndex = newIndex;
+		}
+		break;
+	}
+
+	default:
+		break;
+	}
+
+	if (_inventoryChanged) {
+		int dummy;
+		updateSelection(CAT_INV_LIST, 0, &dummy);
+	}
+}
+
 void UserInterface::scrollbarChanged() {
 	Common::Rect r(73, 4, 73 + 9, 4 + 38);
 	_uiSlots.add(r);
@@ -673,7 +692,7 @@ void UserInterface::loadElements() {
 			getBounds(CAT_INV_SCROLLER, idx, bounds);
 			moveRect(bounds);
 
-			_vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_INV_SCROLLER, idx);
+			_vm->_game->_screenObjects.add(bounds, SCREENMODE_VGA, CAT_INV_SCROLLER, idx);
 		}
 
 		// Set up actions
@@ -682,7 +701,7 @@ void UserInterface::loadElements() {
 			getBounds(CAT_COMMAND, idx, bounds);
 			moveRect(bounds);
 
-			_vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_COMMAND, idx);
+			_vm->_game->_screenObjects.add(bounds, SCREENMODE_VGA, CAT_COMMAND, idx);
 		}
 
 		// Set up inventory list
@@ -691,7 +710,7 @@ void UserInterface::loadElements() {
 			getBounds(CAT_INV_LIST, _inventoryTopIndex + idx, bounds);
 			moveRect(bounds);
 
-			_vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_INV_LIST, idx);
+			_vm->_game->_screenObjects.add(bounds, SCREENMODE_VGA, CAT_INV_LIST, idx);
 		}
 
 		// Set up the inventory vocab list
@@ -700,12 +719,12 @@ void UserInterface::loadElements() {
 			getBounds(CAT_INV_VOCAB, idx, bounds);
 			moveRect(bounds);
 
-			_vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_INV_VOCAB, idx);
+			_vm->_game->_screenObjects.add(bounds, SCREENMODE_VGA, CAT_INV_VOCAB, idx);
 		}
 
 		// Set up the inventory item picture
 		_categoryIndexes[CAT_INV_ANIM - 1] = _vm->_game->_screenObjects.size() + 1;
-		_vm->_game->_screenObjects.add(Common::Rect(160, 159, 231, 194), LAYER_GUI,
+		_vm->_game->_screenObjects.add(Common::Rect(160, 159, 231, 194), SCREENMODE_VGA,
 			CAT_INV_ANIM, 0);
 	}
 
@@ -714,7 +733,9 @@ void UserInterface::loadElements() {
 		_categoryIndexes[CAT_HOTSPOT - 1] = _vm->_game->_screenObjects.size() + 1;
 		for (int hotspotIdx = scene._hotspots.size() - 1; hotspotIdx >= 0; --hotspotIdx) {
 			Hotspot &hs = scene._hotspots[hotspotIdx];
-			_vm->_game->_screenObjects.add(hs._bounds, LAYER_GUI, CAT_HOTSPOT, hotspotIdx);
+			ScreenObject *so = _vm->_game->_screenObjects.add(hs._bounds, SCREENMODE_VGA, 
+				CAT_HOTSPOT, hotspotIdx);
+			so->_active = hs._active;
 		}
 	}
 
@@ -725,7 +746,7 @@ void UserInterface::loadElements() {
 			getBounds(CAT_TALK_ENTRY, idx, bounds);
 			moveRect(bounds);
 
-			_vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_TALK_ENTRY, idx);
+			_vm->_game->_screenObjects.add(bounds, SCREENMODE_VGA, CAT_TALK_ENTRY, idx);
 		}
 	}
 
@@ -833,23 +854,24 @@ void UserInterface::emptyConversationList() {
 }
 
 void UserInterface::addConversationMessage(int vocabId, const Common::String &msg) {
-	assert(_talkStrings.size() < 5);
-
-	_talkStrings.push_back(msg);
-	_talkIds.push_back(vocabId);
+	// Only allow a maximum of 5 talk entries to be displayed
+	if (_talkStrings.size() < 5) {
+		_talkStrings.push_back(msg);
+		_talkIds.push_back(vocabId);
+	}
 }
 
 void UserInterface::loadInventoryAnim(int objectId) {
 	Scene &scene = _vm->_game->_scene;
 	noInventoryAnim();
 
-	if (_vm->_invObjectsAnimated) {
-		Common::String resName = Common::String::format("*OB%.3dI", objectId);
-		SpriteAsset *asset = new SpriteAsset(_vm, resName, ASSET_SPINNING_OBJECT);
-		_invSpritesIndex = scene._sprites.add(asset, 1);
-		if (_invSpritesIndex >= 0) {
-			_invFrameNumber = 1;
-		}
+	// WORKAROUND: Even in still mode, we now load the animation frames for the
+	// object, so we can show the first frame as a 'still'
+	Common::String resName = Common::String::format("*OB%.3dI", objectId);
+	SpriteAsset *asset = new SpriteAsset(_vm, resName, ASSET_SPINNING_OBJECT);
+	_invSpritesIndex = scene._sprites.add(asset, 1);
+	if (_invSpritesIndex >= 0) {
+		_invFrameNumber = 1;
 	}
 }
 
@@ -881,10 +903,13 @@ void UserInterface::inventoryAnim() {
 			_invSpritesIndex < 0)
 		return;
 
-	// Move to the next frame number in the sequence, resetting if at the end
-	SpriteAsset *asset = scene._sprites[_invSpritesIndex];
-	if (++_invFrameNumber > asset->getCount())
-		_invFrameNumber = 1;
+	// WORKAROUND: Fix still inventory display, which was broken in the original
+	if (_vm->_invObjectsAnimated) {
+		// Move to the next frame number in the sequence, resetting if at the end
+		SpriteAsset *asset = scene._sprites[_invSpritesIndex];
+		if (++_invFrameNumber > asset->getCount())
+			_invFrameNumber = 1;
+	}
 
 	// Loop through the slots list for inventory animation entry
 	for (uint i = 0; i < _uiSlots.size(); ++i) {
diff --git a/engines/mads/user_interface.h b/engines/mads/user_interface.h
index 89044c9bf1..1366aa2c32 100644
--- a/engines/mads/user_interface.h
+++ b/engines/mads/user_interface.h
@@ -8,12 +8,12 @@
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
-
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
-
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@@ -140,7 +140,6 @@ private:
 	bool _scrollFlag;
 	int _noSegmentsActive;
 	int _someSegmentsActive;
-	ScrollbarActive _scrollbarStrokeType;
 
 	/**
 	 * Loads the elements of the user interface
@@ -216,6 +215,7 @@ public:
 	bool _scrollbarQuickly;
 	uint32 _scrollbarMilliTime;
 	int _scrollbarElevator, _scrollbarOldElevator;
+	ScrollbarActive _scrollbarStrokeType;
 public:
 	/**
 	* Constructor
@@ -275,6 +275,11 @@ public:
 
 	void updateSelection(ScrCategory category, int newIndex, int *idx);
 
+	/**
+	* Updates the current top visible item of the scrollbar
+	*/
+	void changeScrollBar();
+
 	void scrollerChanged();
 
 	void scrollInventory();
diff --git a/engines/mohawk/configure.engine b/engines/mohawk/configure.engine
index fa9d15cffc..47402c4560 100644
--- a/engines/mohawk/configure.engine
+++ b/engines/mohawk/configure.engine
@@ -3,4 +3,4 @@
 add_engine mohawk "Mohawk" yes "cstime myst riven" "Living Books"
 add_engine cstime "Where in Time is Carmen Sandiego?" no
 add_engine riven "Riven: The Sequel to Myst" no "" "" "16bit"
-add_engine myst "Myst" no "" "" "16bit"
+add_engine myst "Myst" no
diff --git a/engines/mohawk/console.cpp b/engines/mohawk/console.cpp
index d49f3e8637..9b5bae78be 100644
--- a/engines/mohawk/console.cpp
+++ b/engines/mohawk/console.cpp
@@ -248,9 +248,9 @@ bool MystConsole::Cmd_PlayMovie(int argc, const char **argv) {
 		return true;
 	}
 
-	int8 stackNum = 0;
-
+	Common::String fileName;
 	if (argc == 3 || argc > 4) {
+		int8 stackNum = 0;
 		for (byte i = 1; i <= ARRAYSIZE(mystStackNames); i++)
 			if (!scumm_stricmp(argv[2], mystStackNames[i - 1])) {
 				stackNum = i;
@@ -261,16 +261,27 @@ bool MystConsole::Cmd_PlayMovie(int argc, const char **argv) {
 			debugPrintf("\'%s\' is not a stack name!\n", argv[2]);
 			return true;
 		}
+
+		fileName = _vm->wrapMovieFilename(argv[1], stackNum - 1);
+	} else {
+		fileName = argv[1];
 	}
 
-	if (argc == 2)
-		_vm->_video->playMovie(argv[1], 0, 0);
-	else if (argc == 3)
-		_vm->_video->playMovie(_vm->wrapMovieFilename(argv[1], stackNum - 1), 0, 0);
-	else if (argc == 4)
-		_vm->_video->playMovie(argv[1], atoi(argv[2]), atoi(argv[3]));
-	else
-		_vm->_video->playMovie(_vm->wrapMovieFilename(argv[1], stackNum - 1), atoi(argv[3]), atoi(argv[4]));
+	VideoHandle handle = _vm->_video->playMovie(fileName);
+	if (!handle) {
+		debugPrintf("Failed to open movie '%s'\n", fileName.c_str());
+		return true;
+	}
+
+	if (argc == 4) {
+		handle->setX(atoi(argv[2]));
+		handle->setY(atoi(argv[3]));
+	} else if (argc > 4) {
+		handle->setX(atoi(argv[3]));
+		handle->setY(atoi(argv[4]));
+	} else {
+		handle->center();
+	}
 
 	return false;
 }
diff --git a/engines/mohawk/cursors.cpp b/engines/mohawk/cursors.cpp
index f1baac02e2..4b66829e6a 100644
--- a/engines/mohawk/cursors.cpp
+++ b/engines/mohawk/cursors.cpp
@@ -122,7 +122,11 @@ void MystCursorManager::setCursor(uint16 id) {
 	// Myst ME stores some cursors as 24bpp images instead of 8bpp
 	if (surface->format.bytesPerPixel == 1) {
 		CursorMan.replaceCursor(surface->getPixels(), surface->w, surface->h, hotspotX, hotspotY, 0);
-		CursorMan.replaceCursorPalette(mhkSurface->getPalette(), 0, 256);
+
+		// We're using the screen palette for the original game, but we need
+		// to use this for any 8bpp cursor in ME.
+		if (_vm->getFeatures() & GF_ME)
+			CursorMan.replaceCursorPalette(mhkSurface->getPalette(), 0, 256);
 	} else {
 		Graphics::PixelFormat pixelFormat = g_system->getScreenFormat();
 		CursorMan.replaceCursor(surface->getPixels(), surface->w, surface->h, hotspotX, hotspotY, pixelFormat.RGBToColor(255, 255, 255), false, &pixelFormat);
diff --git a/engines/mohawk/detection_tables.h b/engines/mohawk/detection_tables.h
index 7632cde294..6bb836b5b8 100644
--- a/engines/mohawk/detection_tables.h
+++ b/engines/mohawk/detection_tables.h
@@ -1379,6 +1379,22 @@ static const MohawkGameDescription gameDescriptions[] = {
 		"GRANDMA.EXE"
 	},
 
+	// Just Grandma and Me 1.0, Macintosh
+	{
+		{
+			"grandma",
+			"v1.0",
+			AD_ENTRY1("BookOutline", "9162483da06179e76f4a082412245efa"),
+			Common::EN_ANY,
+			Common::kPlatformMacintosh,
+			ADGF_NO_FLAGS,
+			GUIO1(GUIO_NOASPECT)
+		},
+		GType_LIVINGBOOKSV1,
+		GF_LB_10,
+		0
+	},
+
 	// Just Grandma and Me 1.1 Mac
 	// From eisnerguy1 in bug#3610725
 	{
diff --git a/engines/mohawk/livingbooks.cpp b/engines/mohawk/livingbooks.cpp
index 998ef048f6..5af8fac901 100644
--- a/engines/mohawk/livingbooks.cpp
+++ b/engines/mohawk/livingbooks.cpp
@@ -363,6 +363,44 @@ void MohawkEngine_LivingBooks::destroyPage() {
 	_focus = NULL;
 }
 
+// Replace any colons (originally a slash) with another character
+static Common::String replaceColons(const Common::String &in, char replace) {
+	Common::String out;
+
+	for (uint32 i = 0; i < in.size(); i++) {
+		if (in[i] == ':')
+			out += replace;
+		else
+			out += in[i];
+	}
+
+	return out;
+}
+
+// Helper function to assist in opening pages
+static bool tryOpenPage(Archive *archive, const Common::String &fileName) {
+	// Try the plain file name first
+	if (archive->openFile(fileName))
+		return true;
+
+	// No colons, then bail out
+	if (!fileName.contains(':'))
+		return false;
+
+	// Try replacing colons with underscores (in case the original was
+	// a Mac version and had slashes not as a separator).
+	if (archive->openFile(replaceColons(fileName, '_')))
+		return true;
+
+	// Try replacing colons with slashes (in case the original was a Mac
+	// version and had slashes as a separator).
+	if (archive->openFile(replaceColons(fileName, '/')))
+		return true;
+
+	// Failed to open the archive
+	return false;
+}
+
 bool MohawkEngine_LivingBooks::loadPage(LBMode mode, uint page, uint subpage) {
 	destroyPage();
 
@@ -410,7 +448,7 @@ bool MohawkEngine_LivingBooks::loadPage(LBMode mode, uint page, uint subpage) {
 	}
 
 	Archive *pageArchive = createArchive();
-	if (!filename.empty() && pageArchive->openFile(filename)) {
+	if (!filename.empty() && tryOpenPage(pageArchive, filename)) {
 		_page = new LBPage(this);
 		_page->open(pageArchive, 1000);
 	} else {
@@ -824,18 +862,18 @@ int MohawkEngine_LivingBooks::getIntFromConfig(const Common::String &section, co
 
 Common::String MohawkEngine_LivingBooks::getFileNameFromConfig(const Common::String &section, const Common::String &key, Common::String &leftover) {
 	Common::String string = getStringFromConfig(section, key, leftover);
-	Common::String x;
 
-	uint32 i = 0;
 	if (string.hasPrefix("//")) {
 		// skip "//CD-ROM Title/" prefixes which we don't care about
-		i = 3;
+		uint i = 3;
 		while (i < string.size() && string[i - 1] != '/')
 			i++;
+
+		// Already uses slashes, no need to convert further
+		return string.c_str() + i;
 	}
-	x = string.c_str() + i;
 
-	return (getPlatform() == Common::kPlatformMacintosh) ? convertMacFileName(x) : convertWinFileName(x);
+	return (getPlatform() == Common::kPlatformMacintosh) ? convertMacFileName(string) : convertWinFileName(string);
 }
 
 Common::String MohawkEngine_LivingBooks::removeQuotesFromString(const Common::String &string, Common::String &leftover) {
@@ -866,8 +904,10 @@ Common::String MohawkEngine_LivingBooks::convertMacFileName(const Common::String
 	for (uint32 i = 0; i < string.size(); i++) {
 		if (i == 0 && string[i] == ':') // First character should be ignored (another colon)
 			continue;
-		if (string[i] == ':')
+		if (string[i] == ':') // Directory separator
 			filename += '/';
+		else if (string[i] == '/') // Literal slash
+			filename += ':'; // Replace by colon, as used by Mac OS X for slash
 		else
 			filename += string[i];
 	}
@@ -3772,7 +3812,7 @@ LBMovieItem::~LBMovieItem() {
 void LBMovieItem::update() {
 	if (_playing) {
 		VideoHandle videoHandle = _vm->_video->findVideoHandle(_resourceId);
-		if (videoHandle == NULL_VID_HANDLE || _vm->_video->endOfVideo(videoHandle))
+		if (!videoHandle || videoHandle->endOfVideo())
 			done(true);
 	}
 
@@ -3783,8 +3823,11 @@ bool LBMovieItem::togglePlaying(bool playing, bool restart) {
 	if (playing) {
 		if ((_loaded && _enabled && _globalEnabled) || _phase == kLBPhaseNone) {
 			debug("toggled video for phase %d", _phase);
-			_vm->_video->playMovie(_resourceId, _rect.left, _rect.top);
+			VideoHandle handle = _vm->_video->playMovie(_resourceId);
+			if (!handle)
+				error("Failed to open tMOV %d", _resourceId);
 
+			handle->moveTo(_rect.left, _rect.top);
 			return true;
 		}
 	}
@@ -3808,9 +3851,9 @@ bool LBMiniGameItem::togglePlaying(bool playing, bool restart) {
 	// just skip to the most logical page. For optional minigames, this
 	// will return the player to the previous page. For mandatory minigames,
 	// this will send the player to the next page.
-	// TODO: Document mini games from Arthur's Reading Race
 
-	uint16 destPage;
+	uint16 destPage = 0;
+	bool returnToMenu = false;
 
 	// Figure out what minigame we have and bring us back to a page where
 	// the player can continue
@@ -3820,13 +3863,31 @@ bool LBMiniGameItem::togglePlaying(bool playing, bool restart) {
 		destPage = 5;
 	else if (_desc == "Fall") // Green Eggs and Ham: Fall minigame
 		destPage = 13;
+	else if (_desc == "MagicWrite3") // Arthur's Reading Race: "Let Me Write" minigame (Page 3)
+		destPage = 3;
+	else if (_desc == "MagicWrite4") // Arthur's Reading Race: "Let Me Write" minigame (Page 4)
+		destPage = 4;
+	else if (_desc == "MagicSpy5") // Arthur's Reading Race: "I Spy" minigame (Page 5)
+		destPage = 5;
+	else if (_desc == "MagicSpy6") // Arthur's Reading Race: "I Spy" minigame (Page 6)
+		destPage = 6;
+	else if (_desc == "MagicWrite7") // Arthur's Reading Race: "Let Me Write" minigame (Page 7)
+		destPage = 7;
+	else if (_desc == "MagicSpy8") // Arthur's Reading Race: "I Spy" minigame (Page 8)
+		destPage = 8;
+	else if (_desc == "MagicRace") // Arthur's Reading Race: Race minigame
+		returnToMenu = true;
 	else
 		error("Unknown minigame '%s'", _desc.c_str());
 
 	GUI::MessageDialog dialog(Common::String::format("The '%s' minigame is not supported yet.", _desc.c_str()));
 	dialog.runModal();
 
-	_vm->addNotifyEvent(NotifyEvent(kLBNotifyChangePage, destPage));
+	// Go back to the menu if requested, otherwise go to the requested page
+	if (returnToMenu)
+		_vm->addNotifyEvent(NotifyEvent(kLBNotifyGoToControls, 1));
+	else 
+		_vm->addNotifyEvent(NotifyEvent(kLBNotifyChangePage, destPage));
 
 	return false;
 }
@@ -3863,7 +3924,7 @@ void LBProxyItem::load() {
 
 	debug(1, "LBProxyItem loading archive '%s' with id %d", filename.c_str(), baseId);
 	Archive *pageArchive = _vm->createArchive();
-	if (!pageArchive->openFile(filename))
+	if (!tryOpenPage(pageArchive, filename))
 		error("failed to open archive '%s' (for proxy '%s')", filename.c_str(), _desc.c_str());
 	_page = new LBPage(_vm);
 	_page->open(pageArchive, baseId);
diff --git a/engines/mohawk/livingbooks_code.cpp b/engines/mohawk/livingbooks_code.cpp
index 6dcd8c3ce7..b5ea547414 100644
--- a/engines/mohawk/livingbooks_code.cpp
+++ b/engines/mohawk/livingbooks_code.cpp
@@ -842,8 +842,8 @@ CodeCommandInfo generalCommandInfo[NUM_GENERAL_COMMANDS] = {
 	{ "bottom", &LBCode::cmdBottom },
 	// 0x10
 	{ "right", &LBCode::cmdRight },
-	{ "xpos", 0 },
-	{ "ypos", 0 },
+	{ "xpos", &LBCode::cmdXPos },
+	{ "ypos", &LBCode::cmdYPos },
 	{ "playFrom", 0 },
 	{ "move", &LBCode::cmdMove },
 	{ 0, 0 },
@@ -852,13 +852,13 @@ CodeCommandInfo generalCommandInfo[NUM_GENERAL_COMMANDS] = {
 	{ "resetDragParams", 0 },
 	{ "enableRollover", &LBCode::cmdUnimplemented /* FIXME */ },
 	{ "setCursor", 0 },
-	{ "width", 0 },
-	{ "height", 0 },
+	{ "width", &LBCode::cmdWidth },
+	{ "height", &LBCode::cmdHeight },
 	{ "getFrameBounds", 0 }, // also "getFrameRect"
 	{ "traceRect", 0 },
 	{ "sqrt", 0 },
 	// 0x20
-	{ "deleteVar", 0 },
+	{ "deleteVar", &LBCode::cmdDeleteVar },
 	{ "saveVars", 0 },
 	{ "scriptLink", 0 },
 	{ "setViewOrigin", &LBCode::cmdUnimplemented },
@@ -1131,6 +1131,38 @@ void LBCode::cmdRight(const Common::Array<LBValue> &params) {
 	_stack.push(rect.right);
 }
 
+void LBCode::cmdXPos(const Common::Array<LBValue> &params) {
+	if (params.size() != 1)
+		error("too many parameters (%d) to xpos", params.size());
+
+	Common::Point point = params[0].toPoint();
+	_stack.push(point.x);
+}
+
+void LBCode::cmdYPos(const Common::Array<LBValue> &params) {
+	if (params.size() != 1)
+		error("too many parameters (%d) to ypos", params.size());
+
+	Common::Point point = params[0].toPoint();
+	_stack.push(point.y);
+}
+
+void LBCode::cmdWidth(const Common::Array<LBValue> &params) {
+	if (params.size() > 1)
+		error("too many parameters (%d) to width", params.size());
+
+	Common::Rect rect = getRectFromParams(params);
+	_stack.push(rect.width());
+}
+
+void LBCode::cmdHeight(const Common::Array<LBValue> &params) {
+	if (params.size() > 1)
+		error("too many parameters (%d) to height", params.size());
+
+	Common::Rect rect = getRectFromParams(params);
+	_stack.push(rect.height());
+}
+
 void LBCode::cmdMove(const Common::Array<LBValue> &params) {
 	if (params.size() != 1 && params.size() != 2)
 		error("incorrect number of parameters (%d) to move", params.size());
@@ -1263,6 +1295,14 @@ void LBCode::cmdGetProperty(const Common::Array<LBValue> &params) {
 	_stack.push(target->_variables[name]);
 }
 
+void LBCode::cmdDeleteVar(const Common::Array<LBValue> &params) {
+	if (params.size() != 1)
+		error("incorrect number of parameters (%d) to deleteVar", params.size());
+
+	const Common::String &string = params[0].toString();
+	_vm->_variables.erase(string);
+}
+
 void LBCode::cmdExec(const Common::Array<LBValue> &params) {
 	if (params.size() != 1)
 		error("incorrect number of parameters (%d) to exec", params.size());
@@ -1706,6 +1746,10 @@ uint LBCode::parseCode(const Common::String &source) {
 		if (token != ' ' && token != '(' && wasFunction)
 			error("while parsing script '%s', encountered incomplete function call", source.c_str());
 
+		// Skip C++-style comments
+		if (token == '/' && lookahead == '/')
+			break;
+
 		// First, we check for simple operators.
 		for (uint i = 0; i < NUM_LB_OPERATORS; i++) {
 			if (token != operators[i].token)
@@ -1736,6 +1780,7 @@ uint LBCode::parseCode(const Common::String &source) {
 		switch (token) {
 		// whitespace
 		case ' ':
+		case '\t':
 			// ignore
 			break;
 		// literal string
diff --git a/engines/mohawk/livingbooks_code.h b/engines/mohawk/livingbooks_code.h
index 080377ce99..6f6297d592 100644
--- a/engines/mohawk/livingbooks_code.h
+++ b/engines/mohawk/livingbooks_code.h
@@ -263,6 +263,10 @@ public:
 	void cmdLeft(const Common::Array<LBValue> &params);
 	void cmdBottom(const Common::Array<LBValue> &params);
 	void cmdRight(const Common::Array<LBValue> &params);
+	void cmdXPos(const Common::Array<LBValue> &params);
+	void cmdYPos(const Common::Array<LBValue> &params);
+	void cmdWidth(const Common::Array<LBValue> &params);
+	void cmdHeight(const Common::Array<LBValue> &params);
 	void cmdMove(const Common::Array<LBValue> &params);
 	void cmdSetDragParams(const Common::Array<LBValue> &params);
 	void cmdNewList(const Common::Array<LBValue> &params);
@@ -273,6 +277,7 @@ public:
 	void cmdDeleteAt(const Common::Array<LBValue> &params);
 	void cmdSetProperty(const Common::Array<LBValue> &params);
 	void cmdGetProperty(const Common::Array<LBValue> &params);
+	void cmdDeleteVar(const Common::Array<LBValue> &params);
 	void cmdExec(const Common::Array<LBValue> &params);
 	void cmdReturn(const Common::Array<LBValue> &params);
 	void cmdSetPlayParams(const Common::Array<LBValue> &params);
diff --git a/engines/mohawk/myst.cpp b/engines/mohawk/myst.cpp
index 7634e8d88a..b6a6c27329 100644
--- a/engines/mohawk/myst.cpp
+++ b/engines/mohawk/myst.cpp
@@ -413,7 +413,12 @@ void MohawkEngine_Myst::changeToStack(uint16 stack, uint16 card, uint16 linkSrcS
 
 	// Fill screen with black and empty cursor
 	_cursor->setCursor(0);
-	_system->fillScreen(_system->getScreenFormat().RGBToColor(0, 0, 0));
+
+	if (getFeatures() & GF_ME)
+		_system->fillScreen(_system->getScreenFormat().RGBToColor(0, 0, 0));
+	else
+		_gfx->clearScreenPalette();
+
 	_system->updateScreen();
 
 	_sound->stopSound();
@@ -495,9 +500,10 @@ void MohawkEngine_Myst::changeToStack(uint16 stack, uint16 card, uint16 linkSrcS
 	_cache.clear();
 	_gfx->clearCache();
 
-	// Play Flyby Entry Movie on Masterpiece Edition.
-	const char *flyby = 0;
 	if (getFeatures() & GF_ME) {
+		// Play Flyby Entry Movie on Masterpiece Edition.
+		const char *flyby = 0;
+
 		switch (_curStack) {
 		case kSeleniticStack:
 			flyby = "selenitic flyby";
diff --git a/engines/mohawk/myst_areas.cpp b/engines/mohawk/myst_areas.cpp
index 4a3001774a..7a9596d8e0 100644
--- a/engines/mohawk/myst_areas.cpp
+++ b/engines/mohawk/myst_areas.cpp
@@ -223,20 +223,26 @@ VideoHandle MystResourceType6::playMovie() {
 	VideoHandle handle = _vm->_video->findVideoHandle(_videoFile);
 
 	// If the video is not running, play it
-	if (handle == NULL_VID_HANDLE || _vm->_video->endOfVideo(handle)) {
-		handle = _vm->_video->playMovie(_videoFile, _left, _top, _loop);
+	if (!handle || handle->endOfVideo()) {
+		handle = _vm->_video->playMovie(_videoFile);
+		if (!handle)
+			error("Failed to open '%s'", _videoFile.c_str());
+
+		handle->moveTo(_left, _top);
+		handle->setLooping(_loop != 0);
+
 		if (_direction == -1) {
-			_vm->_video->seekToTime(handle, _vm->_video->getDuration(handle));
-			_vm->_video->setVideoRate(handle, -1);
+			handle->seek(handle->getDuration());
+			handle->setRate(-1);
 		}
 	} else {
 		// Resume the video
-		_vm->_video->pauseMovie(handle, false);
+		handle->pause(false);
 	}
 
 	if (_playBlocking) {
 		_vm->_video->waitUntilMovieEnds(handle);
-		handle = NULL_VID_HANDLE;
+		return VideoHandle();
 	}
 
 	return handle;
@@ -249,13 +255,13 @@ void MystResourceType6::handleCardChange() {
 
 bool MystResourceType6::isPlaying() {
 	VideoHandle handle = _vm->_video->findVideoHandle(_videoFile);
-	return handle != NULL_VID_HANDLE && !_vm->_video->endOfVideo(handle);
+	return handle && !handle->endOfVideo();
 }
 
 void MystResourceType6::pauseMovie(bool pause) {
 	VideoHandle handle = _vm->_video->findVideoHandle(_videoFile);
-	if (handle != NULL_VID_HANDLE && !_vm->_video->endOfVideo(handle))
-		_vm->_video->pauseMovie(handle, pause);
+	if (handle && !handle->endOfVideo())
+		handle->pause(pause);
 }
 
 MystResourceType7::MystResourceType7(MohawkEngine_Myst *vm, Common::SeekableReadStream *rlstStream, MystResource *parent) : MystResource(vm, rlstStream, parent) {
diff --git a/engines/mohawk/myst_graphics.cpp b/engines/mohawk/myst_graphics.cpp
index 9ea9f15444..49f97cca63 100644
--- a/engines/mohawk/myst_graphics.cpp
+++ b/engines/mohawk/myst_graphics.cpp
@@ -28,6 +28,7 @@
 #include "common/system.h"
 #include "common/textconsole.h"
 #include "engines/util.h"
+#include "graphics/palette.h"
 #include "image/pict.h"
 
 namespace Mohawk {
@@ -37,16 +38,20 @@ MystGraphics::MystGraphics(MohawkEngine_Myst* vm) : GraphicsManager(), _vm(vm) {
 
 	_viewport = Common::Rect(544, 332);
 
-	// The original version of Myst could run in 8bpp color too.
-	// However, it dithered videos to 8bpp and they looked considerably
-	// worse (than they already did :P). So we're not even going to
-	// support 8bpp mode in Myst (Myst ME required >8bpp anyway).
-	initGraphics(_viewport.width(), _viewport.height(), true, NULL); // What an odd screen size!
+	if (_vm->getFeatures() & GF_ME) {
+		// High color
+		initGraphics(_viewport.width(), _viewport.height(), true, NULL);
 
-	_pixelFormat = _vm->_system->getScreenFormat();
+		if (_vm->_system->getScreenFormat().bytesPerPixel == 1)
+			error("Myst ME requires greater than 256 colors to run");
+	} else {
+		// Paletted
+		initGraphics(_viewport.width(), _viewport.height(), true);
+		setBasePalette();
+		setPaletteToScreen();
+	}
 
-	if (_pixelFormat.bytesPerPixel == 1)
-		error("Myst requires greater than 256 colors to run");
+	_pixelFormat = _vm->_system->getScreenFormat();
 
 	// Initialize our buffer
 	_backBuffer = new Graphics::Surface();
@@ -101,7 +106,9 @@ MohawkSurface *MystGraphics::decodeImage(uint16 id) {
 		mhkSurface = new MohawkSurface(pict.getSurface()->convertTo(_pixelFormat));
 	} else {
 		mhkSurface = _bmpDecoder->decodeImage(dataStream);
-		mhkSurface->convertToTrueColor();
+
+		if (_vm->getFeatures() & GF_ME)
+			mhkSurface->convertToTrueColor();
 	}
 
 	assert(mhkSurface);
@@ -151,7 +158,8 @@ void MystGraphics::copyImageSectionToScreen(uint16 image, Common::Rect src, Comm
 }
 
 void MystGraphics::copyImageSectionToBackBuffer(uint16 image, Common::Rect src, Common::Rect dest) {
-	Graphics::Surface *surface = findImage(image)->getSurface();
+	MohawkSurface *mhkSurface = findImage(image);
+	Graphics::Surface *surface = mhkSurface->getSurface();
 
 	// Make sure the image is bottom aligned in the dest rect
 	dest.top = dest.bottom - MIN<int>(surface->h, dest.height());
@@ -190,6 +198,13 @@ void MystGraphics::copyImageSectionToBackBuffer(uint16 image, Common::Rect src,
 
 	for (uint16 i = 0; i < height; i++)
 		memcpy(_backBuffer->getBasePtr(dest.left, i + dest.top), surface->getBasePtr(src.left, top + i), width * surface->format.bytesPerPixel);
+
+	if (!(_vm->getFeatures() & GF_ME)) {
+		// Make sure the palette is set
+		assert(mhkSurface->getPalette());
+		memcpy(_palette + 10 * 3, mhkSurface->getPalette() + 10 * 3, (256 - 10 * 2) * 3);
+		setPaletteToScreen();
+	}
 }
 
 void MystGraphics::copyImageToScreen(uint16 image, Common::Rect dest) {
@@ -419,12 +434,16 @@ void MystGraphics::transitionDissolve(Common::Rect rect, uint step) {
 
 		for (uint16 x = rect.left; x < rect.right; x++) {
 			if (linePattern[x % 4]) {
-				if (_pixelFormat.bytesPerPixel == 2) {
-					uint16 *dst = (uint16 *)screen->getBasePtr(x, y);
-					*dst = *(const uint16 *)_backBuffer->getBasePtr(x, y);
-				} else {
-					uint32 *dst = (uint32 *)screen->getBasePtr(x, y);
-					*dst = *(const uint32 *)_backBuffer->getBasePtr(x, y);
+				switch (_pixelFormat.bytesPerPixel) {
+				case 1:
+					*((byte *)screen->getBasePtr(x, y)) = *((const byte *)_backBuffer->getBasePtr(x, y));
+					break;
+				case 2:
+					*((uint16 *)screen->getBasePtr(x, y)) = *((const uint16 *)_backBuffer->getBasePtr(x, y));
+					break;
+				case 4:
+					*((uint32 *)screen->getBasePtr(x, y)) = *((const uint32 *)_backBuffer->getBasePtr(x, y));
+					break;
 				}
 			}
 		}
@@ -588,11 +607,11 @@ void MystGraphics::drawRect(Common::Rect rect, RectState state) {
 	Graphics::Surface *screen = _vm->_system->lockScreen();
 
 	if (state == kRectEnabled)
-		screen->frameRect(rect, _pixelFormat.RGBToColor(0, 255, 0));
+		screen->frameRect(rect, (_vm->getFeatures() & GF_ME) ? _pixelFormat.RGBToColor(0, 255, 0) : 250);
 	else if (state == kRectUnreachable)
-		screen->frameRect(rect, _pixelFormat.RGBToColor(0, 0, 255));
+		screen->frameRect(rect, (_vm->getFeatures() & GF_ME) ? _pixelFormat.RGBToColor(0, 0, 255) : 252);
 	else
-		screen->frameRect(rect, _pixelFormat.RGBToColor(255, 0, 0));
+		screen->frameRect(rect, (_vm->getFeatures() & GF_ME) ? _pixelFormat.RGBToColor(255, 0, 0) : 249);
 
 	_vm->_system->unlockScreen();
 }
@@ -629,50 +648,94 @@ void MystGraphics::simulatePreviousDrawDelay(const Common::Rect &dest) {
 	_nextAllowedDrawTime = time + _constantDrawDelay + dest.height() * dest.width() / _proportionalDrawDelay;
 }
 
-void MystGraphics::copyBackBufferToScreenWithSaturation(int16 saturation) {
-	Graphics::Surface *screen = _vm->_system->lockScreen();
+void MystGraphics::fadeToBlack() {
+	// This is only for the demo
+	assert(!(_vm->getFeatures() & GF_ME));
 
-	for (uint16 y = 0; y < _viewport.height(); y++)
-		for (uint16 x = 0; x < _viewport.width(); x++) {
-			uint32 color;
-			uint8 r, g, b;
+	// Linear fade in 64 steps
+	for (int i = 63; i >= 0; i--) {
+		byte palette[256 * 3];
+		byte *src = _palette;
+		byte *dst = palette;
 
-			if (_pixelFormat.bytesPerPixel == 2)
-				color = *(const uint16 *)_backBuffer->getBasePtr(x, y);
-			else
-				color = *(const uint32 *)_backBuffer->getBasePtr(x, y);
+		for (uint j = 0; j < sizeof(palette); j++)
+			*dst++ = *src++ * i / 64;
 
-			_pixelFormat.colorToRGB(color, r, g, b);
+		_vm->_system->getPaletteManager()->setPalette(palette, 0, 256);
+		_vm->_system->updateScreen();
+	}
+}
 
-			r = CLIP<int16>((int16)r - saturation, 0, 255);
-			g = CLIP<int16>((int16)g - saturation, 0, 255);
-			b = CLIP<int16>((int16)b - saturation, 0, 255);
+void MystGraphics::fadeFromBlack() {
+	// This is only for the demo
+	assert(!(_vm->getFeatures() & GF_ME));
 
-			color = _pixelFormat.RGBToColor(r, g, b);
+	copyBackBufferToScreen(_viewport);
 
-			if (_pixelFormat.bytesPerPixel == 2) {
-				uint16 *dst = (uint16 *)screen->getBasePtr(x, y);
-				*dst = color;
-			} else {
-				uint32 *dst = (uint32 *)screen->getBasePtr(x, y);
-				*dst = color;
-			}
-		}
+	// Linear fade in 64 steps
+	for (int i = 0; i < 64; i++) {
+		byte palette[256 * 3];
+		byte *src = _palette;
+		byte *dst = palette;
 
-	_vm->_system->unlockScreen();
+		for (uint j = 0; j < sizeof(palette); j++)
+			*dst++ = *src++ * i / 64;
+
+		_vm->_system->getPaletteManager()->setPalette(palette, 0, 256);
+		_vm->_system->updateScreen();
+	}
+
+	// Set the full palette
+	_vm->_system->getPaletteManager()->setPalette(_palette, 0, 256);
 	_vm->_system->updateScreen();
 }
 
-void MystGraphics::fadeToBlack() {
-	for (int16 i = 0; i < 256; i += 32) {
-		copyBackBufferToScreenWithSaturation(i);
-	}
+void MystGraphics::clearScreenPalette() {
+	// Set the palette to all black
+	byte palette[256 * 3];
+	memset(palette, 0, sizeof(palette));
+	_vm->_system->getPaletteManager()->setPalette(palette, 0, 256);
 }
 
-void MystGraphics::fadeFromBlack() {
-	for (int16 i = 256; i >= 0; i -= 32) {
-		copyBackBufferToScreenWithSaturation(i);
-	}
+void MystGraphics::setBasePalette() {
+	// Entries [0, 9] of the palette
+	static const byte lowPalette[] = {
+		0xFF, 0xFF, 0xFF,
+		0x80, 0x00, 0x00,
+		0x00, 0x80, 0x00,
+		0x80, 0x80, 0x00,
+		0x00, 0x00, 0x80,
+		0x80, 0x00, 0x80,
+		0x00, 0x80, 0x80,
+		0xC0, 0xC0, 0xC0,
+		0xC0, 0xDC, 0xC0,
+		0xA6, 0xCA, 0xF0
+	};
+
+	// Entries [246, 255] of the palette
+	static const byte highPalette[] = {
+		0xFF, 0xFB, 0xF0,
+		0xA0, 0xA0, 0xA4,
+		0x80, 0x80, 0x80,
+		0xFF, 0x00, 0x00,
+		0x00, 0xFF, 0x00,
+		0xFF, 0xFF, 0x00,
+		0x00, 0x00, 0xFF,
+		0xFF, 0x00, 0xFF,
+		0x00, 0xFF, 0xFF,
+		0x00, 0x00, 0x00
+	};
+
+	// Note that 0 and 255 are different from normal Windows.
+	// Myst seems to hack that to white, resp. black (probably for Mac compat).
+
+	memcpy(_palette, lowPalette, sizeof(lowPalette));
+	memset(_palette + sizeof(lowPalette), 0, sizeof(_palette) - sizeof(lowPalette) - sizeof(highPalette));
+	memcpy(_palette + sizeof(_palette) - sizeof(highPalette), highPalette, sizeof(highPalette));
+}
+
+void MystGraphics::setPaletteToScreen() {
+	_vm->_system->getPaletteManager()->setPalette(_palette, 0, 256);
 }
 
 } // End of namespace Mohawk
diff --git a/engines/mohawk/myst_graphics.h b/engines/mohawk/myst_graphics.h
index 1f70320bf6..6281c94cc8 100644
--- a/engines/mohawk/myst_graphics.h
+++ b/engines/mohawk/myst_graphics.h
@@ -40,7 +40,7 @@ enum RectState {
 
 class MystGraphics : public GraphicsManager {
 public:
-	MystGraphics(MohawkEngine_Myst*);
+	MystGraphics(MohawkEngine_Myst *vm);
 	~MystGraphics();
 
 	void copyImageSectionToScreen(uint16 image, Common::Rect src, Common::Rect dest);
@@ -55,18 +55,15 @@ public:
 	void fadeToBlack();
 	void fadeFromBlack();
 
+	void clearScreenPalette();
+	void setBasePalette();
+	void setPaletteToScreen();
+	const byte *getPalette() const { return _palette; }
+
 protected:
 	MohawkSurface *decodeImage(uint16 id);
 	MohawkEngine *getVM() { return (MohawkEngine *)_vm; }
-	void simulatePreviousDrawDelay(const Common::Rect &dest);
-	void copyBackBufferToScreenWithSaturation(int16 saturation);
-	void transitionDissolve(Common::Rect rect, uint step);
-	void transitionSlideToLeft(Common::Rect rect, uint16 steps, uint16 delay);
-	void transitionSlideToRight(Common::Rect rect, uint16 steps, uint16 delay);
-	void transitionSlideToTop(Common::Rect rect, uint16 steps, uint16 delay);
-	void transitionSlideToBottom(Common::Rect rect, uint16 steps, uint16 delay);
-	void transitionPartialToRight(Common::Rect rect, uint32 width, uint32 steps);
-	void transitionPartialToLeft(Common::Rect rect, uint32 width, uint32 steps);
+
 private:
 	MohawkEngine_Myst *_vm;
 	MystBitmap *_bmpDecoder;
@@ -74,11 +71,21 @@ private:
 	Graphics::Surface *_backBuffer;
 	Graphics::PixelFormat _pixelFormat;
 	Common::Rect _viewport;
+	byte _palette[256 * 3];
 
 	int _enableDrawingTimeSimulation;
 	uint32 _nextAllowedDrawTime;
 	static const uint _constantDrawDelay = 10; // ms
 	static const uint _proportionalDrawDelay = 500; // pixels per ms
+
+	void simulatePreviousDrawDelay(const Common::Rect &dest);
+	void transitionDissolve(Common::Rect rect, uint step);
+	void transitionSlideToLeft(Common::Rect rect, uint16 steps, uint16 delay);
+	void transitionSlideToRight(Common::Rect rect, uint16 steps, uint16 delay);
+	void transitionSlideToTop(Common::Rect rect, uint16 steps, uint16 delay);
+	void transitionSlideToBottom(Common::Rect rect, uint16 steps, uint16 delay);
+	void transitionPartialToRight(Common::Rect rect, uint32 width, uint32 steps);
+	void transitionPartialToLeft(Common::Rect rect, uint32 width, uint32 steps);
 };
 
 } // End of namespace Mohawk
diff --git a/engines/mohawk/myst_stacks/channelwood.cpp b/engines/mohawk/myst_stacks/channelwood.cpp
index 2dd5745550..dfa15a9b6c 100644
--- a/engines/mohawk/myst_stacks/channelwood.cpp
+++ b/engines/mohawk/myst_stacks/channelwood.cpp
@@ -299,13 +299,17 @@ bool Channelwood::pipeChangeValve(bool open, uint16 mask) {
 void Channelwood::o_bridgeToggle(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
 	debugC(kDebugScript, "Opcode %d: Bridge rise / skink video", op);
 
-	VideoHandle bridge = _vm->_video->playMovie(_vm->wrapMovieFilename("bridge", kChannelwoodStack), 292, 203);
+	VideoHandle bridge = _vm->_video->playMovie(_vm->wrapMovieFilename("bridge", kChannelwoodStack));
+	if (!bridge)
+		error("Failed to open 'bridge' movie");
+
+	bridge->moveTo(292, 203);
 
 	// Toggle bridge state
 	if (_state.waterPumpBridgeState)
-		_vm->_video->setVideoBounds(bridge, Audio::Timestamp(0, 3050, 600), Audio::Timestamp(0, 6100, 600));
+		bridge->setBounds(Audio::Timestamp(0, 3050, 600), Audio::Timestamp(0, 6100, 600));
 	else
-		_vm->_video->setVideoBounds(bridge, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 3050, 600));
+		bridge->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 3050, 600));
 
 	_vm->_video->waitUntilMovieEnds(bridge);
 }
@@ -317,13 +321,17 @@ void Channelwood::o_pipeExtend(uint16 op, uint16 var, uint16 argc, uint16 *argv)
 	debugC(kDebugScript, "\tsoundId: %d", soundId);
 
 	_vm->_sound->replaceSoundMyst(soundId);
-	VideoHandle pipe = _vm->_video->playMovie(_vm->wrapMovieFilename("pipebrid", kChannelwoodStack), 267, 170);
+	VideoHandle pipe = _vm->_video->playMovie(_vm->wrapMovieFilename("pipebrid", kChannelwoodStack));
+	if (!pipe)
+		error("Failed to open 'pipebrid' movie");
+
+	pipe->moveTo(267, 170);
 
 	// Toggle pipe state
 	if (_state.pipeState)
-		_vm->_video->setVideoBounds(pipe, Audio::Timestamp(0, 3040, 600), Audio::Timestamp(0, 6080, 600));
+		pipe->setBounds(Audio::Timestamp(0, 3040, 600), Audio::Timestamp(0, 6080, 600));
 	else
-		_vm->_video->setVideoBounds(pipe, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 3040, 600));
+		pipe->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 3040, 600));
 
 	_vm->_video->waitUntilMovieEnds(pipe);
 	_vm->_sound->resumeBackgroundMyst();
@@ -605,23 +613,29 @@ void Channelwood::o_hologramMonitor(uint16 op, uint16 var, uint16 argc, uint16 *
 
 		_vm->_video->stopVideos();
 
+		VideoHandle handle;
+
 		switch (button) {
 		case 0:
-			_vm->_video->playMovie(_vm->wrapMovieFilename("monalgh", kChannelwoodStack), 227, 70);
+			handle = _vm->_video->playMovie(_vm->wrapMovieFilename("monalgh", kChannelwoodStack));
 			break;
 		case 1:
-			_vm->_video->playMovie(_vm->wrapMovieFilename("monamth", kChannelwoodStack), 227, 70);
+			handle = _vm->_video->playMovie(_vm->wrapMovieFilename("monamth", kChannelwoodStack));
 			break;
 		case 2:
-			_vm->_video->playMovie(_vm->wrapMovieFilename("monasirs", kChannelwoodStack), 227, 70);
+			handle = _vm->_video->playMovie(_vm->wrapMovieFilename("monasirs", kChannelwoodStack));
 			break;
 		case 3:
-			_vm->_video->playMovie(_vm->wrapMovieFilename("monsmsg", kChannelwoodStack), 227, 70);
+			handle = _vm->_video->playMovie(_vm->wrapMovieFilename("monsmsg", kChannelwoodStack));
 			break;
 		default:
 			warning("Opcode %d Control Variable Out of Range", op);
 			break;
 		}
+
+		// Move the video to the right location
+		if (handle)
+			handle->moveTo(227, 70);
 	}
 }
 
diff --git a/engines/mohawk/myst_stacks/dni.cpp b/engines/mohawk/myst_stacks/dni.cpp
index 3eb3c40cbb..6ba0b63423 100644
--- a/engines/mohawk/myst_stacks/dni.cpp
+++ b/engines/mohawk/myst_stacks/dni.cpp
@@ -103,14 +103,14 @@ void Dni::o_handPage(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
 	VideoHandle atrus = _vm->_video->findVideoHandle(_video);
 
 	// Good ending and Atrus asked to give page
-	if (_globals.ending == 1 && _vm->_video->getTime(atrus) > (uint)Audio::Timestamp(0, 6801, 600).msecs()) {
+	if (_globals.ending == 1 && atrus && atrus->getTime() > (uint)Audio::Timestamp(0, 6801, 600).msecs()) {
 		_globals.ending = 2;
 		_globals.heldPage = 0;
 		_vm->setMainCursor(kDefaultMystCursor);
 
 		// Play movie end (atrus leaving)
-		_vm->_video->setVideoBounds(atrus, Audio::Timestamp(0, 14813, 600), _vm->_video->getDuration(atrus));
-		_vm->_video->setVideoLooping(atrus, false);
+		atrus->setBounds(Audio::Timestamp(0, 14813, 600), atrus->getDuration());
+		atrus->setLooping(false);
 
 		_atrusLeft = true;
 		_waitForLoop = false;
@@ -121,8 +121,12 @@ void Dni::o_handPage(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
 void Dni::atrusLeft_run() {
 	if (_vm->_system->getMillis() > _atrusLeftTime + 63333) {
 		_video = _vm->wrapMovieFilename("atrus2", kDniStack);
-		VideoHandle atrus = _vm->_video->playMovie(_video, 215, 77);
-		_vm->_video->setVideoBounds(atrus, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 98000, 600));
+		VideoHandle atrus = _vm->_video->playMovie(_video);
+		if (!atrus)
+			error("Failed to open '%s'", _video.c_str());
+
+		atrus->moveTo(215, 77);
+		atrus->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 98000, 600));
 
 		_waitForLoop = true;
 		_loopStart = 73095;
@@ -139,9 +143,13 @@ void Dni::atrusLeft_run() {
 
 void Dni::loopVideo_run() {
 	if (!_vm->_video->isVideoPlaying()) {
-		VideoHandle atrus = _vm->_video->playMovie(_video, 215, 77);
-		_vm->_video->setVideoBounds(atrus, Audio::Timestamp(0, _loopStart, 600), Audio::Timestamp(0, _loopEnd, 600));
-		_vm->_video->setVideoLooping(atrus, true);
+		VideoHandle atrus = _vm->_video->playMovie(_video);
+		if (!atrus)
+			error("Failed to open '%s'", _video.c_str());
+
+		atrus->moveTo(215, 77);
+		atrus->setBounds(Audio::Timestamp(0, _loopStart, 600), Audio::Timestamp(0, _loopEnd, 600));
+		atrus->setLooping(true);
 
 		_waitForLoop = false;
 	}
@@ -155,14 +163,23 @@ void Dni::atrus_run() {
 		// Atrus asking for page
 		if (!_vm->_video->isVideoPlaying()) {
 			_video = _vm->wrapMovieFilename("atr1page", kDniStack);
-			VideoHandle atrus = _vm->_video->playMovie(_video, 215, 77, true);
-			_vm->_video->setVideoBounds(atrus, Audio::Timestamp(0, 7388, 600), Audio::Timestamp(0, 14700, 600));
+			VideoHandle atrus = _vm->_video->playMovie(_video);
+			if (!atrus)
+				error("Failed to open '%s'", _video.c_str());
+
+			atrus->moveTo(215, 77);
+			atrus->setLooping(true);
+			atrus->setBounds(Audio::Timestamp(0, 7388, 600), Audio::Timestamp(0, 14700, 600));
 		}
 	} else if (_globals.ending != 3 && _globals.ending != 4) {
 		if (_globals.heldPage == 13) {
 			_video = _vm->wrapMovieFilename("atr1page", kDniStack);
-			VideoHandle atrus = _vm->_video->playMovie(_video, 215, 77);
-			_vm->_video->setVideoBounds(atrus, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 14700, 600));
+			VideoHandle atrus = _vm->_video->playMovie(_video);
+			if (!atrus)
+				error("Failed to open '%s'", _video.c_str());
+
+			atrus->moveTo(215, 77);
+			atrus->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 14700, 600));
 
 			_waitForLoop = true;
 			_loopStart = 7388;
@@ -173,8 +190,12 @@ void Dni::atrus_run() {
 
 		} else {
 			_video = _vm->wrapMovieFilename("atr1nopg", kDniStack);
-			VideoHandle atrus = _vm->_video->playMovie(_video, 215, 77);
-			_vm->_video->setVideoBounds(atrus, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 46175, 600));
+			VideoHandle atrus = _vm->_video->playMovie(_video);
+			if (!atrus)
+				error("Failed to open '%s'", _video.c_str());
+
+			atrus->moveTo(215, 77);
+			atrus->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 46175, 600));
 
 			_waitForLoop = true;
 			_loopStart = 30656;
@@ -184,7 +205,12 @@ void Dni::atrus_run() {
 			_globals.ending = 3;
 		}
 	} else if (!_vm->_video->isVideoPlaying()) {
-		_vm->_video->playMovie(_vm->wrapMovieFilename("atrwrite", kDniStack), 215, 77, true);
+		VideoHandle handle = _vm->_video->playMovie(_vm->wrapMovieFilename("atrwrite", kDniStack));
+		if (!handle)
+			error("Failed to open atrwrite movie");
+
+		handle->moveTo(215, 77);
+		handle->setLooping(true);
 	}
 }
 
diff --git a/engines/mohawk/myst_stacks/intro.cpp b/engines/mohawk/myst_stacks/intro.cpp
index 2a33379198..dc66984398 100644
--- a/engines/mohawk/myst_stacks/intro.cpp
+++ b/engines/mohawk/myst_stacks/intro.cpp
@@ -98,10 +98,16 @@ void Intro::introMovies_run() {
 	// Play Intro Movies
 	// This is all quite messy...
 
+	VideoHandle handle;
+
 	switch (_introStep) {
 	case 0:
 		_introStep = 1;
-		_vm->_video->playMovie(_vm->wrapMovieFilename("broder", kIntroStack));
+		handle = _vm->_video->playMovie(_vm->wrapMovieFilename("broder", kIntroStack));
+		if (!handle)
+			error("Failed to open broder movie");
+
+		handle->center();
 		break;
 	case 1:
 		if (!_vm->_video->isVideoPlaying())
@@ -109,7 +115,11 @@ void Intro::introMovies_run() {
 		break;
 	case 2:
 		_introStep = 3;
-		_vm->_video->playMovie(_vm->wrapMovieFilename("cyanlogo", kIntroStack));
+		handle = _vm->_video->playMovie(_vm->wrapMovieFilename("cyanlogo", kIntroStack));
+		if (!handle)
+			error("Failed to open cyanlogo movie");
+
+		handle->center();
 		break;
 	case 3:
 		if (!_vm->_video->isVideoPlaying())
@@ -118,8 +128,13 @@ void Intro::introMovies_run() {
 	case 4:
 		_introStep = 5;
 
-		if (!(_vm->getFeatures() & GF_DEMO)) // The demo doesn't have the intro video
-			_vm->_video->playMovie(_vm->wrapMovieFilename("intro", kIntroStack));
+		if (!(_vm->getFeatures() & GF_DEMO)) { // The demo doesn't have the intro video
+			handle = _vm->_video->playMovie(_vm->wrapMovieFilename("intro", kIntroStack));
+			if (!handle)
+				error("Failed to open intro movie");
+
+			handle->center();
+		}
 		break;
 	case 5:
 		if (!_vm->_video->isVideoPlaying())
diff --git a/engines/mohawk/myst_stacks/mechanical.cpp b/engines/mohawk/myst_stacks/mechanical.cpp
index b5d1285435..ffcaa226c6 100644
--- a/engines/mohawk/myst_stacks/mechanical.cpp
+++ b/engines/mohawk/myst_stacks/mechanical.cpp
@@ -316,12 +316,16 @@ void Mechanical::o_snakeBoxTrigger(uint16 op, uint16 var, uint16 argc, uint16 *a
 void Mechanical::o_fortressStaircaseMovie(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
 	debugC(kDebugScript, "Opcode %d: Play Stairs Movement Movie", op);
 
-	VideoHandle staircase = _vm->_video->playMovie(_vm->wrapMovieFilename("hhstairs", kMechanicalStack), 174, 222);
+	VideoHandle staircase = _vm->_video->playMovie(_vm->wrapMovieFilename("hhstairs", kMechanicalStack));
+	if (!staircase)
+		error("Failed to open hhstairs movie");
+
+	staircase->moveTo(174, 222);
 
 	if (_state.staircaseState) {
-		_vm->_video->setVideoBounds(staircase, Audio::Timestamp(0, 840, 600), Audio::Timestamp(0, 1680, 600));
+		staircase->setBounds(Audio::Timestamp(0, 840, 600), Audio::Timestamp(0, 1680, 600));
 	} else {
-		_vm->_video->setVideoBounds(staircase, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 840, 600));
+		staircase->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 840, 600));
 	}
 
 	_vm->_video->waitUntilMovieEnds(staircase);
@@ -571,8 +575,12 @@ void Mechanical::o_elevatorWindowMovie(uint16 op, uint16 var, uint16 argc, uint1
 
 	debugC(kDebugScript, "Opcode %d Movie Time Index %d to %d", op, startTime, endTime);
 
-	VideoHandle window = _vm->_video->playMovie(_vm->wrapMovieFilename("ewindow", kMechanicalStack), 253, 0);
-	_vm->_video->setVideoBounds(window, Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, endTime, 600));
+	VideoHandle window = _vm->_video->playMovie(_vm->wrapMovieFilename("ewindow", kMechanicalStack));
+	if (!window)
+		error("Failed to open ewindow movie");
+
+	window->moveTo(253, 0);
+	window->setBounds(Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, endTime, 600));
 	_vm->_video->waitUntilMovieEnds(window);
 }
 
@@ -644,8 +652,12 @@ void Mechanical::o_elevatorTopMovie(uint16 op, uint16 var, uint16 argc, uint16 *
 
 	debugC(kDebugScript, "Opcode %d Movie Time Index %d to %d", op, startTime, endTime);
 
-	VideoHandle window = _vm->_video->playMovie(_vm->wrapMovieFilename("hcelev", kMechanicalStack), 206, 38);
-	_vm->_video->setVideoBounds(window, Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, endTime, 600));
+	VideoHandle window = _vm->_video->playMovie(_vm->wrapMovieFilename("hcelev", kMechanicalStack));
+	if (!window)
+		error("Failed to open hcelev movie");
+
+	window->moveTo(206, 38);
+	window->setBounds(Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, endTime, 600));
 	_vm->_video->waitUntilMovieEnds(window);
 }
 
@@ -653,7 +665,7 @@ void Mechanical::o_fortressRotationSetPosition(uint16 op, uint16 var, uint16 arg
 	debugC(kDebugScript, "Opcode %d: Set fortress position", op);
 
 	VideoHandle gears = _fortressRotationGears->playMovie();
-	uint32 moviePosition = Audio::Timestamp(_vm->_video->getTime(gears), 600).totalNumberOfFrames();
+	uint32 moviePosition = Audio::Timestamp(gears->getTime(), 600).totalNumberOfFrames();
 
 	// Myst ME short movie workaround, explained in o_fortressRotation_init
 	if (_fortressRotationShortMovieWorkaround) {
@@ -788,9 +800,8 @@ void Mechanical::o_elevatorRotation_init(uint16 op, uint16 var, uint16 argc, uin
 void Mechanical::fortressRotation_run() {
 	VideoHandle gears = _fortressRotationGears->playMovie();
 
-	double oldRate = _vm->_video->getVideoRate(gears).toDouble();
-
-	uint32 moviePosition = Audio::Timestamp(_vm->_video->getTime(gears), 600).totalNumberOfFrames();
+	double oldRate = gears->getRate().toDouble();
+	uint32 moviePosition = Audio::Timestamp(gears->getTime(), 600).totalNumberOfFrames();
 
 	// Myst ME short movie workaround, explained in o_fortressRotation_init
 	if (_fortressRotationShortMovieWorkaround) {
@@ -837,19 +848,19 @@ void Mechanical::fortressRotation_run() {
 
 		newRate = CLIP<double>(newRate, -2.5, 2.5);
 
-		_vm->_video->setVideoRate(gears, Common::Rational((int)(newRate * 1000.0), 1000));
+		gears->setRate(Common::Rational((int)(newRate * 1000.0), 1000));
 
 		_gearsWereRunning = true;
 	} else if (_gearsWereRunning) {
 		// The fortress has stopped. Set its new position
 		_fortressPosition = (moviePosition + 900) / 1800 % 4;
 
-		_vm->_video->setVideoRate(gears, 0);
+		gears->setRate(0);
 
 		if (!_fortressRotationShortMovieWorkaround) {
-			_vm->_video->seekToTime(gears, Audio::Timestamp(0, 1800 * _fortressPosition, 600));
+			gears->seek(Audio::Timestamp(0, 1800 * _fortressPosition, 600));
 		} else {
-			_vm->_video->seekToTime(gears, Audio::Timestamp(0, 1800 * (_fortressPosition % 2), 600));
+			gears->seek(Audio::Timestamp(0, 1800 * (_fortressPosition % 2), 600));
 		}
 
 		_vm->_sound->playSoundBlocking(_fortressRotationSounds[_fortressPosition]);
@@ -864,9 +875,9 @@ void Mechanical::o_fortressRotation_init(uint16 op, uint16 var, uint16 argc, uin
 	_fortressRotationGears = static_cast<MystResourceType6 *>(_invokingResource);
 
 	VideoHandle gears = _fortressRotationGears->playMovie();
-	_vm->_video->setVideoLooping(gears, true);
-	_vm->_video->seekToTime(gears, Audio::Timestamp(0, 1800 * _fortressPosition, 600));
-	_vm->_video->setVideoRate(gears, 0);
+	gears->setLooping(true);
+	gears->seek(Audio::Timestamp(0, 1800 * _fortressPosition, 600));
+	gears->setRate(0);
 
 	_fortressRotationSounds[0] = argv[0];
 	_fortressRotationSounds[1] = argv[1];
@@ -884,7 +895,7 @@ void Mechanical::o_fortressRotation_init(uint16 op, uint16 var, uint16 argc, uin
 	// ScummVM simulates a longer movie by counting the number of times the movie
 	// looped and adding that time to the current movie position.
 	// Hence allowing the fortress position to be properly computed.
-	uint32 movieDuration = _vm->_video->getDuration(gears).convertToFramerate(600).totalNumberOfFrames();
+	uint32 movieDuration = gears->getDuration().convertToFramerate(600).totalNumberOfFrames();
 	if (movieDuration == 3680) {
 		_fortressRotationShortMovieWorkaround = true;
 		_fortressRotationShortMovieCount = 0;
@@ -924,8 +935,8 @@ void Mechanical::fortressSimulation_run() {
 
 		_fortressSimulationStartup->pauseMovie(true);
 		VideoHandle holo = _fortressSimulationHolo->playMovie();
-		_vm->_video->setVideoLooping(holo, true);
-		_vm->_video->setVideoRate(holo, 0);
+		holo->setLooping(true);
+		holo->setRate(0);
 
 		_vm->_cursor->showCursor();
 
@@ -933,9 +944,8 @@ void Mechanical::fortressSimulation_run() {
 	} else {
 		VideoHandle holo = _fortressSimulationHolo->playMovie();
 
-		double oldRate = _vm->_video->getVideoRate(holo).toDouble();
-
-		uint32 moviePosition = Audio::Timestamp(_vm->_video->getTime(holo), 600).totalNumberOfFrames();
+		double oldRate = holo->getRate().toDouble();
+		uint32 moviePosition = Audio::Timestamp(holo->getTime(), 600).totalNumberOfFrames();
 
 		int32 positionInQuarter = 900 - (moviePosition + 900) % 1800;
 
@@ -968,15 +978,15 @@ void Mechanical::fortressSimulation_run() {
 
 			newRate = CLIP<double>(newRate, -2.5, 2.5);
 
-			_vm->_video->setVideoRate(holo, Common::Rational((int)(newRate * 1000.0), 1000));
+			holo->setRate(Common::Rational((int)(newRate * 1000.0), 1000));
 
 			_gearsWereRunning = true;
 		} else if (_gearsWereRunning) {
 			// The fortress has stopped. Set its new position
 			uint16 simulationPosition = (moviePosition + 900) / 1800 % 4;
 
-			_vm->_video->setVideoRate(holo, 0);
-			_vm->_video->seekToTime(holo, Audio::Timestamp(0, 1800 * simulationPosition, 600));
+			holo->setRate(0);
+			holo->seek(Audio::Timestamp(0, 1800 * simulationPosition, 600));
 			_vm->_sound->playSoundBlocking(	_fortressRotationSounds[simulationPosition]);
 
 			_gearsWereRunning = false;
diff --git a/engines/mohawk/myst_stacks/myst.cpp b/engines/mohawk/myst_stacks/myst.cpp
index c500df5ad3..98f0aa5349 100644
--- a/engines/mohawk/myst_stacks/myst.cpp
+++ b/engines/mohawk/myst_stacks/myst.cpp
@@ -51,8 +51,6 @@ Myst::Myst(MohawkEngine_Myst *vm) :
 	_dockVaultState = 0;
 	_cabinDoorOpened = 0;
 	_cabinMatchState = 2;
-	_cabinGaugeMovie = NULL_VID_HANDLE;
-	_cabinFireMovie = NULL_VID_HANDLE;
 	_matchBurning = false;
 	_tree = 0;
 	_treeAlcove = 0;
@@ -1135,10 +1133,13 @@ void Myst::o_clockWheelsExecute(uint16 op, uint16 var, uint16 argc, uint16 *argv
 		_vm->_system->delayMillis(500);
 
 		// Gears rise up
-		VideoHandle gears = _vm->_video->playMovie(_vm->wrapMovieFilename("gears", kMystStack), 305, 33);
-		_vm->_video->setVideoBounds(gears, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 650, 600));
-		_vm->_video->waitUntilMovieEnds(gears);
+		VideoHandle gears = _vm->_video->playMovie(_vm->wrapMovieFilename("gears", kMystStack));
+		if (!gears)
+			error("Failed to open gears movie");
 
+		gears->moveTo(305, 33);
+		gears->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 650, 600));
+		_vm->_video->waitUntilMovieEnds(gears);
 
 		_state.clockTowerBridgeOpen = 1;
 		_vm->redrawArea(12);
@@ -1147,8 +1148,12 @@ void Myst::o_clockWheelsExecute(uint16 op, uint16 var, uint16 argc, uint16 *argv
 		_vm->_system->delayMillis(500);
 
 		// Gears sink down
-		VideoHandle gears = _vm->_video->playMovie(_vm->wrapMovieFilename("gears", kMystStack), 305, 33);
-		_vm->_video->setVideoBounds(gears, Audio::Timestamp(0, 700, 600), Audio::Timestamp(0, 1300, 600));
+		VideoHandle gears = _vm->_video->playMovie(_vm->wrapMovieFilename("gears", kMystStack));
+		if (!gears)
+			error("Failed to open gears movie");
+
+		gears->moveTo(305, 33);
+		gears->setBounds(Audio::Timestamp(0, 700, 600), Audio::Timestamp(0, 1300, 600));
 		_vm->_video->waitUntilMovieEnds(gears);
 
 		_state.clockTowerBridgeOpen = 0;
@@ -1191,15 +1196,23 @@ void Myst::o_imagerPlayButton(uint16 op, uint16 var, uint16 argc, uint16 *argv)
 		if (_state.imagerActive) {
 			// Mountains disappearing
 			Common::String file = _vm->wrapMovieFilename("vltmntn", kMystStack);
-			VideoHandle mountain = _vm->_video->playMovie(file, 159, 96, false);
-			_vm->_video->setVideoBounds(mountain, Audio::Timestamp(0, 11180, 600), Audio::Timestamp(0, 16800, 600));
+			VideoHandle mountain = _vm->_video->playMovie(file);
+			if (!mountain)
+				error("Failed to open '%s'", file.c_str());
+
+			mountain->moveTo(159, 96);
+			mountain->setBounds(Audio::Timestamp(0, 11180, 600), Audio::Timestamp(0, 16800, 600));
 
 			_state.imagerActive = 0;
 		} else {
 			// Mountains appearing
 			Common::String file = _vm->wrapMovieFilename("vltmntn", kMystStack);
-			VideoHandle mountain = _vm->_video->playMovie(file, 159, 96, false);
-			_vm->_video->setVideoBounds(mountain, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 11180, 600));
+			VideoHandle mountain = _vm->_video->playMovie(file);
+			if (!mountain)
+				error("Failed to open '%s'", file.c_str());
+
+			mountain->moveTo(159, 96);
+			mountain->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 11180, 600));
 
 			_state.imagerActive = 1;
 		}
@@ -1212,20 +1225,20 @@ void Myst::o_imagerPlayButton(uint16 op, uint16 var, uint16 argc, uint16 *argv)
 
 			// Water disappearing
 			VideoHandle water = _imagerMovie->playMovie();
-			_vm->_video->setVideoBounds(water, Audio::Timestamp(0, 4204, 600), Audio::Timestamp(0, 6040, 600));
-			_vm->_video->setVideoLooping(water, false);
+			water->setBounds(Audio::Timestamp(0, 4204, 600), Audio::Timestamp(0, 6040, 600));
+			water->setLooping(false);
 
 			_state.imagerActive = 0;
 		} else {
 			// Water appearing
 			VideoHandle water = _imagerMovie->playMovie();
-			_vm->_video->setVideoBounds(water, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 1814, 600));
+			water->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 1814, 600));
 			_vm->_video->waitUntilMovieEnds(water);
 
 			// Water looping
 			water = _imagerMovie->playMovie();
-			_vm->_video->setVideoBounds(water, Audio::Timestamp(0, 1814, 600), Audio::Timestamp(0, 4204, 600));
-			_vm->_video->setVideoLooping(water, true);
+			water->setBounds(Audio::Timestamp(0, 1814, 600), Audio::Timestamp(0, 4204, 600));
+			water->setLooping(true);
 
 			_state.imagerActive = 1;
 		}
@@ -1902,11 +1915,19 @@ Common::Rational Myst::boilerComputeGaugeRate(uint16 pressure, uint32 delay) {
 }
 
 void Myst::boilerResetGauge(const Common::Rational &rate) {
-	if (_vm->_video->endOfVideo(_cabinGaugeMovie)) {
+	if (!_cabinGaugeMovie || _cabinGaugeMovie->endOfVideo()) {
 		if (_vm->getCurCard() == 4098) {
-			_cabinGaugeMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabingau", kMystStack), 243, 96);
+			_cabinGaugeMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabingau", kMystStack));
+			if (!_cabinGaugeMovie)
+				error("Failed to open cabingau movie");
+
+			_cabinGaugeMovie->moveTo(243, 96);
 		} else {
-			_cabinGaugeMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabcgfar", kMystStack), 254, 136);
+			_cabinGaugeMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabcgfar", kMystStack));
+			if (!_cabinGaugeMovie)
+				error("Failed to open cabingau movie");
+
+			_cabinGaugeMovie->moveTo(254, 136);
 		}
 	}
 
@@ -1914,10 +1935,10 @@ void Myst::boilerResetGauge(const Common::Rational &rate) {
 	if (rate > 0)
 		goTo = Audio::Timestamp(0, 0, 600);
 	else
-		goTo = _vm->_video->getDuration(_cabinGaugeMovie);
+		goTo = _cabinGaugeMovie->getDuration();
 
-	_vm->_video->seekToTime(_cabinGaugeMovie, goTo);
-	_vm->_video->setVideoRate(_cabinGaugeMovie, rate);
+	_cabinGaugeMovie->seek(goTo);
+	_cabinGaugeMovie->setRate(rate);
 }
 
 void Myst::o_boilerIncreasePressureStop(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
@@ -1931,10 +1952,10 @@ void Myst::o_boilerIncreasePressureStop(uint16 op, uint16 var, uint16 argc, uint
 		if (_state.cabinValvePosition > 0)
 			_vm->_sound->replaceBackgroundMyst(8098, 49152);
 
-		if (!_vm->_video->endOfVideo(_cabinGaugeMovie)) {
+		if (_cabinGaugeMovie && !_cabinGaugeMovie->endOfVideo()) {
 			uint16 delay = treeNextMoveDelay(_state.cabinValvePosition);
 			Common::Rational rate = boilerComputeGaugeRate(_state.cabinValvePosition, delay);
-			_vm->_video->setVideoRate(_cabinGaugeMovie, rate);
+			_cabinGaugeMovie->setRate(rate);
 		}
 
 	} else if (_state.cabinValvePosition > 0)
@@ -2006,10 +2027,10 @@ void Myst::o_boilerDecreasePressureStop(uint16 op, uint16 var, uint16 argc, uint
 		if (_state.cabinValvePosition > 0)
 			_vm->_sound->replaceBackgroundMyst(8098, 49152);
 
-		if (!_vm->_video->endOfVideo(_cabinGaugeMovie)) {
+		if (_cabinGaugeMovie && !_cabinGaugeMovie->endOfVideo()) {
 			uint16 delay = treeNextMoveDelay(_state.cabinValvePosition);
 			Common::Rational rate = boilerComputeGaugeRate(_state.cabinValvePosition, delay);
-			_vm->_video->setVideoRate(_cabinGaugeMovie, rate);
+			_cabinGaugeMovie->setRate(rate);
 		}
 
 	} else {
@@ -2117,7 +2138,7 @@ void Myst::tree_run() {
 				// Check if alcove is accessible
 				treeSetAlcoveAccessible();
 
-				if (_cabinGaugeMovie != NULL_VID_HANDLE) {
+				if (_cabinGaugeMovie) {
 					Common::Rational rate = boilerComputeGaugeRate(pressure, delay);
 					boilerResetGauge(rate);
 				}
@@ -2246,13 +2267,22 @@ void Myst::rocketCheckSolution() {
 
 		// Book appearing
 		Common::String movieFile = _vm->wrapMovieFilename("selenbok", kMystStack);
-		_rocketLinkBook = _vm->_video->playMovie(movieFile, 224, 41);
-		_vm->_video->setVideoBounds(_rocketLinkBook, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 660, 600));
+		_rocketLinkBook = _vm->_video->playMovie(movieFile);
+		if (!_rocketLinkBook)
+			error("Failed to open '%s'", movieFile.c_str());
+
+		_rocketLinkBook->moveTo(224, 41);
+		_rocketLinkBook->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 660, 600));
 		_vm->_video->waitUntilMovieEnds(_rocketLinkBook);
 
 		// Book looping closed
-		_rocketLinkBook = _vm->_video->playMovie(movieFile, 224, 41, true);
-		_vm->_video->setVideoBounds(_rocketLinkBook, Audio::Timestamp(0, 660, 600), Audio::Timestamp(0, 3500, 600));
+		_rocketLinkBook = _vm->_video->playMovie(movieFile);
+		if (!_rocketLinkBook)
+			error("Failed to open '%s'", movieFile.c_str());
+
+		_rocketLinkBook->moveTo(224, 41);
+		_rocketLinkBook->setLooping(true);
+		_rocketLinkBook->setBounds(Audio::Timestamp(0, 660, 600), Audio::Timestamp(0, 3500, 600));
 
 		_tempVar = 1;
 	}
@@ -2367,7 +2397,7 @@ void Myst::o_rocketOpenBook(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
 	debugC(kDebugScript, "Opcode %d: Rocket open link book", op);
 
 	// Flyby movie
-	_vm->_video->setVideoBounds(_rocketLinkBook, Audio::Timestamp(0, 3500, 600), Audio::Timestamp(0, 13100, 600));
+	_rocketLinkBook->setBounds(Audio::Timestamp(0, 3500, 600), Audio::Timestamp(0, 13100, 600));
 
 	// Set linkable
 	_tempVar = 2;
@@ -2889,8 +2919,12 @@ void Myst::clockGearForwardOneStep(uint16 gear) {
 
 	// Set video bounds
 	uint16 gearPosition = _clockGearsPositions[gear] - 1;
-	_clockGearsVideos[gear] = _vm->_video->playMovie(_vm->wrapMovieFilename(videos[gear], kMystStack), x[gear], y[gear]);
-	_vm->_video->setVideoBounds(_clockGearsVideos[gear],
+	_clockGearsVideos[gear] = _vm->_video->playMovie(_vm->wrapMovieFilename(videos[gear], kMystStack));
+	if (!_clockGearsVideos[gear])
+		error("Failed to open %s movie", videos[gear]);
+
+	_clockGearsVideos[gear]->moveTo(x[gear], y[gear]);
+	_clockGearsVideos[gear]->setBounds(
 			Audio::Timestamp(0, startTime[gearPosition], 600),
 			Audio::Timestamp(0, endTime[gearPosition], 600));
 }
@@ -2902,8 +2936,12 @@ void Myst::clockWeightDownOneStep() {
 
 	// Set video bounds
 	if (updateVideo) {
-		_clockWeightVideo = _vm->_video->playMovie(_vm->wrapMovieFilename("cl1wlfch", kMystStack) , 124, 0);
-		_vm->_video->setVideoBounds(_clockWeightVideo,
+		_clockWeightVideo = _vm->_video->playMovie(_vm->wrapMovieFilename("cl1wlfch", kMystStack));
+		if (!_clockWeightVideo)
+			error("Failed to open cl1wlfch movie");
+
+		_clockWeightVideo->moveTo(124, 0);
+		_clockWeightVideo->setBounds(
 				Audio::Timestamp(0, _clockWeightPosition, 600),
 				Audio::Timestamp(0, _clockWeightPosition + 246, 600));
 	}
@@ -2931,7 +2969,7 @@ void Myst::o_clockLeverEndMove(uint16 op, uint16 var, uint16 argc, uint16 *argv)
 	// Let movies stop playing
 	for (uint i = 0; i < ARRAYSIZE(videos); i++) {
 		VideoHandle handle = _vm->_video->findVideoHandle(_vm->wrapMovieFilename(videos[i], kMystStack));
-		if (handle != NULL_VID_HANDLE)
+		if (handle)
 			_vm->_video->delayUntilMovieEnds(handle);
 	}
 
@@ -2956,8 +2994,12 @@ void Myst::clockGearsCheckSolution() {
 
 		// Make weight go down
 		_vm->_sound->replaceSoundMyst(9113);
-		_clockWeightVideo = _vm->_video->playMovie(_vm->wrapMovieFilename("cl1wlfch", kMystStack) , 124, 0);
-		_vm->_video->setVideoBounds(_clockWeightVideo,
+		_clockWeightVideo = _vm->_video->playMovie(_vm->wrapMovieFilename("cl1wlfch", kMystStack));
+		if (!_clockWeightVideo)
+			error("Failed to open cl1wlfch movie");
+
+		_clockWeightVideo->moveTo(124, 0);
+		_clockWeightVideo->setBounds(
 				Audio::Timestamp(0, _clockWeightPosition, 600),
 				Audio::Timestamp(0, 2214, 600));
 		_vm->_video->waitUntilMovieEnds(_clockWeightVideo);
@@ -2968,7 +3010,7 @@ void Myst::clockGearsCheckSolution() {
 		_vm->_sound->replaceSoundMyst(7113);
 
 		// Gear opening video
-		_vm->_video->playMovieBlocking(_vm->wrapMovieFilename("cl1wggat", kMystStack) , 195, 225);
+		_vm->_video->playMovieBlocking(_vm->wrapMovieFilename("cl1wggat", kMystStack), 195, 225);
 		_state.gearsOpen = 1;
 		_vm->redrawArea(40);
 
@@ -3011,7 +3053,7 @@ void Myst::clockReset() {
 	// Let movies stop playing
 	for (uint i = 0; i < ARRAYSIZE(videos); i++) {
 		VideoHandle handle = _vm->_video->findVideoHandle(_vm->wrapMovieFilename(videos[i], kMystStack));
-		if (handle != NULL_VID_HANDLE)
+		if (handle)
 			_vm->_video->delayUntilMovieEnds(handle);
 	}
 
@@ -3024,9 +3066,13 @@ void Myst::clockReset() {
 		_vm->_sound->replaceSoundMyst(7113);
 
 		// Gear closing movie
-		VideoHandle handle = _vm->_video->playMovie(_vm->wrapMovieFilename("cl1wggat", kMystStack) , 195, 225);
-		_vm->_video->seekToTime(handle, _vm->_video->getDuration(handle));
-		_vm->_video->setVideoRate(handle, -1);
+		VideoHandle handle = _vm->_video->playMovie(_vm->wrapMovieFilename("cl1wggat", kMystStack));
+		if (!handle)
+			error("Failed to open cl1wggat movie");
+
+		handle->moveTo(195, 225);
+		handle->seek(handle->getDuration());
+		handle->setRate(-1);
 		_vm->_video->waitUntilMovieEnds(handle);
 
 		// Redraw gear
@@ -3038,11 +3084,15 @@ void Myst::clockReset() {
 }
 
 void Myst::clockResetWeight() {
-	_clockWeightVideo = _vm->_video->playMovie(_vm->wrapMovieFilename("cl1wlfch", kMystStack) , 124, 0);
+	_clockWeightVideo = _vm->_video->playMovie(_vm->wrapMovieFilename("cl1wlfch", kMystStack));
+	if (!_clockWeightVideo)
+		error("Failed to open cl1wlfch movie");
+
+	_clockWeightVideo->moveTo(124, 0);
 
 	// Play the movie backwards, weight going up
-	_vm->_video->seekToTime(_clockWeightVideo, Audio::Timestamp(0, _clockWeightPosition, 600));
-	_vm->_video->setVideoRate(_clockWeightVideo, -1);
+	_clockWeightVideo->seek(Audio::Timestamp(0, _clockWeightPosition, 600));
+	_clockWeightVideo->setRate(-1);
 
 	// Reset position
 	_clockWeightPosition = 0;
@@ -3057,8 +3107,12 @@ void Myst::clockResetGear(uint16 gear) {
 	// Set video bounds, gears going to 3
 	uint16 gearPosition = _clockGearsPositions[gear] - 1;
 	if (gearPosition != 2) {
-		_clockGearsVideos[gear] = _vm->_video->playMovie(_vm->wrapMovieFilename(videos[gear], kMystStack), x[gear], y[gear]);
-		_vm->_video->setVideoBounds(_clockGearsVideos[gear],
+		_clockGearsVideos[gear] = _vm->_video->playMovie(_vm->wrapMovieFilename(videos[gear], kMystStack));
+		if (!_clockGearsVideos[gear])
+			error("Failed to open gears movie");
+
+		_clockGearsVideos[gear]->moveTo(x[gear], y[gear]);
+		_clockGearsVideos[gear]->setBounds(
 				Audio::Timestamp(0, time[gearPosition], 600),
 				Audio::Timestamp(0, time[2], 600));
 	}
@@ -3201,13 +3255,21 @@ Common::Point Myst::towerRotationMapComputeCoords(const Common::Point &center, u
 }
 
 void Myst::towerRotationMapDrawLine(const Common::Point &center, const Common::Point &end) {
-	Graphics::PixelFormat pf = _vm->_system->getScreenFormat();
-	uint32 color = 0;
+	uint32 color;
 
-	if (!_towerRotationOverSpot)
-		color = pf.RGBToColor(0xFF, 0xFF, 0xFF); // White
-	else
-		color = pf.RGBToColor(0xFF, 0, 0); // Red
+	if (_vm->getFeatures() & GF_ME) {
+		Graphics::PixelFormat pf = _vm->_system->getScreenFormat();
+
+		if (!_towerRotationOverSpot)
+			color = pf.RGBToColor(0xFF, 0xFF, 0xFF); // White
+		else
+			color = pf.RGBToColor(0xFF, 0, 0); // Red
+	} else {
+		if (!_towerRotationOverSpot)
+			color = 0x00; // White
+		else
+			color = 0xF9; // Red
+	}
 
 	const Common::Rect rect = Common::Rect(106, 42, 459, 273);
 
@@ -3281,8 +3343,8 @@ void Myst::imager_run() {
 
 	if (_state.imagerActive && _state.imagerSelection == 67) {
 		VideoHandle water = _imagerMovie->playMovie();
-		_vm->_video->setVideoBounds(water, Audio::Timestamp(0, 1814, 600), Audio::Timestamp(0, 4204, 600));
-		_vm->_video->setVideoLooping(water, true);
+		water->setBounds(Audio::Timestamp(0, 1814, 600), Audio::Timestamp(0, 4204, 600));
+		water->setLooping(true);
 	}
 }
 
@@ -3394,8 +3456,11 @@ void Myst::gullsFly1_run() {
 			else
 				x = _vm->_rnd->getRandomNumber(160) + 260;
 
-			_vm->_video->playMovie(_vm->wrapMovieFilename(gulls[video], kMystStack), x, 0);
+			VideoHandle handle = _vm->_video->playMovie(_vm->wrapMovieFilename(gulls[video], kMystStack));
+			if (!handle)
+				error("Failed to open gulls movie");
 
+			handle->moveTo(x, 0);
 			_gullsNextTime = time + _vm->_rnd->getRandomNumber(16667) + 13334;
 		}
 	}
@@ -3540,8 +3605,11 @@ void Myst::gullsFly2_run() {
 	if (time > _gullsNextTime) {
 		uint16 video = _vm->_rnd->getRandomNumber(3);
 		if (video != 3) {
-			_vm->_video->playMovie(_vm->wrapMovieFilename(gulls[video], kMystStack), 424, 0);
-
+			VideoHandle handle = _vm->_video->playMovie(_vm->wrapMovieFilename(gulls[video], kMystStack));
+			if (!handle)
+				error("Failed to open gulls movie");
+	
+			handle->moveTo(424, 0);
 			_gullsNextTime = time + _vm->_rnd->getRandomNumber(16667) + 13334;
 		}
 	}
@@ -3572,31 +3640,41 @@ void Myst::o_boilerMovies_init(uint16 op, uint16 var, uint16 argc, uint16 *argv)
 
 void Myst::boilerFireInit() {
 	if (_vm->getCurCard() == 4098) {
-		_cabinFireMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabfire", kMystStack), 240, 279, true);
-		_vm->_video->pauseMovie(_cabinFireMovie, true);
+		_cabinFireMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabfire", kMystStack));
+		if (!_cabinFireMovie)
+				error("Failed to open cabfire movie");
+
+		_cabinFireMovie->moveTo(240, 279);
+		_cabinFireMovie->setLooping(true);
+		_cabinFireMovie->pause(true);
 
 		_vm->redrawArea(305);
 		boilerFireUpdate(true);
 	} else {
 		if (_state.cabinPilotLightLit == 1 && _state.cabinValvePosition >= 1) {
-			_cabinFireMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabfirfr", kMystStack), 254, 244, true);
+			_cabinFireMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabfirfr", kMystStack));
+			if (!_cabinFireMovie)
+				error("Failed to open cabfirfr movie");
+
+			_cabinFireMovie->moveTo(254, 244);
+			_cabinFireMovie->setLooping(true);
 		}
 	}
 }
 
 void Myst::boilerFireUpdate(bool init) {
-	uint position = _vm->_video->getTime(_cabinFireMovie);
+	uint position = _cabinFireMovie->getTime();
 
 	if (_state.cabinPilotLightLit == 1) {
 		if (_state.cabinValvePosition == 0) {
 			if (position > (uint)Audio::Timestamp(0, 200, 600).msecs() || init) {
-				_vm->_video->setVideoBounds(_cabinFireMovie, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 100, 600));
-				_vm->_video->pauseMovie(_cabinFireMovie, false);
+				_cabinFireMovie->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 100, 600));
+				_cabinFireMovie->pause(false);
 			}
 		} else {
 			if (position < (uint)Audio::Timestamp(0, 200, 600).msecs() || init) {
-				_vm->_video->setVideoBounds(_cabinFireMovie, Audio::Timestamp(0, 201, 600), Audio::Timestamp(0, 1900, 600));
-				_vm->_video->pauseMovie(_cabinFireMovie, false);
+				_cabinFireMovie->setBounds(Audio::Timestamp(0, 201, 600), Audio::Timestamp(0, 1900, 600));
+				_cabinFireMovie->pause(false);
 			}
 		}
 	}
@@ -3604,15 +3682,23 @@ void Myst::boilerFireUpdate(bool init) {
 
 void Myst::boilerGaugeInit() {
 	if (_vm->getCurCard() == 4098) {
-		_cabinGaugeMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabingau", kMystStack), 243, 96);
+		_cabinGaugeMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabingau", kMystStack));
+		if (!_cabinFireMovie)
+			error("Failed to open cabingau movie");
+
+		_cabinFireMovie->moveTo(243, 96);
 	} else {
-		_cabinGaugeMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabcgfar", kMystStack), 254, 136);
+		_cabinGaugeMovie = _vm->_video->playMovie(_vm->wrapMovieFilename("cabcgfar", kMystStack));
+		if (!_cabinFireMovie)
+			error("Failed to open cabcgfar movie");
+
+		_cabinFireMovie->moveTo(254, 136);
 	}
 
 	Audio::Timestamp frame;
 
 	if (_state.cabinPilotLightLit == 1 && _state.cabinValvePosition > 12)
-		frame = _vm->_video->getDuration(_cabinGaugeMovie);
+		frame = _cabinGaugeMovie->getDuration();
 	else
 		frame = Audio::Timestamp(0, 0, 600);
 
@@ -3672,18 +3758,27 @@ void Myst::greenBook_run() {
 		_vm->_sound->stopSound();
 		_vm->_sound->pauseBackgroundMyst();
 
+		VideoHandle book = _vm->_video->playMovie(file);
+		if (!book)
+			error("Failed to open '%s'", file.c_str());
+
+		book->moveTo(314, 76);
+
 		if (_globals.ending != 4) {
 			_tempVar = 2;
-			_vm->_video->playMovie(file, 314, 76);
 		} else {
-			VideoHandle book = _vm->_video->playMovie(file, 314, 76, true);
-			_vm->_video->setVideoBounds(book, Audio::Timestamp(0, loopStart, 600), Audio::Timestamp(0, loopEnd, 600));
+			book->setBounds(Audio::Timestamp(0, loopStart, 600), Audio::Timestamp(0, loopEnd, 600));
+			book->setLooping(true);
 			_tempVar = 0;
 		}
 	} else if (_tempVar == 2 && !_vm->_video->isVideoPlaying()) {
-		VideoHandle book = _vm->_video->playMovie(file, 314, 76);
-		_vm->_video->setVideoBounds(book, Audio::Timestamp(0, loopStart, 600), Audio::Timestamp(0, loopEnd, 600));
-		_vm->_video->setVideoLooping(book, true);
+		VideoHandle book = _vm->_video->playMovie(file);
+		if (!book)
+			error("Failed to open '%s'", file.c_str());
+
+		book->moveTo(314, 76);
+		book->setBounds(Audio::Timestamp(0, loopStart, 600), Audio::Timestamp(0, loopEnd, 600));
+		book->setLooping(true);
 		_tempVar = 0;
 	}
 }
@@ -3706,8 +3801,11 @@ void Myst::gullsFly3_run() {
 		if (video != 3) {
 			uint16 x = _vm->_rnd->getRandomNumber(280) + 135;
 
-			_vm->_video->playMovie(_vm->wrapMovieFilename(gulls[video], kMystStack), x, 0);
+			VideoHandle handle = _vm->_video->playMovie(_vm->wrapMovieFilename(gulls[video], kMystStack));
+			if (!handle)
+				error("Failed to open gulls movie");
 
+			handle->moveTo(x, 0);
 			_gullsNextTime = time + _vm->_rnd->getRandomNumber(16667) + 13334;
 		}
 	}
@@ -3742,8 +3840,8 @@ void Myst::o_treeEntry_exit(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
 void Myst::o_boiler_exit(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
 	debugC(kDebugScript, "Opcode %d: Exit boiler card", op);
 
-	_cabinGaugeMovie = NULL_VID_HANDLE;
-	_cabinFireMovie = NULL_VID_HANDLE;
+	_cabinGaugeMovie = VideoHandle();
+	_cabinFireMovie = VideoHandle();
 }
 
 void Myst::o_generatorControlRoom_exit(uint16 op, uint16 var, uint16 argc, uint16 *argv) {
diff --git a/engines/mohawk/myst_stacks/stoneship.cpp b/engines/mohawk/myst_stacks/stoneship.cpp
index d8dbeef641..1113ceeac9 100644
--- a/engines/mohawk/myst_stacks/stoneship.cpp
+++ b/engines/mohawk/myst_stacks/stoneship.cpp
@@ -425,8 +425,12 @@ void Stoneship::o_cabinBookMovie(uint16 op, uint16 var, uint16 argc, uint16 *arg
 	uint16 startTime = argv[0];
 	uint16 endTime = argv[1];
 
-	VideoHandle book = _vm->_video->playMovie(_vm->wrapMovieFilename("bkroom", kStoneshipStack), 159, 99);
-	_vm->_video->setVideoBounds(book, Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, endTime, 600));
+	VideoHandle book = _vm->_video->playMovie(_vm->wrapMovieFilename("bkroom", kStoneshipStack));
+	if (!book)
+		error("Failed to open bkroom movie");
+
+	book->moveTo(159, 99);
+	book->setBounds(Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, endTime, 600));
 	_vm->_video->waitUntilMovieEnds(book);
 }
 
@@ -597,9 +601,9 @@ void Stoneship::o_hologramPlayback(uint16 op, uint16 var, uint16 argc, uint16 *a
 	if (_hologramTurnedOn) {
 		if (_hologramDisplayPos)
 			endPoint = _hologramDisplayPos;
-		_vm->_video->setVideoBounds(displayMovie, Audio::Timestamp(0, startPoint, 600), Audio::Timestamp(0, endPoint, 600));
+		displayMovie->setBounds(Audio::Timestamp(0, startPoint, 600), Audio::Timestamp(0, endPoint, 600));
 	} else {
-		_vm->_video->setVideoBounds(displayMovie, Audio::Timestamp(0, startPoint, 600), Audio::Timestamp(0, endPoint, 600));
+		displayMovie->setBounds(Audio::Timestamp(0, startPoint, 600), Audio::Timestamp(0, endPoint, 600));
 	}
 
 	_vm->_video->delayUntilMovieEnds(displayMovie);
@@ -673,29 +677,45 @@ void Stoneship::o_chestValveVideos(uint16 op, uint16 var, uint16 argc, uint16 *a
 
 	if (_state.chestValveState) {
 		// Valve closing
-		VideoHandle valve = _vm->_video->playMovie(movie, 97, 267);
-		_vm->_video->setVideoBounds(valve, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 350, 600));
+		VideoHandle valve = _vm->_video->playMovie(movie);
+		if (!valve)
+			error("Failed to open '%s'", movie.c_str());
+
+		valve->moveTo(97, 267);
+		valve->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 350, 600));
 		_vm->_video->waitUntilMovieEnds(valve);
 	} else if (_state.chestWaterState) {
 		// Valve opening, spilling water
-		VideoHandle valve = _vm->_video->playMovie(movie, 97, 267);
-		_vm->_video->setVideoBounds(valve, Audio::Timestamp(0, 350, 600), Audio::Timestamp(0, 650, 600));
+		VideoHandle valve = _vm->_video->playMovie(movie);
+		if (!valve)
+			error("Failed to open '%s'", movie.c_str());
+
+		valve->moveTo(97, 267);
+		valve->setBounds(Audio::Timestamp(0, 350, 600), Audio::Timestamp(0, 650, 600));
 		_vm->_video->waitUntilMovieEnds(valve);
 
 		_vm->_sound->playSound(3132);
 
 		for (uint i = 0; i < 25; i++) {
-			valve = _vm->_video->playMovie(movie, 97, 267);
-			_vm->_video->setVideoBounds(valve, Audio::Timestamp(0, 650, 600), Audio::Timestamp(0, 750, 600));
+			valve = _vm->_video->playMovie(movie);
+			if (!valve)
+				error("Failed to open '%s'", movie.c_str());
+
+			valve->moveTo(97, 267);
+			valve->setBounds(Audio::Timestamp(0, 650, 600), Audio::Timestamp(0, 750, 600));
 			_vm->_video->waitUntilMovieEnds(valve);
 		}
 
 		_vm->_sound->resumeBackgroundMyst();
 	} else {
 		// Valve opening
-		VideoHandle valve = _vm->_video->playMovie(movie, 97, 267);
-		_vm->_video->seekToTime(valve, Audio::Timestamp(0, 350, 600));
-		_vm->_video->setVideoRate(valve, -1);
+		VideoHandle valve = _vm->_video->playMovie(movie);
+		if (!valve)
+			error("Failed to open '%s'", movie.c_str());
+
+		valve->moveTo(97, 267);
+		valve->seek(Audio::Timestamp(0, 350, 600));
+		valve->setRate(-1);
 		_vm->_video->waitUntilMovieEnds(valve);
 	}
 }
@@ -716,14 +736,22 @@ void Stoneship::o_trapLockOpen(uint16 op, uint16 var, uint16 argc, uint16 *argv)
 
 	Common::String movie = _vm->wrapMovieFilename("openloc", kStoneshipStack);
 
-	VideoHandle lock = _vm->_video->playMovie(movie, 187, 71);
-	_vm->_video->setVideoBounds(lock, Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 750, 600));
+	VideoHandle lock = _vm->_video->playMovie(movie);
+	if (!lock)
+		error("Failed to open '%s'", movie.c_str());
+
+	lock->moveTo(187, 71);
+	lock->setBounds(Audio::Timestamp(0, 0, 600), Audio::Timestamp(0, 750, 600));
 	_vm->_video->waitUntilMovieEnds(lock);
 
 	_vm->_sound->playSound(2143);
 
-	lock = _vm->_video->playMovie(movie, 187, 71);
-	_vm->_video->setVideoBounds(lock, Audio::Timestamp(0, 750, 600), Audio::Timestamp(0, 10000, 600));
+	lock = _vm->_video->playMovie(movie);
+	if (!lock)
+		error("Failed to open '%s'", movie.c_str());
+
+	lock->moveTo(187, 71);
+	lock->setBounds(Audio::Timestamp(0, 750, 600), Audio::Timestamp(0, 10000, 600));
 	_vm->_video->waitUntilMovieEnds(lock);
 
 	if (_state.pumpState != 4)
diff --git a/engines/mohawk/riven.cpp b/engines/mohawk/riven.cpp
index a7fe12b9e1..898f68c581 100644
--- a/engines/mohawk/riven.cpp
+++ b/engines/mohawk/riven.cpp
@@ -828,7 +828,7 @@ static void sunnersTopStairsTimer(MohawkEngine_Riven *vm) {
 	VideoHandle oldHandle = vm->_video->findVideoHandleRiven(1);
 	uint32 timerTime = 500;
 
-	if (oldHandle == NULL_VID_HANDLE || vm->_video->endOfVideo(oldHandle)) {
+	if (!oldHandle || oldHandle->endOfVideo()) {
 		uint32 &sunnerTime = vm->_vars["jsunnertime"];
 
 		if (sunnerTime == 0) {
@@ -836,7 +836,7 @@ static void sunnersTopStairsTimer(MohawkEngine_Riven *vm) {
 		} else if (sunnerTime < vm->getTotalPlayTime()) {
 			VideoHandle handle = vm->_video->playMovieRiven(vm->_rnd->getRandomNumberRng(1, 3));
 
-			timerTime = vm->_video->getDuration(handle).msecs() + vm->_rnd->getRandomNumberRng(2, 15) * 1000;
+			timerTime = handle->getDuration().msecs() + vm->_rnd->getRandomNumberRng(2, 15) * 1000;
 		}
 
 		sunnerTime = timerTime + vm->getTotalPlayTime();
@@ -858,7 +858,7 @@ static void sunnersMidStairsTimer(MohawkEngine_Riven *vm) {
 	VideoHandle oldHandle = vm->_video->findVideoHandleRiven(1);
 	uint32 timerTime = 500;
 
-	if (oldHandle == NULL_VID_HANDLE || vm->_video->endOfVideo(oldHandle)) {
+	if (!oldHandle || oldHandle->endOfVideo()) {
 		uint32 &sunnerTime = vm->_vars["jsunnertime"];
 
 		if (sunnerTime == 0) {
@@ -874,7 +874,7 @@ static void sunnersMidStairsTimer(MohawkEngine_Riven *vm) {
 
 			VideoHandle handle = vm->_video->playMovieRiven(movie);
 
-			timerTime = vm->_video->getDuration(handle).msecs() + vm->_rnd->getRandomNumberRng(1, 10) * 1000;
+			timerTime = handle->getDuration().msecs() + vm->_rnd->getRandomNumberRng(1, 10) * 1000;
 		}
 
 		sunnerTime = timerTime + vm->getTotalPlayTime();
@@ -896,7 +896,7 @@ static void sunnersLowerStairsTimer(MohawkEngine_Riven *vm) {
 	VideoHandle oldHandle = vm->_video->findVideoHandleRiven(1);
 	uint32 timerTime = 500;
 
-	if (oldHandle == NULL_VID_HANDLE || vm->_video->endOfVideo(oldHandle)) {
+	if (!oldHandle || oldHandle->endOfVideo()) {
 		uint32 &sunnerTime = vm->_vars["jsunnertime"];
 
 		if (sunnerTime == 0) {
@@ -904,7 +904,7 @@ static void sunnersLowerStairsTimer(MohawkEngine_Riven *vm) {
 		} else if (sunnerTime < vm->getTotalPlayTime()) {
 			VideoHandle handle = vm->_video->playMovieRiven(vm->_rnd->getRandomNumberRng(3, 5));
 
-			timerTime = vm->_video->getDuration(handle).msecs() + vm->_rnd->getRandomNumberRng(1, 30) * 1000;
+			timerTime = handle->getDuration().msecs() + vm->_rnd->getRandomNumberRng(1, 30) * 1000;
 		}
 
 		sunnerTime = timerTime + vm->getTotalPlayTime();
@@ -926,7 +926,7 @@ static void sunnersBeachTimer(MohawkEngine_Riven *vm) {
 	VideoHandle oldHandle = vm->_video->findVideoHandleRiven(3);
 	uint32 timerTime = 500;
 
-	if (oldHandle == NULL_VID_HANDLE || vm->_video->endOfVideo(oldHandle)) {
+	if (!oldHandle || oldHandle->endOfVideo()) {
 		uint32 &sunnerTime = vm->_vars["jsunnertime"];
 
 		if (sunnerTime == 0) {
@@ -938,7 +938,7 @@ static void sunnersBeachTimer(MohawkEngine_Riven *vm) {
 			vm->_video->activateMLST(mlstID, vm->getCurCard());
 			VideoHandle handle = vm->_video->playMovieRiven(mlstID);
 
-			timerTime = vm->_video->getDuration(handle).msecs() + vm->_rnd->getRandomNumberRng(1, 30) * 1000;
+			timerTime = handle->getDuration().msecs() + vm->_rnd->getRandomNumberRng(1, 30) * 1000;
 		}
 
 		sunnerTime = timerTime + vm->getTotalPlayTime();
@@ -969,7 +969,7 @@ void MohawkEngine_Riven::installCardTimer() {
 }
 
 void MohawkEngine_Riven::doVideoTimer(VideoHandle handle, bool force) {
-	assert(handle != NULL_VID_HANDLE);
+	assert(handle);
 
 	uint16 id = _scriptMan->getStoredMovieOpcodeID();
 
@@ -977,7 +977,7 @@ void MohawkEngine_Riven::doVideoTimer(VideoHandle handle, bool force) {
 		return;
 
 	// Run the opcode if we can at this point
-	if (force || _video->getTime(handle) >= _scriptMan->getStoredMovieOpcodeTime())
+	if (force || handle->getTime() >= _scriptMan->getStoredMovieOpcodeTime())
 		_scriptMan->runStoredMovieOpcode();
 }
 
@@ -1003,7 +1003,7 @@ void MohawkEngine_Riven::checkSunnerAlertClick() {
 
 	// If the alert video is no longer playing, we have nothing left to do
 	VideoHandle handle = _video->findVideoHandleRiven(1);
-	if (handle == NULL_VID_HANDLE || _video->endOfVideo(handle))
+	if (!handle || handle->endOfVideo())
 		return;
 
 	sunners = 1;
diff --git a/engines/mohawk/riven_external.cpp b/engines/mohawk/riven_external.cpp
index cda0683028..00075039fe 100644
--- a/engines/mohawk/riven_external.cpp
+++ b/engines/mohawk/riven_external.cpp
@@ -229,7 +229,7 @@ void RivenExternal::runCredits(uint16 video, uint32 delay) {
 	VideoHandle videoHandle = _vm->_video->findVideoHandleRiven(video);
 
 	while (!_vm->shouldQuit() && _vm->_gfx->getCurCreditsImage() <= 320) {
-		if (_vm->_video->getCurFrame(videoHandle) >= (int32)_vm->_video->getFrameCount(videoHandle) - 1) {
+		if (videoHandle->getCurFrame() >= (int32)videoHandle->getFrameCount() - 1) {
 			if (nextCreditsFrameStart == 0) {
 				// Set us up to start after delay ms
 				nextCreditsFrameStart = _vm->_system->getMillis() + delay;
@@ -265,10 +265,10 @@ void RivenExternal::runDomeCheck() {
 	// Check if we clicked while the golden frame was showing
 
 	VideoHandle video = _vm->_video->findVideoHandleRiven(1);
-	assert(video != NULL_VID_HANDLE);
+	assert(video);
 
-	int32 curFrame = _vm->_video->getCurFrame(video);
-	int32 frameCount = _vm->_video->getFrameCount(video);
+	int32 curFrame = video->getCurFrame();
+	int32 frameCount = video->getFrameCount();
 
 	// The final frame of the video is the 'golden' frame (double meaning: the
 	// frame that is the magic one is the one with the golden symbol) but we
@@ -857,8 +857,12 @@ void RivenExternal::xbupdateboiler(uint16 argc, uint16 *argv) {
 			_vm->_video->playMovieRiven(7);
 		}
 	} else {
-		_vm->_video->disableMovieRiven(7);
-		_vm->_video->disableMovieRiven(8);
+		VideoHandle handle = _vm->_video->findVideoHandleRiven(7);
+		if (handle)
+			handle->setEnabled(false);
+		handle = _vm->_video->findVideoHandleRiven(8);
+		if (handle)
+			handle->setEnabled(false);
 	}
 }
 
@@ -1149,8 +1153,8 @@ void RivenExternal::lowerPins() {
 
 	// Play the video of the pins going down
 	VideoHandle handle = _vm->_video->playMovieRiven(upMovie);
-	assert(handle != NULL_VID_HANDLE);
-	_vm->_video->setVideoBounds(handle, Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, startTime + 550, 600));
+	assert(handle);
+	handle->setBounds(Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, startTime + 550, 600));
 	_vm->_video->waitUntilMovieEnds(handle);
 
 	upMovie = 0;
@@ -1181,8 +1185,8 @@ void RivenExternal::xgrotatepins(uint16 argc, uint16 *argv) {
 
 	// Play the video of the pins rotating
 	VideoHandle handle = _vm->_video->playMovieRiven(_vm->_vars["gupmoov"]);
-	assert(handle != NULL_VID_HANDLE);
-	_vm->_video->setVideoBounds(handle, Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, startTime + 1215, 600));
+	assert(handle);
+	handle->setBounds(Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, startTime + 1215, 600));
 	_vm->_video->waitUntilMovieEnds(handle);
 }
 
@@ -1265,9 +1269,9 @@ void RivenExternal::xgpincontrols(uint16 argc, uint16 *argv) {
 
 	// Actually play the movie
 	VideoHandle handle = _vm->_video->playMovieRiven(pinMovieCodes[imagePos - 1]);
-	assert(handle != NULL_VID_HANDLE);
+	assert(handle);
 	uint32 startTime = 9630 - pinPos * 600;
-	_vm->_video->setVideoBounds(handle, Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, startTime + 550, 600));
+	handle->setBounds(Audio::Timestamp(0, startTime, 600), Audio::Timestamp(0, startTime + 550, 600));
 	_vm->_video->waitUntilMovieEnds(handle);
 
 	// Update the relevant variables
@@ -1343,8 +1347,8 @@ void RivenExternal::xgrviewer(uint16 argc, uint16 *argv) {
 
 	// Now play the movie
 	VideoHandle handle = _vm->_video->playMovieRiven(1);
-	assert(handle != NULL_VID_HANDLE);
-	_vm->_video->setVideoBounds(handle, Audio::Timestamp(0, s_viewerTimeIntervals[curPos], 600), Audio::Timestamp(0, s_viewerTimeIntervals[newPos], 600));
+	assert(handle);
+	handle->setBounds(Audio::Timestamp(0, s_viewerTimeIntervals[curPos], 600), Audio::Timestamp(0, s_viewerTimeIntervals[newPos], 600));
 	_vm->_video->waitUntilMovieEnds(handle);
 
 	// Set the new position and let the card's scripts take over again
@@ -1412,8 +1416,8 @@ void RivenExternal::xglviewer(uint16 argc, uint16 *argv) {
 
 	// Now play the movie
 	VideoHandle handle = _vm->_video->playMovieRiven(1);
-	assert(handle != NULL_VID_HANDLE);
-	_vm->_video->setVideoBounds(handle, Audio::Timestamp(0, s_viewerTimeIntervals[curPos], 600), Audio::Timestamp(0, s_viewerTimeIntervals[newPos], 600));
+	assert(handle);
+	handle->setBounds(Audio::Timestamp(0, s_viewerTimeIntervals[curPos], 600), Audio::Timestamp(0, s_viewerTimeIntervals[newPos], 600));
 	_vm->_video->waitUntilMovieEnds(handle);
 
 	// Set the new position to the variable
@@ -1467,7 +1471,7 @@ static void catherineViewerIdleTimer(MohawkEngine_Riven *vm) {
 	VideoHandle videoHandle = vm->_video->playMovieRiven(30);
 
 	// Reset the timer
-	vm->installTimer(&catherineViewerIdleTimer, vm->_video->getDuration(videoHandle).msecs() + vm->_rnd->getRandomNumber(60) * 1000);
+	vm->installTimer(&catherineViewerIdleTimer, videoHandle->getDuration().msecs() + vm->_rnd->getRandomNumber(60) * 1000);
 }
 
 void RivenExternal::xglview_prisonon(uint16 argc, uint16 *argv) {
@@ -1507,7 +1511,7 @@ void RivenExternal::xglview_prisonon(uint16 argc, uint16 *argv) {
 		_vm->_video->activateMLST(cathMovie, _vm->getCurCard());
 		VideoHandle videoHandle = _vm->_video->playMovieRiven(30);
 
-		timeUntilNextMovie = _vm->_video->getDuration(videoHandle).msecs() + _vm->_rnd->getRandomNumber(60) * 1000;
+		timeUntilNextMovie = videoHandle->getDuration().msecs() + _vm->_rnd->getRandomNumber(60) * 1000;
 	} else {
 		// Otherwise, just redraw the imager
 		timeUntilNextMovie = _vm->_rnd->getRandomNumberRng(10, 20) * 1000;
@@ -1986,7 +1990,7 @@ void RivenExternal::xschool280_playwhark(uint16 argc, uint16 *argv) {
 	Audio::Timestamp startTime = Audio::Timestamp(0, (11560 / 19) * (*posVar), 600);
 	*posVar += number; // Adjust to the end
 	Audio::Timestamp endTime = Audio::Timestamp(0, (11560 / 19) * (*posVar), 600);
-	_vm->_video->setVideoBounds(handle, startTime, endTime);
+	handle->setBounds(startTime, endTime);
 	_vm->_video->waitUntilMovieEnds(handle);
 
 	if (*posVar > 19) {
@@ -2059,7 +2063,7 @@ void RivenExternal::xbookclick(uint16 argc, uint16 *argv) {
 	debug(0, "\tHotspot    = %d -> %d", argv[3], hotspotMap[argv[3] - 1]);
 
 	// Just let the video play while we wait until Gehn opens the trap book for us
-	while (_vm->_video->getTime(video) < startTime && !_vm->shouldQuit()) {
+	while (video->getTime() < startTime && !_vm->shouldQuit()) {
 		if (_vm->_video->updateMovies())
 			_vm->_system->updateScreen();
 
@@ -2084,7 +2088,7 @@ void RivenExternal::xbookclick(uint16 argc, uint16 *argv) {
 
 	// OK, Gehn has opened the trap book and has asked us to go in. Let's watch
 	// and see what the player will do...
-	while (_vm->_video->getTime(video) < endTime && !_vm->shouldQuit()) {
+	while (video->getTime() < endTime && !_vm->shouldQuit()) {
 		bool updateScreen = _vm->_video->updateMovies();
 
 		Common::Event event;
@@ -2335,7 +2339,7 @@ static void rebelPrisonWindowTimer(MohawkEngine_Riven *vm) {
 	VideoHandle handle = vm->_video->playMovieRiven(movie);
 
 	// Ensure the next video starts after this one ends
-	uint32 timeUntilNextVideo = vm->_video->getDuration(handle).msecs() + vm->_rnd->getRandomNumberRng(38, 58) * 1000;
+	uint32 timeUntilNextVideo = handle->getDuration().msecs() + vm->_rnd->getRandomNumberRng(38, 58) * 1000;
 
 	// Save the time in case we leave the card and return
 	vm->_vars["rvillagetime"] = timeUntilNextVideo + vm->getTotalPlayTime();
@@ -2434,7 +2438,7 @@ void RivenExternal::xtexterior300_telescopedown(uint16 argc, uint16 *argv) {
 		static const uint32 timeIntervals[] = { 4320, 3440, 2560, 1760, 880, 0 };
 		uint16 movieCode = telescopeCover ? 1 : 2;
 		VideoHandle handle = _vm->_video->playMovieRiven(movieCode);
-		_vm->_video->setVideoBounds(handle, Audio::Timestamp(0, timeIntervals[telescopePos], 600), Audio::Timestamp(0, timeIntervals[telescopePos - 1], 600));
+		handle->setBounds(Audio::Timestamp(0, timeIntervals[telescopePos], 600), Audio::Timestamp(0, timeIntervals[telescopePos - 1], 600));
 		_vm->_sound->playSound(14); // Play the moving sound
 		_vm->_video->waitUntilMovieEnds(handle);
 
@@ -2467,7 +2471,7 @@ void RivenExternal::xtexterior300_telescopeup(uint16 argc, uint16 *argv) {
 	static const uint32 timeIntervals[] = { 0, 800, 1680, 2560, 3440, 4320 };
 	uint16 movieCode = _vm->_vars["ttelecover"] ? 4 : 5;
 	VideoHandle handle = _vm->_video->playMovieRiven(movieCode);
-	_vm->_video->setVideoBounds(handle, Audio::Timestamp(0, timeIntervals[telescopePos - 1], 600), Audio::Timestamp(0, timeIntervals[telescopePos], 600));
+	handle->setBounds(Audio::Timestamp(0, timeIntervals[telescopePos - 1], 600), Audio::Timestamp(0, timeIntervals[telescopePos], 600));
 	_vm->_sound->playSound(14); // Play the moving sound
 	_vm->_video->waitUntilMovieEnds(handle);
 
@@ -2569,26 +2573,47 @@ void RivenExternal::xt7500_checkmarbles(uint16 argc, uint16 *argv) {
 
 void RivenExternal::xt7600_setupmarbles(uint16 argc, uint16 *argv) {
 	// Draw the small marbles when we're a step away from the waffle
-	uint16 baseBitmapId = _vm->findResourceID(ID_TBMP, "*tsmallred");
+
+	// Convert from marble X coordinate to screen X coordinate
+	static const uint16 xPosOffsets[] = {
+		246, 245, 244, 243, 243, 241, 240, 240, 239, 238, 237, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 226, 225
+	};
+
+	// Convert from marble Y coordinate to screen Y coordinate
+	static const uint16 yPosOffsets[] = {
+		261, 263, 265, 267, 268, 270, 272, 274, 276, 278, 281, 284, 285, 288, 290, 293, 295, 298, 300, 303, 306, 309, 311, 314, 316
+	};
+
+	// Handle spacing for y coordinates due to the angle
+	static const double yAdjusts[] = {
+		4.56, 4.68, 4.76, 4.84, 4.84, 4.96, 5.04, 5.04, 5.12, 5.2, 5.28, 5.28, 5.36, 5.44, 5.4, 5.6, 5.72, 5.8, 5.88, 5.96, 6.04, 6.12, 6.2, 6.2, 6.28
+	};
+
+	// Waffle state of 0 is up, 1 down
 	bool waffleDown = _vm->_vars["twaffle"] != 0;
 
 	// Note that each of the small marble images is exactly 4x2
+	// The original seems to scale the marble images from extras.mhk, but
+	// we're using the pre-scaled images in the stack.
+	uint16 baseBitmapId = _vm->findResourceID(ID_TBMP, "*tsmallred");
 
 	for (uint16 i = 0; i < kMarbleCount; i++) {
-		uint32 &var = _vm->_vars[s_marbleNames[i]];
+		uint32 var = _vm->_vars[s_marbleNames[i]];
 
 		if (var == 0) {
 			// The marble is still in its initial place
 			// (Note that this is still drawn even if the waffle is down)
-			int marbleX = 376 + i * 2;
-			int marbleY = 253 + i * 4;
-			_vm->_gfx->copyImageToScreen(baseBitmapId + i, marbleX, marbleY, marbleX + kSmallMarbleWidth, marbleY + kSmallMarbleHeight);
+			static const uint16 defaultX[] = { 375, 377, 379, 381, 383, 385 };
+			static const uint16 defaultY[] = { 253, 257, 261, 265, 268, 273 };
+			_vm->_gfx->copyImageToScreen(baseBitmapId + i, defaultX[i], defaultY[i], defaultX[i] + kSmallMarbleWidth, defaultY[i] + kSmallMarbleHeight);
 		} else if (waffleDown) {
 			// The marble is on the grid and the waffle is down
 			// (Nothing to draw here)
 		} else {
 			// The marble is on the grid and the waffle is up
-			// TODO: Draw them onto the grid
+			int marbleX = (int)floor(getMarbleX(var) * yAdjusts[getMarbleY(var)] + xPosOffsets[getMarbleY(var)] + 0.5);
+			int marbleY = yPosOffsets[getMarbleY(var)];
+			_vm->_gfx->copyImageToScreen(baseBitmapId + i, marbleX, marbleY, marbleX + kSmallMarbleWidth, marbleY + kSmallMarbleHeight);
 		}
 	}
 }
diff --git a/engines/mohawk/riven_scripts.cpp b/engines/mohawk/riven_scripts.cpp
index 29ee5cd50b..caa235ec8b 100644
--- a/engines/mohawk/riven_scripts.cpp
+++ b/engines/mohawk/riven_scripts.cpp
@@ -493,7 +493,9 @@ void RivenScript::changeStack(uint16 op, uint16 argc, uint16 *argv) {
 
 // Command 28: disable a movie
 void RivenScript::disableMovie(uint16 op, uint16 argc, uint16 *argv) {
-	_vm->_video->disableMovieRiven(argv[0]);
+	VideoHandle handle = _vm->_video->findVideoHandleRiven(argv[0]);
+	if (handle)
+		handle->setEnabled(false);
 }
 
 // Command 29: disable all movies
@@ -503,7 +505,9 @@ void RivenScript::disableAllMovies(uint16 op, uint16 argc, uint16 *argv) {
 
 // Command 31: enable a movie
 void RivenScript::enableMovie(uint16 op, uint16 argc, uint16 *argv) {
-	_vm->_video->enableMovieRiven(argv[0]);
+	VideoHandle handle = _vm->_video->findVideoHandleRiven(argv[0]);
+	if (handle)
+		handle->setEnabled(true);
 }
 
 // Command 32: play foreground movie - blocking (movie_id)
diff --git a/engines/mohawk/sound.cpp b/engines/mohawk/sound.cpp
index 6f18d7178e..198627e012 100644
--- a/engines/mohawk/sound.cpp
+++ b/engines/mohawk/sound.cpp
@@ -77,8 +77,8 @@ void Sound::initMidi() {
 	_midiParser->setTimerRate(_midiDriver->getBaseTempo());
 }
 
-Audio::AudioStream *Sound::makeAudioStream(uint16 id, CueList *cueList) {
-	Audio::AudioStream *audStream = NULL;
+Audio::RewindableAudioStream *Sound::makeAudioStream(uint16 id, CueList *cueList) {
+	Audio::RewindableAudioStream *audStream = NULL;
 
 	switch (_vm->getGameType()) {
 	case GType_MYST:
@@ -109,17 +109,18 @@ Audio::AudioStream *Sound::makeAudioStream(uint16 id, CueList *cueList) {
 Audio::SoundHandle *Sound::playSound(uint16 id, byte volume, bool loop, CueList *cueList) {
 	debug (0, "Playing sound %d", id);
 
-	Audio::AudioStream *audStream = makeAudioStream(id, cueList);
+	Audio::RewindableAudioStream *rewindStream = makeAudioStream(id, cueList);
 
-	if (audStream) {
+	if (rewindStream) {
 		SndHandle *handle = getHandle();
 		handle->type = kUsedHandle;
 		handle->id = id;
-		handle->samplesPerSecond = audStream->getRate();
+		handle->samplesPerSecond = rewindStream->getRate();
 
 		// Set the stream to loop here if it's requested
+		Audio::AudioStream *audStream = rewindStream;
 		if (loop)
-			audStream = Audio::makeLoopingAudioStream((Audio::RewindableAudioStream *)audStream, 0);
+			audStream = Audio::makeLoopingAudioStream(rewindStream, 0);
 
 		_vm->_mixer->playStream(Audio::Mixer::kPlainSoundType, &handle->handle, audStream, -1, volume);
 		return &handle->handle;
@@ -335,11 +336,12 @@ void Sound::playSLSTSound(uint16 id, bool fade, bool loop, uint16 volume, int16
 	sndHandle.id = id;
 	_currentSLSTSounds.push_back(sndHandle);
 
-	Audio::AudioStream *audStream = makeMohawkWaveStream(_vm->getResource(ID_TWAV, id));
+	Audio::RewindableAudioStream *rewindStream = makeMohawkWaveStream(_vm->getResource(ID_TWAV, id));
 
 	// Loop here if necessary
+	Audio::AudioStream *audStream = rewindStream;
 	if (loop)
-		audStream = Audio::makeLoopingAudioStream((Audio::RewindableAudioStream *)audStream, 0);
+		audStream = Audio::makeLoopingAudioStream(rewindStream, 0);
 
 	// TODO: Handle fading, possibly just raise the volume of the channel in increments?
 
@@ -363,7 +365,7 @@ void Sound::resumeSLST() {
 		_vm->_mixer->pauseHandle(*_currentSLSTSounds[i].handle, false);
 }
 
-Audio::AudioStream *Sound::makeMohawkWaveStream(Common::SeekableReadStream *stream, CueList *cueList) {
+Audio::RewindableAudioStream *Sound::makeMohawkWaveStream(Common::SeekableReadStream *stream, CueList *cueList) {
 	uint32 tag = 0;
 	ADPCMStatus adpcmStatus;
 	DataChunk dataChunk;
@@ -507,7 +509,7 @@ Audio::AudioStream *Sound::makeMohawkWaveStream(Common::SeekableReadStream *stre
 	return NULL;
 }
 
-Audio::AudioStream *Sound::makeLivingBooksWaveStream_v1(Common::SeekableReadStream *stream) {
+Audio::RewindableAudioStream *Sound::makeLivingBooksWaveStream_v1(Common::SeekableReadStream *stream) {
 	uint16 header = stream->readUint16BE();
 	uint16 rate = 0;
 	uint32 size = 0;
@@ -646,15 +648,15 @@ Audio::SoundHandle *Sound::replaceBackgroundMyst(uint16 id, uint16 volume) {
 	stopBackgroundMyst();
 
 	// Play new sound
-	Audio::AudioStream *audStream = makeAudioStream(id);
+	Audio::RewindableAudioStream *rewindStream = makeAudioStream(id);
 
-	if (audStream) {
+	if (rewindStream) {
 		_mystBackgroundSound.type = kUsedHandle;
 		_mystBackgroundSound.id = id;
-		_mystBackgroundSound.samplesPerSecond = audStream->getRate();
+		_mystBackgroundSound.samplesPerSecond = rewindStream->getRate();
 
 		// Set the stream to loop
-		audStream = Audio::makeLoopingAudioStream((Audio::RewindableAudioStream *)audStream, 0);
+		Audio::AudioStream *audStream = Audio::makeLoopingAudioStream(rewindStream, 0);
 
 		_vm->_mixer->playStream(Audio::Mixer::kPlainSoundType, &_mystBackgroundSound.handle, audStream, -1, volume >> 8);
 		return &_mystBackgroundSound.handle;
diff --git a/engines/mohawk/sound.h b/engines/mohawk/sound.h
index 49f6751072..75c9492d96 100644
--- a/engines/mohawk/sound.h
+++ b/engines/mohawk/sound.h
@@ -156,13 +156,13 @@ private:
 	MidiParser *_midiParser;
 	byte *_midiData;
 
-	static Audio::AudioStream *makeMohawkWaveStream(Common::SeekableReadStream *stream, CueList *cueList = NULL);
-	static Audio::AudioStream *makeLivingBooksWaveStream_v1(Common::SeekableReadStream *stream);
+	static Audio::RewindableAudioStream *makeMohawkWaveStream(Common::SeekableReadStream *stream, CueList *cueList = NULL);
+	static Audio::RewindableAudioStream *makeLivingBooksWaveStream_v1(Common::SeekableReadStream *stream);
 	void initMidi();
 
 	Common::Array<SndHandle> _handles;
 	SndHandle *getHandle();
-	Audio::AudioStream *makeAudioStream(uint16 id, CueList *cueList = NULL);
+	Audio::RewindableAudioStream *makeAudioStream(uint16 id, CueList *cueList = NULL);
 	uint16 convertMystID(uint16 id);
 
 	// Myst-specific
diff --git a/engines/mohawk/video.cpp b/engines/mohawk/video.cpp
index cebb72e24f..ff4a69cd28 100644
--- a/engines/mohawk/video.cpp
+++ b/engines/mohawk/video.cpp
@@ -24,6 +24,7 @@
 #include "mohawk/resource.h"
 #include "mohawk/video.h"
 
+#include "common/algorithm.h"
 #include "common/debug.h"
 #include "common/events.h"
 #include "common/textconsole.h"
@@ -37,22 +38,115 @@
 
 namespace Mohawk {
 
-void VideoEntry::clear() {
-	video = 0;
-	x = 0;
-	y = 0;
-	loop = false;
-	enabled = false;
-	start = Audio::Timestamp(0, 1);
-	filename.clear();
-	id = -1;
+VideoEntry::VideoEntry() : _video(0), _id(-1), _x(0), _y(0), _loop(false), _enabled(true) {
 }
 
-bool VideoEntry::endOfVideo() {
-	return !video || video->endOfVideo();
+VideoEntry::VideoEntry(Video::VideoDecoder *video, const Common::String &fileName) : _video(video), _fileName(fileName), _id(-1), _x(0), _y(0), _loop(false), _enabled(true) {
+}
+
+VideoEntry::VideoEntry(Video::VideoDecoder *video, int id) : _video(video), _id(id), _x(0), _y(0), _loop(false), _enabled(true) {
+}
+
+VideoEntry::~VideoEntry() {
+	close();
+}
+
+void VideoEntry::close() {
+	delete _video;
+	_video = 0;
+}
+
+bool VideoEntry::endOfVideo() const {
+	return !isOpen() || _video->endOfVideo();
+}
+
+int VideoEntry::getCurFrame() const {
+	assert(_video);
+	return _video->getCurFrame();
+}
+
+uint32 VideoEntry::getFrameCount() const {
+	assert(_video);
+	return _video->getFrameCount();
+}
+
+uint32 VideoEntry::getTime() const {
+	assert(_video);
+	return _video->getTime();
+}
+
+Audio::Timestamp VideoEntry::getDuration() const {
+	assert(_video);
+	return _video->getDuration();
+}
+
+Common::Rational VideoEntry::getRate() const {
+	assert(_video);
+	return _video->getRate();
+}
+
+void VideoEntry::center() {
+	assert(_video);
+	_x = (g_system->getWidth() - _video->getWidth()) / 2;
+	_y = (g_system->getHeight() - _video->getHeight()) / 2;
+}
+
+void VideoEntry::setBounds(const Audio::Timestamp &startTime, const Audio::Timestamp &endTime) {
+	assert(_video);
+	_start = startTime;
+	_video->setEndTime(endTime);
+	_video->seek(startTime);
+}
+
+void VideoEntry::seek(const Audio::Timestamp &time) {
+	assert(_video);
+	_video->seek(time);
+}
+
+void VideoEntry::setRate(const Common::Rational &rate) {
+	assert(_video);
+	_video->setRate(rate);
+}
+
+void VideoEntry::pause(bool isPaused) {
+	assert(_video);
+	_video->pauseVideo(isPaused);
+}
+
+void VideoEntry::start() {
+	assert(_video);
+	_video->start();
+}
+
+void VideoEntry::stop() {
+	assert(_video);
+	_video->stop();
+}
+
+bool VideoEntry::isPlaying() const {
+	assert(_video);
+	return _video->isPlaying();
+}
+
+int VideoEntry::getVolume() const {
+	assert(_video);
+	return _video->getVolume();
+}
+
+void VideoEntry::setVolume(int volume) {
+	assert(_video);
+	_video->setVolume(CLIP(volume, 0, 255));
+}
+
+VideoHandle::VideoHandle(VideoEntryPtr ptr) : _ptr(ptr) {
+}
+
+VideoHandle::VideoHandle(const VideoHandle &handle) : _ptr(handle._ptr) {
 }
 
 VideoManager::VideoManager(MohawkEngine* vm) : _vm(vm) {
+	// Set dithering enabled, if required
+	_enableDither = _vm->getGameType() == GType_MYST && !(_vm->getFeatures() & GF_ME);
 }
 
 VideoManager::~VideoManager() {
@@ -60,41 +154,42 @@ VideoManager::~VideoManager() {
 }
 
 void VideoManager::pauseVideos() {
-	for (uint16 i = 0; i < _videoStreams.size(); i++)
-		if (_videoStreams[i].video)
-			_videoStreams[i]->pauseVideo(true);
+	for (VideoList::iterator it = _videos.begin(); it != _videos.end(); it++)
+		(*it)->pause(true);
 }
 
 void VideoManager::resumeVideos() {
-	for (uint16 i = 0; i < _videoStreams.size(); i++)
-		if (_videoStreams[i].video)
-			_videoStreams[i]->pauseVideo(false);
+	for (VideoList::iterator it = _videos.begin(); it != _videos.end(); it++)
+		(*it)->pause(false);
 }
 
 void VideoManager::stopVideos() {
-	for (uint16 i = 0; i < _videoStreams.size(); i++)
-		delete _videoStreams[i].video;
+	for (VideoList::iterator it = _videos.begin(); it != _videos.end(); it++)
+		(*it)->close();
 
-	_videoStreams.clear();
+	_videos.clear();
 }
 
-void VideoManager::playMovieBlocking(const Common::String &filename, uint16 x, uint16 y, bool clearScreen) {
-	VideoHandle videoHandle = createVideoHandle(filename, x, y, false);
-	if (videoHandle == NULL_VID_HANDLE)
+void VideoManager::playMovieBlocking(const Common::String &fileName, uint16 x, uint16 y, bool clearScreen) {
+	VideoEntryPtr ptr = open(fileName);
+	if (!ptr)
 		return;
 
+	ptr->moveTo(x, y);
+
 	// Clear screen if requested
 	if (clearScreen) {
 		_vm->_system->fillScreen(_vm->_system->getScreenFormat().RGBToColor(0, 0, 0));
 		_vm->_system->updateScreen();
 	}
 
-	waitUntilMovieEnds(videoHandle);
+	ptr->start();
+	waitUntilMovieEnds(ptr);
 }
 
-void VideoManager::playMovieBlockingCentered(const Common::String &filename, bool clearScreen) {
-	VideoHandle videoHandle = createVideoHandle(filename, 0, 0, false);
-	if (videoHandle == NULL_VID_HANDLE)
+void VideoManager::playMovieBlockingCentered(const Common::String &fileName, bool clearScreen) {
+	VideoEntryPtr ptr = open(fileName);
+	if (!ptr)
 		return;
 
 	// Clear screen if requested
@@ -103,19 +198,22 @@ void VideoManager::playMovieBlockingCentered(const Common::String &filename, boo
 		_vm->_system->updateScreen();
 	}
 
-	_videoStreams[videoHandle].x = (_vm->_system->getWidth() - _videoStreams[videoHandle]->getWidth()) / 2;
-	_videoStreams[videoHandle].y = (_vm->_system->getHeight() - _videoStreams[videoHandle]->getHeight()) / 2;
-
-	waitUntilMovieEnds(videoHandle);
+	ptr->center();
+	ptr->start();
+	waitUntilMovieEnds(ptr);
 }
 
 void VideoManager::waitUntilMovieEnds(VideoHandle videoHandle) {
-	if (videoHandle == NULL_VID_HANDLE)
+	if (!videoHandle)
 		return;
 
+	// Sanity check
+	if (videoHandle._ptr->isLooping())
+		error("Called waitUntilMovieEnds() on a looping video");
+
 	bool continuePlaying = true;
 
-	while (!_videoStreams[videoHandle].endOfVideo() && !_vm->shouldQuit() && continuePlaying) {
+	while (!videoHandle->endOfVideo() && !_vm->shouldQuit() && continuePlaying) {
 		if (updateMovies())
 			_vm->_system->updateScreen();
 
@@ -147,12 +245,22 @@ void VideoManager::waitUntilMovieEnds(VideoHandle videoHandle) {
 		_vm->_system->delayMillis(10);
 	}
 
-	delete _videoStreams[videoHandle].video;
-	_videoStreams[videoHandle].clear();
+	// Ensure it's removed
+	removeEntry(videoHandle._ptr);
 }
 
 void VideoManager::delayUntilMovieEnds(VideoHandle videoHandle) {
-	while (!_videoStreams[videoHandle].endOfVideo() && !_vm->shouldQuit()) {
+	// FIXME: Why is this separate from waitUntilMovieEnds?
+	// It seems to only cut out the event loop (which is bad).
+
+	if (!videoHandle)
+		return;
+
+	// Sanity check
+	if (videoHandle._ptr->isLooping())
+		error("Called delayUntilMovieEnds() on a looping video");
+
+	while (!videoHandle->endOfVideo() && !_vm->shouldQuit()) {
 		if (updateMovies())
 			_vm->_system->updateScreen();
 
@@ -160,92 +268,85 @@ void VideoManager::delayUntilMovieEnds(VideoHandle videoHandle) {
 		_vm->_system->delayMillis(10);
 	}
 
-	delete _videoStreams[videoHandle].video;
-	_videoStreams[videoHandle].clear();
+	// Ensure it's removed
+	removeEntry(videoHandle._ptr);
 }
 
-VideoHandle VideoManager::playMovie(const Common::String &filename, int16 x, int16 y, bool loop) {
-	VideoHandle videoHandle = createVideoHandle(filename, x, y, loop);
-	if (videoHandle == NULL_VID_HANDLE)
-		return NULL_VID_HANDLE;
-
-	// Center x if requested
-	if (x < 0)
-		_videoStreams[videoHandle].x = (_vm->_system->getWidth() - _videoStreams[videoHandle]->getWidth()) / 2;
+VideoHandle VideoManager::playMovie(const Common::String &fileName) {
+	VideoEntryPtr ptr = open(fileName);
+	if (!ptr)
+		return VideoHandle();
 
-	// Center y if requested
-	if (y < 0)
-		_videoStreams[videoHandle].y = (_vm->_system->getHeight() - _videoStreams[videoHandle]->getHeight()) / 2;
-
-	return videoHandle;
+	ptr->start();
+	return ptr;
 }
 
-VideoHandle VideoManager::playMovie(uint16 id, int16 x, int16 y, bool loop) {
-	VideoHandle videoHandle = createVideoHandle(id, x, y, loop);
-	if (videoHandle == NULL_VID_HANDLE)
-		return NULL_VID_HANDLE;
-
-	// Center x if requested
-	if (x < 0)
-		_videoStreams[videoHandle].x = (_vm->_system->getWidth() - _videoStreams[videoHandle]->getWidth()) / 2;
+VideoHandle VideoManager::playMovie(uint16 id) {
+	VideoEntryPtr ptr = open(id);
+	if (!ptr)
+		return VideoHandle();
 
-	// Center y if requested
-	if (y < 0)
-		_videoStreams[videoHandle].y = (_vm->_system->getHeight() - _videoStreams[videoHandle]->getHeight()) / 2;
-
-	return videoHandle;
+	ptr->start();
+	return ptr;
 }
 
 bool VideoManager::updateMovies() {
 	bool updateScreen = false;
 
-	for (uint32 i = 0; i < _videoStreams.size() && !_vm->shouldQuit(); i++) {
-		// Skip deleted videos
-		if (!_videoStreams[i].video)
-			continue;
-
-		// Remove any videos that are over
-		if (_videoStreams[i].endOfVideo()) {
-			if (_videoStreams[i].loop) {
-				_videoStreams[i]->seek(_videoStreams[i].start);
+	for (VideoList::iterator it = _videos.begin(); it != _videos.end(); ) {
+		// Check of the video has reached the end
+		if ((*it)->endOfVideo()) {
+			if ((*it)->isLooping()) {
+				// Seek back if looping
+				(*it)->seek((*it)->getStart());
 			} else {
-				// Check the video time one last time before deleting it
-				_vm->doVideoTimer(i, true);
-				delete _videoStreams[i].video;
-				_videoStreams[i].clear();
+				// Done; close and continue on
+				(*it)->close();
+				it = _videos.erase(it);
 				continue;
 			}
 		}
 
-		// Nothing more to do if we're paused
-		if (_videoStreams[i]->isPaused())
+		Video::VideoDecoder *video = (*it)->_video;
+
+		// Ignore paused videos
+		if (video->isPaused()) {
+			it++;
 			continue;
+		}
 
 		// Check if we need to draw a frame
-		if (_videoStreams[i]->needsUpdate()) {
-			const Graphics::Surface *frame = _videoStreams[i]->decodeNextFrame();
+		if (video->needsUpdate()) {
+			const Graphics::Surface *frame = video->decodeNextFrame();
 			Graphics::Surface *convertedFrame = 0;
 
-			if (frame && _videoStreams[i].enabled) {
+			if (frame && (*it)->isEnabled()) {
 				Graphics::PixelFormat pixelFormat = _vm->_system->getScreenFormat();
 
 				if (frame->format != pixelFormat) {
-					// We don't support downconverting to 8bpp
-					if (pixelFormat.bytesPerPixel == 1)
-						error("Cannot convert high color video frame to 8bpp");
+					// We don't support downconverting to 8bpp without having
+					// support in the codec. Set _enableDither if shows up.
+					if (pixelFormat.bytesPerPixel == 1) {
+						warning("Cannot convert high color video frame to 8bpp");
+						(*it)->close();
+						it = _videos.erase(it);
+						continue;
+					}
 
 					// Convert to the current screen format
-					convertedFrame = frame->convertTo(pixelFormat, _videoStreams[i]->getPalette());
+					convertedFrame = frame->convertTo(pixelFormat, video->getPalette());
 					frame = convertedFrame;
-				} else if (pixelFormat.bytesPerPixel == 1 && _videoStreams[i]->hasDirtyPalette()) {
+				} else if (pixelFormat.bytesPerPixel == 1 && video->hasDirtyPalette()) {
 					// Set the palette when running in 8bpp mode only
-					_vm->_system->getPaletteManager()->setPalette(_videoStreams[i]->getPalette(), 0, 256);
+					// Don't do this for Myst, which has its own per-stack handling
+					if (_vm->getGameType() != GType_MYST)
+						_vm->_system->getPaletteManager()->setPalette(video->getPalette(), 0, 256);
 				}
 
 				// Clip the width/height to make sure we stay on the screen (Myst does this a few times)
-				uint16 width = MIN<int32>(_videoStreams[i]->getWidth(), _vm->_system->getWidth() - _videoStreams[i].x);
-				uint16 height = MIN<int32>(_videoStreams[i]->getHeight(), _vm->_system->getHeight() - _videoStreams[i].y);
-				_vm->_system->copyRectToScreen(frame->getPixels(), frame->pitch, _videoStreams[i].x, _videoStreams[i].y, width, height);
+				uint16 width = MIN<int32>(video->getWidth(), _vm->_system->getWidth() - (*it)->getX());
+				uint16 height = MIN<int32>(video->getHeight(), _vm->_system->getHeight() - (*it)->getY());
+				_vm->_system->copyRectToScreen(frame->getPixels(), frame->pitch, (*it)->getX(), (*it)->getY(), width, height);
 
 				// We've drawn something to the screen, make sure we update it
 				updateScreen = true;
@@ -259,7 +360,10 @@ bool VideoManager::updateMovies() {
 		}
 
 		// Check the video time
-		_vm->doVideoTimer(i, false);
+		_vm->doVideoTimer(*it, false);
+
+		// Remember to increase the iterator
+		it++;
 	}
 
 	// Return true if we need to update the screen
@@ -314,241 +418,180 @@ void VideoManager::clearMLST() {
 }
 
 VideoHandle VideoManager::playMovieRiven(uint16 id) {
-	for (uint16 i = 0; i < _mlstRecords.size(); i++)
+	for (uint16 i = 0; i < _mlstRecords.size(); i++) {
 		if (_mlstRecords[i].code == id) {
 			debug(1, "Play tMOV %d (non-blocking) at (%d, %d) %s, Volume = %d", _mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top, _mlstRecords[i].loop != 0 ? "looping" : "non-looping", _mlstRecords[i].volume);
-			return createVideoHandle(_mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top, _mlstRecords[i].loop != 0, _mlstRecords[i].volume);
+
+			VideoEntryPtr ptr = open(_mlstRecords[i].movieID);
+			if (ptr) {
+				ptr->moveTo(_mlstRecords[i].left, _mlstRecords[i].top);
+				ptr->setLooping(_mlstRecords[i].loop != 0);
+				ptr->setVolume(_mlstRecords[i].volume);
+				ptr->start();
+			}
+
+			return ptr;
 		}
+	}
 
-	return NULL_VID_HANDLE;
+	return VideoHandle();
 }
 
 void VideoManager::playMovieBlockingRiven(uint16 id) {
-	for (uint16 i = 0; i < _mlstRecords.size(); i++)
+	for (uint16 i = 0; i < _mlstRecords.size(); i++) {
 		if (_mlstRecords[i].code == id) {
 			debug(1, "Play tMOV %d (blocking) at (%d, %d), Volume = %d", _mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top, _mlstRecords[i].volume);
-			VideoHandle videoHandle = createVideoHandle(_mlstRecords[i].movieID, _mlstRecords[i].left, _mlstRecords[i].top, false);
-			waitUntilMovieEnds(videoHandle);
+			VideoEntryPtr ptr = open(_mlstRecords[i].movieID);
+			ptr->moveTo(_mlstRecords[i].left, _mlstRecords[i].top);
+			ptr->setVolume(_mlstRecords[i].volume);
+			ptr->start();
+			waitUntilMovieEnds(ptr);
 			return;
 		}
+	}
 }
 
 void VideoManager::stopMovieRiven(uint16 id) {
 	debug(2, "Stopping movie %d", id);
-	for (uint16 i = 0; i < _mlstRecords.size(); i++)
-		if (_mlstRecords[i].code == id)
-			for (uint16 j = 0; j < _videoStreams.size(); j++)
-				if (_mlstRecords[i].movieID == _videoStreams[j].id) {
-					delete _videoStreams[j].video;
-					_videoStreams[j].clear();
-					return;
-				}
-}
-
-void VideoManager::enableMovieRiven(uint16 id) {
-	debug(2, "Enabling movie %d", id);
-	for (uint16 i = 0; i < _mlstRecords.size(); i++)
-		if (_mlstRecords[i].code == id)
-			for (uint16 j = 0; j < _videoStreams.size(); j++)
-				if (_mlstRecords[i].movieID == _videoStreams[j].id) {
-					_videoStreams[j].enabled = true;
-					return;
-				}
-}
-
-void VideoManager::disableMovieRiven(uint16 id) {
-	debug(2, "Disabling movie %d", id);
-	for (uint16 i = 0; i < _mlstRecords.size(); i++)
-		if (_mlstRecords[i].code == id)
-			for (uint16 j = 0; j < _videoStreams.size(); j++)
-				if (_mlstRecords[i].movieID == _videoStreams[j].id) {
-					_videoStreams[j].enabled = false;
-					return;
-				}
+	VideoHandle handle = findVideoHandleRiven(id);
+	if (handle)
+		removeEntry(handle._ptr);
 }
 
 void VideoManager::disableAllMovies() {
 	debug(2, "Disabling all movies");
-	for (uint16 i = 0; i < _videoStreams.size(); i++)
-		_videoStreams[i].enabled = false;
+	for (VideoList::iterator it = _videos.begin(); it != _videos.end(); it++)
+		(*it)->setEnabled(false);
 }
 
-VideoHandle VideoManager::createVideoHandle(uint16 id, uint16 x, uint16 y, bool loop, uint16 volume) {
-	// First, check to see if that video is already playing
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (_videoStreams[i].id == id)
-			return i;
+VideoEntryPtr VideoManager::open(uint16 id) {
+	// If this video is already playing, return that handle
+	VideoHandle oldHandle = findVideoHandle(id);
+	if (oldHandle._ptr)
+		return oldHandle._ptr;
 
 	// Otherwise, create a new entry
-	Video::QuickTimeDecoder *decoder = new Video::QuickTimeDecoder();
-	decoder->setChunkBeginOffset(_vm->getResourceOffset(ID_TMOV, id));
-	decoder->loadStream(_vm->getResource(ID_TMOV, id));
-	decoder->setVolume((volume >= 256) ? 255 : volume);
-
-	VideoEntry entry;
-	entry.clear();
-	entry.video = decoder;
-	entry.x = x;
-	entry.y = y;
-	entry.id = id;
-	entry.loop = loop;
-	entry.enabled = true;
-
-	entry->start();
-
-	// Search for any deleted videos so we can take a formerly used slot
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (!_videoStreams[i].video) {
-			_videoStreams[i] = entry;
-			return i;
-		}
+	Video::QuickTimeDecoder *video = new Video::QuickTimeDecoder();
+	video->setChunkBeginOffset(_vm->getResourceOffset(ID_TMOV, id));
+	video->loadStream(_vm->getResource(ID_TMOV, id));
+
+	// Create the entry
+	VideoEntryPtr entry(new VideoEntry(video, id));
+
+	// Enable dither if necessary
+	checkEnableDither(entry);
+
+	// Add it to the video list
+	_videos.push_back(entry);
 
-	// Otherwise, just add it to the list
-	_videoStreams.push_back(entry);
-	return _videoStreams.size() - 1;
+	return entry;
 }
 
-VideoHandle VideoManager::createVideoHandle(const Common::String &filename, uint16 x, uint16 y, bool loop, byte volume) {
-	// First, check to see if that video is already playing
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (_videoStreams[i].filename == filename)
-			return i;
+VideoEntryPtr VideoManager::open(const Common::String &fileName) {
+	// If this video is already playing, return that entry
+	VideoHandle oldHandle = findVideoHandle(fileName);
+	if (oldHandle._ptr)
+		return oldHandle._ptr;
 
 	// Otherwise, create a new entry
-	VideoEntry entry;
-	entry.clear();
-	entry.video = new Video::QuickTimeDecoder();
-	entry.x = x;
-	entry.y = y;
-	entry.filename = filename;
-	entry.loop = loop;
-	entry.enabled = true;
-
-	Common::File *file = new Common::File();
-	if (!file->open(filename)) {
-		delete file;
-		return NULL_VID_HANDLE;
+	Common::SeekableReadStream *stream = SearchMan.createReadStreamForMember(fileName);
+	if (!stream)
+		return VideoEntryPtr();
+
+	Video::VideoDecoder *video = new Video::QuickTimeDecoder();
+	if (!video->loadStream(stream)) {
+		// FIXME: Better error handling
+		delete video;
+		return VideoEntryPtr();
 	}
 
-	entry->loadStream(file);
-	entry->setVolume(volume);
-	entry->start();
+	// Create the entry
+	VideoEntryPtr entry(new VideoEntry(video, fileName));
 
-	// Search for any deleted videos so we can take a formerly used slot
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (!_videoStreams[i].video) {
-			_videoStreams[i] = entry;
-			return i;
-		}
+	// Enable dither if necessary
+	checkEnableDither(entry);
+
+	// Add it to the video list
+	_videos.push_back(entry);
 
-	// Otherwise, just add it to the list
-	_videoStreams.push_back(entry);
-	return _videoStreams.size() - 1;
+	return entry;
 }
 
 VideoHandle VideoManager::findVideoHandleRiven(uint16 id) {
 	for (uint16 i = 0; i < _mlstRecords.size(); i++)
 		if (_mlstRecords[i].code == id)
-			for (uint32 j = 0; j < _videoStreams.size(); j++)
-				if (_videoStreams[j].video && _mlstRecords[i].movieID == _videoStreams[j].id)
-					return j;
+			for (VideoList::iterator it = _videos.begin(); it != _videos.end(); it++)
+				if ((*it)->getID() == _mlstRecords[i].movieID)
+					return *it;
 
-	return NULL_VID_HANDLE;
+	return VideoHandle();
 }
 
 VideoHandle VideoManager::findVideoHandle(uint16 id) {
-	if (!id)
-		return NULL_VID_HANDLE;
+	if (id == 0)
+		return VideoHandle();
 
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (_videoStreams[i].video && _videoStreams[i].id == id)
-			return i;
+	for (VideoList::iterator it = _videos.begin(); it != _videos.end(); it++)
+		if ((*it)->getID() == id)
+			return *it;
 
-	return NULL_VID_HANDLE;
+	return VideoHandle();
 }
 
-VideoHandle VideoManager::findVideoHandle(const Common::String &filename) {
-	if (filename.empty())
-		return NULL_VID_HANDLE;
-
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (_videoStreams[i].video && _videoStreams[i].filename.equalsIgnoreCase(filename))
-			return i;
+VideoHandle VideoManager::findVideoHandle(const Common::String &fileName) {
+	if (fileName.empty())
+		return VideoHandle();
 
-	return NULL_VID_HANDLE;
-}
-
-int VideoManager::getCurFrame(VideoHandle handle) {
-	assert(handle != NULL_VID_HANDLE);
-	return _videoStreams[handle]->getCurFrame();
-}
+	for (VideoList::iterator it = _videos.begin(); it != _videos.end(); it++)
+		if ((*it)->getFileName().equalsIgnoreCase(fileName))
+			return *it;
 
-uint32 VideoManager::getFrameCount(VideoHandle handle) {
-	assert(handle != NULL_VID_HANDLE);
-	return _videoStreams[handle]->getFrameCount();
-}
-
-uint32 VideoManager::getTime(VideoHandle handle) {
-	assert(handle != NULL_VID_HANDLE);
-	return _videoStreams[handle]->getTime();
-}
-
-Audio::Timestamp VideoManager::getDuration(VideoHandle handle) {
-	assert(handle != NULL_VID_HANDLE);
-	return _videoStreams[handle]->getDuration();
-}
-
-bool VideoManager::endOfVideo(VideoHandle handle) {
-	assert(handle != NULL_VID_HANDLE);
-	return _videoStreams[handle].endOfVideo();
+	return VideoHandle();
 }
 
 bool VideoManager::isVideoPlaying() {
-	for (uint32 i = 0; i < _videoStreams.size(); i++)
-		if (!_videoStreams[i].endOfVideo())
+	for (VideoList::iterator it = _videos.begin(); it != _videos.end(); it++)
+		if (!(*it)->endOfVideo())
 			return true;
 
 	return false;
 }
 
-void VideoManager::setVideoBounds(VideoHandle handle, Audio::Timestamp start, Audio::Timestamp end) {
-	assert(handle != NULL_VID_HANDLE);
-	_videoStreams[handle].start = start;
-	_videoStreams[handle]->setEndTime(end);
-	_videoStreams[handle]->seek(start);
-}
-
-void VideoManager::drawVideoFrame(VideoHandle handle, Audio::Timestamp time) {
-	assert(handle != NULL_VID_HANDLE);
-	_videoStreams[handle]->seek(time);
+void VideoManager::drawVideoFrame(VideoHandle handle, const Audio::Timestamp &time) {
+	// FIXME: This should be done separately from the "playing"
+	// videos eventually.
+	assert(handle);
+	handle->seek(time);
 	updateMovies();
-	delete _videoStreams[handle].video;
-	_videoStreams[handle].clear();
+	handle->close();
 }
 
-void VideoManager::seekToTime(VideoHandle handle, Audio::Timestamp time) {
-	assert(handle != NULL_VID_HANDLE);
-	_videoStreams[handle]->seek(time);
+VideoManager::VideoList::iterator VideoManager::findEntry(VideoEntryPtr ptr) {
+	return Common::find(_videos.begin(), _videos.end(), ptr);
 }
 
-void VideoManager::setVideoLooping(VideoHandle handle, bool loop) {
-	assert(handle != NULL_VID_HANDLE);
-	_videoStreams[handle].loop = loop;
+void VideoManager::removeEntry(VideoEntryPtr ptr) {
+	VideoManager::VideoList::iterator it = findEntry(ptr);
+	if (it != _videos.end())
+		_videos.erase(it);
 }
 
-Common::Rational VideoManager::getVideoRate(VideoHandle handle) const {
-	assert(handle != NULL_VID_HANDLE);
-	return _videoStreams[handle]->getRate();
-}
+void VideoManager::checkEnableDither(VideoEntryPtr &entry) {
+	// If we're not dithering, bail out
+	if (!_enableDither)
+		return;
 
-void VideoManager::setVideoRate(VideoHandle handle, const Common::Rational &rate) {
-	assert(handle != NULL_VID_HANDLE);
-	_videoStreams[handle]->setRate(rate);
-}
+	// Set the palette
+	byte palette[256 * 3];
+	g_system->getPaletteManager()->grabPalette(palette, 0, 256);
+	entry->_video->setDitheringPalette(palette);
 
-void VideoManager::pauseMovie(VideoHandle handle, bool pause) {
-	assert(handle != NULL_VID_HANDLE);
-	_videoStreams[handle]->pauseVideo(pause);
+	if (entry->_video->getPixelFormat().bytesPerPixel != 1) {
+		if (entry->getFileName().empty())
+			error("Failed to set dither for video tMOV %d", entry->getID());
+		else
+			error("Failed to set dither for video %s", entry->getFileName().c_str());
+	}
 }
 
 } // End of namespace Mohawk
diff --git a/engines/mohawk/video.h b/engines/mohawk/video.h
index 43181e3e6c..106a32f8e2 100644
--- a/engines/mohawk/video.h
+++ b/engines/mohawk/video.h
@@ -23,9 +23,17 @@
 #ifndef MOHAWK_VIDEO_H
 #define MOHAWK_VIDEO_H
 
+#include "audio/timestamp.h"
 #include "common/array.h"
+#include "common/list.h"
+#include "common/noncopyable.h"
+#include "common/ptr.h"
+#include "common/rational.h"
 #include "graphics/pixelformat.h"
-#include "video/video_decoder.h"
+
+namespace Video {
+class VideoDecoder;
+}
 
 namespace Mohawk {
 
@@ -43,29 +51,254 @@ struct MLSTRecord {
 	uint16 u1;
 };
 
-struct VideoEntry {
+/**
+ * A video monitored by the VideoManager
+ */
+class VideoEntry : private Common::NonCopyable {
+	// The private members should be able to be manipulated by VideoManager
+	friend class VideoManager;
+
+private:
+	// Hide the destructor/constructor
+	// Only VideoManager should be allowed
+	VideoEntry();
+	VideoEntry(Video::VideoDecoder *video, const Common::String &fileName);
+	VideoEntry(Video::VideoDecoder *video, int id);
+
+public:
+	~VideoEntry();
+
+	/**
+	 * Convenience implicit cast to bool
+	 */
+	operator bool() const { return isOpen(); }
+
+	/**
+	 * Is the video open?
+	 */
+	bool isOpen() const { return _video != 0; }
+
+	/**
+	 * Close the video
+	 */
+	void close();
+
+	/**
+	 * Has the video reached its end?
+	 */
+	bool endOfVideo() const;
+
+	/**
+	 * Get the X position of where the video is displayed
+	 */
+	uint16 getX() const { return _x; }
+
+	/**
+	 * Get the Y position of where the video is displayed
+	 */
+	uint16 getY() const { return _y; }
+
+	/**
+	 * Is the video looping?
+	 */
+	bool isLooping() const { return _loop; }
+
+	/**
+	 * Is the video enabled? (Drawing to the screen)
+	 */
+	bool isEnabled() const { return _enabled; }
+
+	/**
+	 * Get the start time of the video bounds
+	 */
+	const Audio::Timestamp &getStart() const { return _start; }
+
+	/**
+	 * Get the file name of the video, or empty if by ID
+	 */
+	const Common::String &getFileName() const { return _fileName; }
+
+	/**
+	 * Get the ID of the video, or -1 if by file name
+	 */
+	int getID() const { return _id; }
+
+	/**
+	 * Get the current frame of the video
+	 */
+	int getCurFrame() const;
+
+	/**
+	 * Get the frame count of the video
+	 */
+	uint32 getFrameCount() const;
+
+	/**
+	 * Get the current time position of the video
+	 */
+	uint32 getTime() const;
+
+	/**
+	 * Get the duration of the video
+	 */
+	Audio::Timestamp getDuration() const;
+
+	/**
+	 * Get the current playback rate of the videos
+	 */
+	Common::Rational getRate() const;
+
+	/**
+	 * Move the x position of the video
+	 */
+	void setX(uint16 x) { _x = x; }
+
+	/**
+	 * Move the y position of the video
+	 */
+	void setY(uint16 y) { _y = y; }
+
+	/**
+	 * Move the video to the specified coordinates
+	 */
+	void moveTo(uint16 x, uint16 y) { setX(x); setY(y); }
+
+	/**
+	 * Center the video on the screen
+	 */
+	void center();
+
+	/**
+	 * Set the start time when using video bounds
+	 */
+	void setStart(const Audio::Timestamp &time) { _start = time; }
+
+	/**
+	 * Set the video to loop (true) or not (false)
+	 */
+	void setLooping(bool loop) { _loop = loop; }
+
+	/**
+	 * Set the video's enabled status
+	 */
+	void setEnabled(bool enabled) { _enabled = enabled; }
+
+	/**
+	 * Set the bounds of the video
+	 *
+	 * This automatically seeks to the start time
+	 */
+	void setBounds(const Audio::Timestamp &startTime, const Audio::Timestamp &endTime);
+
+	/**
+	 * Seek to the given time
+	 */
+	void seek(const Audio::Timestamp &time);
+
+	/**
+	 * Set the playback rate
+	 */
+	void setRate(const Common::Rational &rate);
+
+	/**
+	 * Pause the video
+	 */
+	void pause(bool isPaused);
+
+	/**
+	 * Start playing the video
+	 */
+	void start();
+
+	/**
+	 * Stop playing the video
+	 */
+	void stop();
+
+	/**
+	 * Is the video playing?
+	 */
+	bool isPlaying() const;
+
+	/**
+	 * Get the volume of the video
+	 */
+	int getVolume() const;
+
+	/**
+	 * Set the volume of the video
+	 */
+	void setVolume(int volume);
+
+private:
+	// Non-changing variables
+	Video::VideoDecoder *_video;
+	Common::String _fileName; // External video files
+	int _id;                  // Internal Mohawk files
+
 	// Playback variables
-	Video::VideoDecoder *video;
-	uint16 x;
-	uint16 y;
-	bool loop;
-	bool enabled;
-	Audio::Timestamp start;
-
-	// Identification
-	Common::String filename; // External video files
-	int id;                  // Internal Mohawk files
-
-	// Helper functions
-	Video::VideoDecoder *operator->() const { assert(video); return video; } // TODO: Remove this eventually
-	void clear();
-	bool endOfVideo();
+	uint16 _x;
+	uint16 _y;
+	bool _loop;
+	bool _enabled;
+	Audio::Timestamp _start;
 };
 
-typedef int32 VideoHandle;
+typedef Common::SharedPtr<VideoEntry> VideoEntryPtr;
+
+/**
+ * A handle for manipulating a video
+ */
+class VideoHandle {
+	// The private members should be able to be manipulated by VideoManager
+	friend class VideoManager;
+
+public:
+	/**
+	 * Default constructor
+	 */
+	VideoHandle() {}
+
+	/**
+	 * Copy constructor
+	 */
+	VideoHandle(const VideoHandle &handle);
+
+	/**
+	 * Is this handle pointing to a valid video entry?
+	 */
+	bool isValid() const { return _ptr && _ptr->isOpen(); }
+
+	/**
+	 * Convenience implicit cast to bool
+	 */
+	operator bool() const { return isValid(); }
+
+	/**
+	 * Simple equality operator
+	 */
+	bool operator==(const VideoHandle &other) const { return _ptr.get() == other._ptr.get(); }
 
-enum {
-	NULL_VID_HANDLE = -1
+	/**
+	 * Simple inequality operator
+	 */
+	bool operator!=(const VideoHandle &other) const { return !(*this == other); }
+
+	/**
+	 * Convenience operator-> override to give direct access to the VideoEntry
+	 */
+	VideoEntryPtr operator->() const { return _ptr; }
+
+private:
+	/**
+	 * Constructor for internal VideoManager use
+	 */
+	VideoHandle(VideoEntryPtr ptr);
+
+	/**
+	 * The video entry this is associated with
+	 */
+	VideoEntryPtr _ptr;
 };
 
 class VideoManager {
@@ -76,8 +309,8 @@ public:
 	// Generic movie functions
 	void playMovieBlocking(const Common::String &filename, uint16 x = 0, uint16 y = 0, bool clearScreen = false);
 	void playMovieBlockingCentered(const Common::String &filename, bool clearScreen = true);
-	VideoHandle playMovie(const Common::String &filename, int16 x = -1, int16 y = -1, bool loop = false);
-	VideoHandle playMovie(uint16 id, int16 x = -1, int16 y = -1, bool loop = false);
+	VideoHandle playMovie(const Common::String &filename);
+	VideoHandle playMovie(uint16 id);
 	bool updateMovies();
 	void pauseVideos();
 	void resumeVideos();
@@ -87,31 +320,18 @@ public:
 	// Riven-related functions
 	void activateMLST(uint16 mlstId, uint16 card);
 	void clearMLST();
-	void enableMovieRiven(uint16 id);
-	void disableMovieRiven(uint16 id);
 	void disableAllMovies();
 	VideoHandle playMovieRiven(uint16 id);
-	void stopMovieRiven(uint16 id);
 	void playMovieBlockingRiven(uint16 id);
 	VideoHandle findVideoHandleRiven(uint16 id);
+	void stopMovieRiven(uint16 id);
 
 	// Handle functions
 	VideoHandle findVideoHandle(uint16 id);
-	VideoHandle findVideoHandle(const Common::String &filename);
-	int getCurFrame(VideoHandle handle);
-	uint32 getFrameCount(VideoHandle handle);
-	uint32 getTime(VideoHandle handle);
-	Audio::Timestamp getDuration(VideoHandle videoHandle);
-	bool endOfVideo(VideoHandle handle);
-	void setVideoBounds(VideoHandle handle, Audio::Timestamp start, Audio::Timestamp end);
-	void drawVideoFrame(VideoHandle handle, Audio::Timestamp time);
-	void seekToTime(VideoHandle handle, Audio::Timestamp time);
-	void setVideoLooping(VideoHandle handle, bool loop);
-	Common::Rational getVideoRate(VideoHandle handle) const;
-	void setVideoRate(VideoHandle handle, const Common::Rational &rate);
-	void waitUntilMovieEnds(VideoHandle videoHandle);
-	void delayUntilMovieEnds(VideoHandle videoHandle);
-	void pauseMovie(VideoHandle videoHandle, bool pause);
+	VideoHandle findVideoHandle(const Common::String &fileName);
+	void waitUntilMovieEnds(VideoHandle handle);
+	void delayUntilMovieEnds(VideoHandle handle);
+	void drawVideoFrame(VideoHandle handle, const Audio::Timestamp &time);
 
 private:
 	MohawkEngine *_vm;
@@ -120,10 +340,19 @@ private:
 	Common::Array<MLSTRecord> _mlstRecords;
 
 	// Keep tabs on any videos playing
-	Common::Array<VideoEntry> _videoStreams;
+	typedef Common::List<VideoEntryPtr> VideoList;
+	VideoList _videos;
+
+	// Utility functions for managing entries
+	VideoEntryPtr open(uint16 id);
+	VideoEntryPtr open(const Common::String &fileName);
+	
+	VideoList::iterator findEntry(VideoEntryPtr ptr);
+	void removeEntry(VideoEntryPtr ptr);
 
-	VideoHandle createVideoHandle(uint16 id, uint16 x, uint16 y, bool loop, uint16 volume = 0xff);
-	VideoHandle createVideoHandle(const Common::String &filename, uint16 x, uint16 y, bool loop, byte volume = 0xff);
+	// Dithering control
+	bool _enableDither;
+	void checkEnableDither(VideoEntryPtr &entry);
 };
 
 } // End of namespace Mohawk
diff --git a/engines/mortevielle/actions.cpp b/engines/mortevielle/actions.cpp
index 556475d515..b7b9c1e000 100644
--- a/engines/mortevielle/actions.cpp
+++ b/engines/mortevielle/actions.cpp
@@ -571,6 +571,7 @@ void MortevielleEngine::fctSearch() {
 				_curSearchObjId = getFirstObject();
 				if (_curSearchObjId != 0) {
 					_searchCount = 0;
+					_is = 0;
 					_heroSearching = true;
 					_menu->setSearchMenu();
 					prepareNextObject();
@@ -1678,9 +1679,8 @@ void MortevielleEngine::endGame() {
 	handleDescriptionText(2, 35);
 	startMusicOrSpeech(0);
 	testKey(false);
-	// A wait message was displayed.
-	// testKey (aka tkey1) was called before and after.
-	// This double call is useless, thus removed
+	displayInterScreenMessage(2036);
+	testKey(false);
 	resetVariables();
 }
 
diff --git a/engines/mortevielle/detection_tables.h b/engines/mortevielle/detection_tables.h
index d244d15365..fb85e749ad 100644
--- a/engines/mortevielle/detection_tables.h
+++ b/engines/mortevielle/detection_tables.h
@@ -110,6 +110,23 @@ static const MortevielleGameDescription MortevielleGameDescriptions[] = {
 		}, Common::DE_DEU, kUseEngineDataFile
 	},
 
+	// French, provided by ultrapingu in bug ref #6575
+	{
+		{
+			"mortevielle",
+			"",
+			{
+				{"menu.mor", 0, "3fef0a3f8fca99fdcb6dbca8cbcef46f", 160},
+				{"dxx.mor", 0, "949e68e829ecd5ad29e36a00347a9e7e", 207744},
+				AD_LISTEND
+			},
+			Common::FR_FRA,
+			Common::kPlatformDOS,
+			ADGF_NO_FLAGS,
+			GUIO0()
+		}, Common::FR_FRA, kUseEngineDataFile
+	},
+
 	{ AD_TABLE_END_MARKER , Common::EN_ANY, kUseEngineDataFile}
 };
 
diff --git a/engines/mortevielle/dialogs.cpp b/engines/mortevielle/dialogs.cpp
index 89098fabe5..9df66846d2 100644
--- a/engines/mortevielle/dialogs.cpp
+++ b/engines/mortevielle/dialogs.cpp
@@ -66,12 +66,12 @@ int DialogManager::show(const Common::String &msg) {
 		drawAlertBox(10, 5, colNumb);
 	} else {
 		drawAlertBox(8, 7, colNumb);
-		int i = 0;
+		int i = -1;
 		_vm->_screenSurface->_textPos.y = 70;
 		do {
 			curPos.x = 320;
 			Common::String displayStr = "";
-			while ((alertStr[i + 1] != '\174') && (alertStr[i + 1] != '\135')) {
+			while ((alertStr[i + 1] != '|') && (alertStr[i + 1] != ']')) {
 				++i;
 				displayStr += alertStr[i];
 				curPos.x -= 3;
@@ -405,7 +405,7 @@ void DialogManager::drawF3F8() {
 	int f8Width = _vm->_screenSurface->getStringWidth(f8);
 
 	// Write out the bounding box
-	_vm->_screenSurface->drawBox(0, 42, MAX(f3Width, f8Width) + 6, 18, 7);
+	_vm->_screenSurface->drawBox(0, 42, MAX(f3Width, f8Width) + 4, 16, 7);
 }
 
 /**
diff --git a/engines/mortevielle/graphics.cpp b/engines/mortevielle/graphics.cpp
index 553c1a759e..aa479fdd44 100644
--- a/engines/mortevielle/graphics.cpp
+++ b/engines/mortevielle/graphics.cpp
@@ -1019,6 +1019,8 @@ void ScreenSurface::writeCharacter(const Common::Point &pt, unsigned char ch, in
  *		simulate the original 640x400 surface, all Y values have to be doubled
  */
 void ScreenSurface::drawBox(int x, int y, int dx, int dy, int col) {
+	dx++; dy++;	// Original function draws 1px bigger
+
 	Graphics::Surface destSurface = lockArea(Common::Rect(x, y * 2, x + dx, (y + dy) * 2));
 
 	destSurface.hLine(0, 0, dx, col);
diff --git a/engines/mortevielle/menu.cpp b/engines/mortevielle/menu.cpp
index c0b81b252a..6235e9f2ed 100644
--- a/engines/mortevielle/menu.cpp
+++ b/engines/mortevielle/menu.cpp
@@ -682,6 +682,8 @@ void Menu::initMenu() {
 	if (!menuLoaded) {
 		// Load menu from game data using the original language
 		if (_vm->getOriginalLanguage() == Common::FR_FRA) {
+			// We do not support reading menu.mor (it has a different format).
+			// If the game version does not have menufr.mor it has to get the menu from the DAT file.
 			if (!f.open("menufr.mor"))
 				error("Missing file - menufr.mor");
 		} else { // Common::DE_DEU
diff --git a/engines/mortevielle/mortevielle.h b/engines/mortevielle/mortevielle.h
index 5f7f175c26..42d70fcb37 100644
--- a/engines/mortevielle/mortevielle.h
+++ b/engines/mortevielle/mortevielle.h
@@ -92,6 +92,7 @@ enum DataType {
 #define MORT_DAT_REQUIRED_VERSION 1
 #define MORT_DAT "mort.dat"
 #define GAME_FRAME_DELAY (1000 / 50)
+#define DISK_ACCESS_DELAY 1000
 
 const int kTime1 = 410;
 const int kTime2 = 250;
@@ -115,6 +116,7 @@ const int kInventoryStringIndex = 186;
 const int kQuestionStringIndex = 247;
 const int kDialogStringIndex = 292;
 const int kMenuPlaceStringIndex = 435;
+const int kStartingScreenStringIndex = 456;
 const int kMenuActionStringIndex = 476;
 const int kMenuSelfStringIndex = 497;
 const int kMenuSayStringIndex = 502;
@@ -415,6 +417,7 @@ public:
 	int _maff;
 	int _caff;
 	int _crep;
+	int _is;		// ???
 
 	byte _destinationArray[7][25];
 
@@ -465,6 +468,7 @@ public:
 	void gameLoaded();
 	void initGame();
 	void displayAloneText();
+	void displayInterScreenMessage(int mesgId);
 	void draw(int x, int y);
 	void charToHour();
 	void hourToChar();
diff --git a/engines/mortevielle/outtext.cpp b/engines/mortevielle/outtext.cpp
index 6a479c0859..5cbe4deab3 100644
--- a/engines/mortevielle/outtext.cpp
+++ b/engines/mortevielle/outtext.cpp
@@ -227,7 +227,31 @@ void TextHandler::taffich() {
 	Common::String filename, altFilename;
 
 	if ((a != 50) && (a != 51)) {
+		int m = a + 2000;
+
+		if ((m > 2001) && (m < 2010))
+			m = 2001;
+		else if (m == 2011)
+			m = 2010;
+		if (a == 32)
+			m = 2034;
+		else if ((a == 17) && (_vm->_maff == 14))
+			m = 2018;
+		else if (a > 99) {
+			if ((_vm->_is == 1) || (_vm->_is == 0))
+				m = 2031;
+			else
+				m = 2032;
+		}
+
+		if ( ((a > 69) && (a < 80)) || (a == 30) || (a == 31) || (a == 144) || (a == 147) || (a == 149) )
+			m = 2030;
+		else if ( ((a < 27) && ( ((_vm->_maff > 69) && (!_vm->_coreVar._alreadyEnteredManor)) || (_vm->_maff > 99) )) || ((_vm->_maff > 29) && (_vm->_maff < 33)) )
+			m = 2033;
+
+		_vm->displayInterScreenMessage(m);
 		_vm->_maff = a;
+
 		if (a == 159)
 			a = 86;
 		else if (a > 140)
diff --git a/engines/mortevielle/sound.cpp b/engines/mortevielle/sound.cpp
index 23ca9d89b4..f02ccb69ea 100644
--- a/engines/mortevielle/sound.cpp
+++ b/engines/mortevielle/sound.cpp
@@ -139,22 +139,44 @@ void SoundManager::loadAmbiantSounds() {
  * @remarks	Originally called 'charge_bruit' and 'charge_bruit5'
  */
 void SoundManager::loadNoise() {
-	Common::File f1, f2;
+	Common::File f1, f5;
 
-	if (!f1.open("bruits"))               //Translation: "noise"
-		error("Missing file - bruits");
-	if (!f2.open("bruit5"))
+	if (!f5.open("bruit5"))
 		error("Missing file - bruit5");
 
-	_noiseBuf = (byte *)malloc(sizeof(byte) * (f1.size() + f2.size()));
-	assert(f1.size() > 32000);
+	if (f1.open("bruits")) { //Translation: "noise"
+		assert(f1.size() > 32000);
+		_noiseBuf = (byte *)malloc(sizeof(byte) * (f1.size() + f5.size()));
 
-	f1.read(_noiseBuf, 32000); // 250 * 128
-	f2.read(&_noiseBuf[32000], f2.size());
-	f1.read(&_noiseBuf[32000 + f2.size()], f1.size() - 32000); // 19072
+		f1.read(_noiseBuf, 32000); // 250 * 128
+		f5.read(&_noiseBuf[32000], f5.size());
+		f1.read(&_noiseBuf[32000 + f5.size()], f1.size() - 32000); // 19072
 
-	f1.close();
-	f2.close();
+		f1.close();
+	} else {
+		Common::File f2, f3, f4;
+		if (!f1.open("bruit1") || !f2.open("bruit2") || !f3.open("bruit3") || !f4.open("bruit4"))
+			error("Missing file - bruits");
+
+		assert(f4.size() == 32000);
+		_noiseBuf = (byte *)malloc(sizeof(byte) * (f1.size() + f2.size() + f3.size() + f4.size() + f5.size()));
+
+		f4.read(_noiseBuf, f4.size());
+		int pos = f4.size();
+		f5.read(&_noiseBuf[pos], f5.size());
+		pos += f5.size();
+		f1.read(&_noiseBuf[pos], f1.size());
+		pos += f1.size();
+		f2.read(&_noiseBuf[pos], f2.size());
+		pos += f2.size();
+		f3.read(&_noiseBuf[pos], f3.size());
+
+		f1.close();
+		f2.close();
+		f3.close();
+		f4.close();
+	}
+	f5.close();
 }
 
 void SoundManager::regenbruit() {
diff --git a/engines/mortevielle/utils.cpp b/engines/mortevielle/utils.cpp
index 40136ad78b..cbc22e4886 100644
--- a/engines/mortevielle/utils.cpp
+++ b/engines/mortevielle/utils.cpp
@@ -234,6 +234,7 @@ void MortevielleEngine::setMousePos(const Common::Point &pt) {
 void MortevielleEngine::delay(int amount) {
 	uint32 endTime = g_system->getMillis() + amount;
 
+	g_system->showMouse(false);
 	while (g_system->getMillis() < endTime) {
 		if (g_system->getMillis() > (_lastGameFrame + GAME_FRAME_DELAY)) {
 			_lastGameFrame = g_system->getMillis();
@@ -244,6 +245,7 @@ void MortevielleEngine::delay(int amount) {
 
 		g_system->delayMillis(10);
 	}
+	g_system->showMouse(true);
 }
 
 /**
@@ -389,7 +391,7 @@ void MortevielleEngine::setTextColor(int col) {
  */
 void MortevielleEngine::prepareScreenType1() {
 	// Large drawing
-	_screenSurface->drawBox(0, 11, 512, 164, 15);
+	_screenSurface->drawBox(0, 11, 512, 163, 15);
 }
 
 /**
@@ -705,11 +707,11 @@ void MortevielleEngine::displayAloneText() {
 	Common::String sAlone = getEngineString(S_ALONE);
 
 	clearUpperRightPart();
-	_screenSurface->putxy(580 - (_screenSurface->getStringWidth(sYou) / 2), 30);
+	_screenSurface->putxy(560, 30);
 	_screenSurface->drawString(sYou, 4);
-	_screenSurface->putxy(580 - (_screenSurface->getStringWidth(sAre) / 2), 50);
+	_screenSurface->putxy(560, 50);
 	_screenSurface->drawString(sAre, 4);
-	_screenSurface->putxy(580 - (_screenSurface->getStringWidth(sAlone) / 2), 70);
+	_screenSurface->putxy(560, 70);
 	_screenSurface->drawString(sAlone, 4);
 
 	_currBitIndex = 0;
@@ -1357,6 +1359,7 @@ void MortevielleEngine::endSearch() {
 	_heroSearching = false;
 	_obpart = false;
 	_searchCount = 0;
+	_is = 0;
 	_menu->unsetSearchMenu();
 }
 
@@ -1379,7 +1382,7 @@ void MortevielleEngine::gotoDiningRoom() {
 		showPeoplePresent(_currBitIndex);
 		_caff = 77;
 		drawPictureWithText();
-		_screenSurface->drawBox(223, 47, 155, 92, 15);
+		_screenSurface->drawBox(223, 47, 155, 91, 15);
 		handleDescriptionText(2, 33);
 		testKey(false);
 		menuUp();
@@ -1467,6 +1470,7 @@ void MortevielleEngine::gameLoaded() {
 	_num = 0;
 	_startTime = 0;
 	_endTime = 0;
+	_is = 0;
 	_searchCount = 0;
 	_roomDoorId = OWN_ROOM;
 	_syn = true;
@@ -1653,11 +1657,11 @@ void MortevielleEngine::clearDescriptionBar() {
 	_mouse->hideMouse();
 	if (_largestClearScreen) {
 		_screenSurface->fillRect(0, Common::Rect(1, 176, 633, 199));
-		_screenSurface->drawBox(0, 176, 634, 23, 15);
+		_screenSurface->drawBox(0, 175, 634, 24, 15);
 		_largestClearScreen = false;
 	} else {
 		_screenSurface->fillRect(0, Common::Rect(1, 176, 633, 190));
-		_screenSurface->drawBox(0, 176, 634, 14, 15);
+		_screenSurface->drawBox(0, 175, 634, 15, 15);
 	}
 	_mouse->showMouse();
 }
@@ -1691,7 +1695,7 @@ void MortevielleEngine::clearUpperRightPart() {
 	else if (_coreVar._faithScore > 65)
 		st = getEngineString(S_MALSAINE);
 
-	int x1 = 580 - (_screenSurface->getStringWidth(st) / 2);
+	int x1 = 574 - (_screenSurface->getStringWidth(st) / 2);
 	_screenSurface->putxy(x1, 92);
 	_screenSurface->drawString(st, 4);
 
@@ -1722,6 +1726,22 @@ void MortevielleEngine::showMoveMenuAlert() {
  * @remarks	Originally called 'dialpre'
  */
 void MortevielleEngine::showConfigScreen() {
+	// FIXME: need a DOS palette, index 9 (light blue). Also we should show DOS font here
+	Common::String tmpStr;
+	int width, cy = 0;
+	clearScreen();
+ 	do {
+ 		++cy;
+ 		tmpStr = getString(cy + kStartingScreenStringIndex);
+ 		width = _screenSurface->getStringWidth(tmpStr);
+ 		_text->displayStr(tmpStr, 320 - width / 2, cy * 8, 80, 1, 2);
+ 	} while (cy != 20);
+
+ 	int ix = 0;
+ 	do {
+ 		++ix;
+ 	} while (!(keyPressed() || ix == 0x5e5));
+
 	_crep = 998;
 }
 
@@ -2095,8 +2115,12 @@ void MortevielleEngine::music() {
 	_reloadCFIEC = true;
 
 	Common::File f;
-	if (!f.open("mort.img"))
-		error("Missing file - mort.img");
+	if (!f.open("mort.img")) {
+		// Some DOS versions use MORTP2 instead of MORT.IMG
+		// Some have both and they are identical
+		if (!f.open("mortp2"))
+			error("Missing file - mort.img");
+	}
 
 	int size = f.size();
 	byte *compMusicBuf = (byte *)malloc(sizeof(byte) * size);
@@ -2124,9 +2148,11 @@ void MortevielleEngine::showTitleScreen() {
 	_caff = 51;
 	_text->taffich();
 	testKeyboard();
+	delay(DISK_ACCESS_DELAY);
 	clearScreen();
 	draw(0, 0);
 
+	// FIXME: should be a DOS font here
 	Common::String cpr = "COPYRIGHT 1989 : LANKHOR";
 	_screenSurface->putxy(104 + 72 * kResolutionScaler, 185);
 	_screenSurface->drawString(cpr, 0);
@@ -2521,6 +2547,18 @@ void MortevielleEngine::handleDescriptionText(int f, int mesgId) {
 				_coreVar._pctHintFound[10] = '*';
 			}
 			break;
+		case 7: {
+			prepareScreenType3();
+			Common::String tmpStr = getString(mesgId);
+			// CHECKME: original code seems to consider one extra character
+			// See text position in the 3rd intro screen
+			int size = tmpStr.size() + 1;
+			if (size < 40)
+				_text->displayStr(tmpStr, 252 - size * 3, 86, 50, 3, 5);
+			else
+				_text->displayStr(tmpStr, 144, 86, 50, 3, 5);
+			}
+			break;
 		default:
 			break;
 		}
@@ -2870,10 +2908,10 @@ void MortevielleEngine::drawPicture() {
 	clearUpperLeftPart();
 	if (_caff > 99) {
 		draw(60, 33);
-		_screenSurface->drawBox(118, 32, 291, 122, 15);         // Medium box
+		_screenSurface->drawBox(118, 32, 291, 121, 15);         // Medium box
 	} else if (_caff > 69) {
 		draw(112, 48);           // Heads
-		_screenSurface->drawBox(222, 47, 155, 92, 15);
+		_screenSurface->drawBox(222, 47, 155, 91, 15);
 	} else {
 		draw(0, 12);
 		prepareScreenType1();
@@ -2911,6 +2949,9 @@ void MortevielleEngine::drawPicture() {
 	}
 }
 
+/**
+ * @remarks	Originally called 'afdes'
+ */
 void MortevielleEngine::drawPictureWithText() {
 	_text->taffich();
 	drawPicture();
@@ -2971,6 +3012,26 @@ void MortevielleEngine::displayNarrativePicture(int af, int ob) {
 }
 
 /**
+ * Display a message switching from a screen to another.
+ * @remarks	Originally called 'messint'
+ */
+void MortevielleEngine::displayInterScreenMessage(int mesgId) {
+	clearUpperLeftPart();
+	clearDescriptionBar();
+	clearVerbBar();
+
+	GfxSurface surface;
+	surface.decode(_rightFramePict + 1008);
+	surface._offset.x = 80;
+	surface._offset.y = 40;
+	setPal(90);
+	_screenSurface->drawPicture(surface, 0, 0);
+	_screenSurface->drawPicture(surface, 0, 70);
+	handleDescriptionText(7, mesgId);
+	delay(DISK_ACCESS_DELAY);
+}
+
+/**
  * Prepare Display Text
  * @remarks	Originally called 'affrep'
  */
@@ -3072,7 +3133,7 @@ void MortevielleEngine::menuUp() {
  */
 void MortevielleEngine::drawDiscussionBox() {
 	draw(10, 80);
-	_screenSurface->drawBox(18, 79, 155, 92, 15);
+	_screenSurface->drawBox(18, 79, 155, 91, 15);
 }
 
 /**
@@ -3178,6 +3239,7 @@ void MortevielleEngine::prepareNextObject() {
 	} while ((objId == 0) && (_searchCount <= 9));
 
 	if ((objId != 0) && (_searchCount < 11)) {
+		_is++;
 		_caff = objId;
 		_crep = _caff + 400;
 		if (_currBitIndex != 0)
diff --git a/engines/neverhood/menumodule.cpp b/engines/neverhood/menumodule.cpp
index 255d04dc86..826f175d47 100644
--- a/engines/neverhood/menumodule.cpp
+++ b/engines/neverhood/menumodule.cpp
@@ -93,6 +93,10 @@ void MenuModule::setLoadgameInfo(uint index) {
 	_savegameSlot = (*_savegameList)[index].slotNum;
 }
 
+void MenuModule::setLoadgameSlot(int slot) {
+	_savegameSlot = slot;
+}
+
 void MenuModule::setSavegameInfo(const Common::String &description, uint index, bool newSavegame) {
 	_savegameDescription = description;
 	_savegameSlot = newSavegame ? -1 : (*_savegameList)[index].slotNum;
@@ -202,7 +206,7 @@ uint32 MenuModule::handleMessage(int messageNum, const MessageParam &param, Enti
 		break;
 	}
 
-	return Module::handleMessage(messageNum, param, sender);;
+	return Module::handleMessage(messageNum, param, sender);
 }
 
 void MenuModule::createLoadGameMenu() {
@@ -912,7 +916,7 @@ GameStateMenu::GameStateMenu(NeverhoodEngine *vm, Module *parentModule, Savegame
 
 		if (slot >= 0) {
 			if (!isSave) {
-				((MenuModule*)_parentModule)->setLoadgameInfo(slot);
+				((MenuModule*)_parentModule)->setLoadgameSlot(slot);
 			} else {
 				((MenuModule*)_parentModule)->setSavegameInfo(saveDesc,
 					slot, slot >= saveCount);
diff --git a/engines/neverhood/menumodule.h b/engines/neverhood/menumodule.h
index 6508ccbdf2..1c4ade2369 100644
--- a/engines/neverhood/menumodule.h
+++ b/engines/neverhood/menumodule.h
@@ -43,6 +43,7 @@ public:
 	MenuModule(NeverhoodEngine *vm, Module *parentModule, int which);
 	virtual ~MenuModule();
 	void setLoadgameInfo(uint index);
+	void setLoadgameSlot(int slot);
 	void setSavegameInfo(const Common::String &description, uint index, bool newSavegame);
 	void setDeletegameInfo(uint index);
 	void refreshSaveGameList();
diff --git a/engines/neverhood/modules/module2700.cpp b/engines/neverhood/modules/module2700.cpp
index a510c02558..e0c6509793 100644
--- a/engines/neverhood/modules/module2700.cpp
+++ b/engines/neverhood/modules/module2700.cpp
@@ -761,7 +761,7 @@ void Scene2702::moveCarToPoint(NPoint pt) {
 	_tracks.findTrackPoint(pt, minMatchTrackIndex, minMatchDistance, _dataResource);
 	if (minMatchTrackIndex >= 0 && minMatchTrackIndex != _currTrackIndex) {
 		_newTrackIndex = minMatchTrackIndex;
-		_newTrackDestX = pt.x;
+		_newTrackDest = pt;
 		if (_isUpperTrack) {
 			if (_currTrackIndex == 0)
 				sendMessage(_asCar, 0x2003, _trackPoints->size() - 1);
@@ -773,7 +773,7 @@ void Scene2702::moveCarToPoint(NPoint pt) {
 			sendMessage(_asCar, 0x2003, _trackPoints->size() - 1);
 	} else {
 		_newTrackIndex = -1;
-		sendMessage(_asCar, 0x2004, pt.x);
+		sendMessage(_asCar, 0x2004, pt);
 	}
 }
 
@@ -790,7 +790,7 @@ void Scene2702::changeTrack() {
 		sendMessage(_asCar, NM_POSITION_CHANGE, 0);
 	else
 		sendMessage(_asCar, NM_POSITION_CHANGE, _trackPoints->size() - 1);
-	sendMessage(_asCar, 0x2004, _newTrackDestX);
+	sendMessage(_asCar, 0x2004, _newTrackDest);
 	_newTrackIndex = -1;
 }
 
@@ -1092,14 +1092,14 @@ void Scene2706::moveCarToPoint(NPoint pt) {
 	_tracks.findTrackPoint(pt, minMatchTrackIndex, minMatchDistance, _dataResource);
 	if (minMatchTrackIndex >= 0 && minMatchTrackIndex != _currTrackIndex) {
 		_newTrackIndex = minMatchTrackIndex;
-		_newTrackDestX = pt.x;
+		_newTrackDest = pt;
 		if (_currTrackIndex == 0)
 			sendMessage(_asCar, 0x2003, _trackPoints->size() - 1);
 		else
 			sendMessage(_asCar, 0x2003, 0);
 	} else {
 		_newTrackIndex = -1;
-		sendMessage(_asCar, 0x2004, pt.x);
+		sendMessage(_asCar, 0x2004, pt);
 	}
 }
 
@@ -1111,7 +1111,7 @@ void Scene2706::changeTrack() {
 		sendMessage(_asCar, NM_POSITION_CHANGE, _trackPoints->size() - 1);
 	else
 		sendMessage(_asCar, NM_POSITION_CHANGE, 0);
-	sendMessage(_asCar, 0x2004, _newTrackDestX);
+	sendMessage(_asCar, 0x2004, _newTrackDest);
 	_newTrackIndex = -1;
 }
 
diff --git a/engines/neverhood/modules/module2700.h b/engines/neverhood/modules/module2700.h
index 9ac2159765..ece8866cd4 100644
--- a/engines/neverhood/modules/module2700.h
+++ b/engines/neverhood/modules/module2700.h
@@ -76,7 +76,7 @@ protected:
 	Sprite *_asCarShadow;
 	Sprite *_asCarTrackShadow;
 	Sprite *_asCarConnectorShadow;
-	int16 _newTrackDestX;
+	NPoint _newTrackDest;
 	bool _isInLight;
 	int _currTrackIndex, _newTrackIndex;
 	bool _isUpperTrack;
@@ -132,7 +132,7 @@ protected:
 	Sprite *_asCarConnector;
 	Sprite *_asCarTrackShadow;
 	Sprite *_asCarConnectorShadow;
-	int16 _newTrackDestX;
+	NPoint _newTrackDest;
 	int _currTrackIndex, _newTrackIndex;
 	Tracks _tracks;
 	NPointArray *_trackPoints;
diff --git a/engines/parallaction/adlib.cpp b/engines/parallaction/adlib.cpp
index 7c1dd1681f..568ad190aa 100644
--- a/engines/parallaction/adlib.cpp
+++ b/engines/parallaction/adlib.cpp
@@ -25,7 +25,7 @@
 
 #include "audio/fmopl.h"
 #include "audio/mpu401.h"
-#include "audio/softsynth/emumidi.h"
+#include "audio/mididrv.h"
 
 namespace Parallaction {
 
@@ -270,11 +270,13 @@ struct MelodicVoice {
 	int8 _octave;
 };
 
-class AdLibDriver : public MidiDriver_Emulated {
+class AdLibDriver : public MidiDriver {
 public:
-	AdLibDriver(Audio::Mixer *mixer) : MidiDriver_Emulated(mixer) {
+	AdLibDriver(Audio::Mixer *mixer) {
 		for (uint i = 0; i < 16; ++i)
 			_channels[i].init(this, i);
+
+		_isOpen = false;
 	}
 
 	int open();
@@ -282,11 +284,13 @@ public:
 	void send(uint32 b);
 	MidiChannel *allocateChannel();
 	MidiChannel *getPercussionChannel() { return &_channels[9]; }
+	bool isOpen() const { return _isOpen; }
+	uint32 getBaseTempo() { return 1000000 / OPL::OPL::kDefaultCallbackFrequency; }
 
-	bool isStereo() const { return false; }
-	int getRate() const { return _mixer->getOutputRate(); }
-
-	void generateSamples(int16 *buf, int len);
+	virtual void setTimerCallback(void *timerParam, Common::TimerManager::TimerProc timerProc) {
+		_adlibTimerProc = timerProc;
+		_adlibTimerParam = timerParam;
+	}
 
 protected:
 	OPL::OPL *_opl;
@@ -320,6 +324,13 @@ protected:
 	void muteMelodicVoice(uint8 voice);
 
 	void initVoices();
+
+private:
+	void onTimer();
+
+	Common::TimerManager::TimerProc _adlibTimerProc;
+	void *_adlibTimerParam;
+	bool _isOpen;
 };
 
 MidiDriver *createAdLibDriver() {
@@ -348,10 +359,10 @@ int AdLibDriver::open() {
 	if (_isOpen)
 		return MERR_ALREADY_OPEN;
 
-	MidiDriver_Emulated::open();
+	_isOpen = true;
 
 	_opl = OPL::Config::create();
-	_opl->init(getRate());
+	_opl->init();
 	_opl->writeReg(0x1, 0x20); // set bit 5 (enable all waveforms)
 
 	// Reset the OPL registers.
@@ -364,7 +375,7 @@ int AdLibDriver::open() {
 
 	initVoices();
 
-	_mixer->playStream(Audio::Mixer::kMusicSoundType, &_mixerSoundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
+	_opl->start(new Common::Functor0Mem<void, AdLibDriver>(this, &AdLibDriver::onTimer));
 	return 0;
 }
 
@@ -373,7 +384,6 @@ void AdLibDriver::close() {
 		return;
 
 	_isOpen = false;
-	_mixer->stopHandle(_mixerSoundHandle);
 
 	delete _opl;
 }
@@ -777,9 +787,9 @@ MidiChannel *AdLibDriver::allocateChannel() {
 	return NULL;
 }
 
-void AdLibDriver::generateSamples(int16 *buf, int len) {
-	memset(buf, 0, sizeof(int16) * len);
-	_opl->readBuffer(buf, len);
+void AdLibDriver::onTimer() {
+	if (_adlibTimerProc)
+		(*_adlibTimerProc)(_adlibTimerParam);
 }
 
 void AdLibDriver::initVoices() {
diff --git a/engines/pegasus/menu.cpp b/engines/pegasus/menu.cpp
index 4bbda8fd93..3e9bf540fe 100644
--- a/engines/pegasus/menu.cpp
+++ b/engines/pegasus/menu.cpp
@@ -258,12 +258,12 @@ void MainMenu::handleInput(const Input &input, const Hotspot *cursorSpot) {
 	bool isDemo = vm->isDemo();
 
 	if (input.upButtonDown()) {
-		if (_menuSelection > (isDemo ? kFirstSelectionDemo : kFirstSelection)) {
+		if (_menuSelection > (uint32)(isDemo ? kFirstSelectionDemo : kFirstSelection)) {
 			_menuSelection--;
 			updateDisplay();
 		}
 	} else if (input.downButtonDown()) {
-		if (_menuSelection < (isDemo ? kLastSelectionDemo : kLastSelection)) {
+		if (_menuSelection < (uint32)(isDemo ? kLastSelectionDemo : kLastSelection)) {
 			_menuSelection++;
 			updateDisplay();
 		}
diff --git a/engines/pegasus/sound.cpp b/engines/pegasus/sound.cpp
index 5b437b81d4..ddcb2be010 100644
--- a/engines/pegasus/sound.cpp
+++ b/engines/pegasus/sound.cpp
@@ -59,7 +59,15 @@ void Sound::initFromAIFFFile(const Common::String &fileName) {
 		return;
 	}
 
-	_stream = Audio::makeAIFFStream(file, DisposeAfterUse::YES);
+	Audio::RewindableAudioStream *stream = Audio::makeAIFFStream(file, DisposeAfterUse::YES);
+
+	_stream = dynamic_cast<Audio::SeekableAudioStream *>(stream);
+
+	if (!_stream) {
+		delete stream;
+		warning("AIFF stream '%s' is not seekable", fileName.c_str());
+		return;
+	}
 }
 
 void Sound::initFromQuickTime(const Common::String &fileName) {
diff --git a/engines/queen/midiadlib.cpp b/engines/queen/midiadlib.cpp
index 25175c21d7..f5bc0f4d58 100644
--- a/engines/queen/midiadlib.cpp
+++ b/engines/queen/midiadlib.cpp
@@ -23,118 +23,29 @@
 #include "common/endian.h"
 #include "common/textconsole.h"
 
-#include "audio/fmopl.h"
-#include "audio/softsynth/emumidi.h"
+#include "engines/queen/midiadlib.h"
 
 namespace Queen {
 
-class AdLibMidiDriver : public MidiDriver_Emulated {
-public:
-
-	AdLibMidiDriver(Audio::Mixer *mixer) : MidiDriver_Emulated(mixer) { _adlibWaveformSelect = 0; }
-	~AdLibMidiDriver() {}
-
-	// MidiDriver
-	int open();
-	void close();
-	void send(uint32 b);
-	void metaEvent(byte type, byte *data, uint16 length);
-	MidiChannel *allocateChannel() { return 0; }
-	MidiChannel *getPercussionChannel() { return 0; }
-
-	// AudioStream
-	bool isStereo() const { return false; }
-	int getRate() const { return _mixer->getOutputRate(); }
-
-	// MidiDriver_Emulated
-	void generateSamples(int16 *buf, int len);
-
-private:
-
-	void handleMidiEvent0x90_NoteOn(int channel, int param1, int param2);
-	void handleSequencerSpecificMetaEvent1(int channel, const uint8 *data);
-	void handleSequencerSpecificMetaEvent2(uint8 value);
-	void handleSequencerSpecificMetaEvent3(uint8 value);
-
-	void adlibWrite(uint8 port, uint8 value);
-	void adlibSetupCard();
-	void adlibSetupChannels(int fl);
-	void adlibResetAmpVibratoRhythm(int am, int vib, int kso);
-	void adlibResetChannels();
-	void adlibSetAmpVibratoRhythm();
-	void adlibSetCSMKeyboardSplit();
-	void adlibSetNoteMul(int mul);
-	void adlibSetWaveformSelect(int fl);
-	void adlibSetPitchBend(int channel, int range);
-	void adlibPlayNote(int channel);
-	uint8 adlibPlayNoteHelper(int channel, int note1, int note2, int oct);
-	void adlibTurnNoteOff(int channel);
-	void adlibTurnNoteOn(int channel, int note);
-	void adlibSetupChannelFromSequence(int channel, const uint8 *src, int fl);
-	void adlibSetupChannel(int channel, const uint16 *src, int fl);
-	void adlibSetNoteVolume(int channel, int volume);
-	void adlibSetupChannelHelper(int channel);
-	void adlibSetChannel0x40(int channel);
-	void adlibSetChannel0xC0(int channel);
-	void adlibSetChannel0x60(int channel);
-	void adlibSetChannel0x80(int channel);
-	void adlibSetChannel0x20(int channel);
-	void adlibSetChannel0xE0(int channel);
-
-	FM_OPL *_opl;
-	int _midiNumberOfChannels;
-	int _adlibNoteMul;
-	int _adlibWaveformSelect;
-	int _adlibAMDepthEq48;
-	int _adlibVibratoDepthEq14;
-	int _adlibRhythmEnabled;
-	int _adlibKeyboardSplitOn;
-	int _adlibVibratoRhythm;
-	uint8 _midiChannelsFreqTable[9];
-	uint8 _adlibChannelsLevelKeyScalingTable[11];
-	uint8 _adlibSetupChannelSequence1[14 * 18];
-	uint16 _adlibSetupChannelSequence2[14];
-	int16 _midiChannelsNote2Table[9];
-	uint8 _midiChannelsNote1Table[9];
-	uint8 _midiChannelsOctTable[9];
-	uint16 _adlibChannelsVolume[11];
-	uint16 _adlibMetaSequenceData[28];
-
-	static const uint8 _adlibChannelsMappingTable1[];
-	static const uint8 _adlibChannelsNoFeedback[];
-	static const uint8 _adlibChannelsMappingTable2[];
-	static const uint8 _adlibChannelsMappingTable3[];
-	static const uint8 _adlibChannelsKeyScalingTable1[];
-	static const uint8 _adlibChannelsKeyScalingTable2[];
-	static const uint8 _adlibChannelsVolumeTable[];
-	static const uint8 _adlibInitSequenceData1[];
-	static const uint8 _adlibInitSequenceData2[];
-	static const uint8 _adlibInitSequenceData3[];
-	static const uint8 _adlibInitSequenceData4[];
-	static const uint8 _adlibInitSequenceData5[];
-	static const uint8 _adlibInitSequenceData6[];
-	static const uint8 _adlibInitSequenceData7[];
-	static const uint8 _adlibInitSequenceData8[];
-	static const int16 _midiChannelsNoteTable[];
-	static const int16 _midiNoteFreqTable[];
-};
-
 int AdLibMidiDriver::open() {
-	MidiDriver_Emulated::open();
-	_opl = makeAdLibOPL(getRate());
+	_isOpen = true;
+	_opl = OPL::Config::create();
+	if (!_opl || !_opl->init())
+		error("Failed to create OPL");
+
 	adlibSetupCard();
 	for (int i = 0; i < 11; ++i) {
 		_adlibChannelsVolume[i] = 0;
 		adlibSetNoteVolume(i, 0);
 		adlibTurnNoteOff(i);
 	}
-	_mixer->playStream(Audio::Mixer::kMusicSoundType, &_mixerSoundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
+
+	_opl->start(new Common::Functor0Mem<void, AdLibMidiDriver>(this, &AdLibMidiDriver::onTimer));
 	return 0;
 }
 
 void AdLibMidiDriver::close() {
-	_mixer->stopHandle(_mixerSoundHandle);
-	OPLDestroy(_opl);
+	delete _opl;
 }
 
 void AdLibMidiDriver::send(uint32 b) {
@@ -164,6 +75,11 @@ void AdLibMidiDriver::send(uint32 b) {
 	}
 }
 
+void AdLibMidiDriver::setVolume(uint32 volume) {
+	for (int i = 0; i < _midiNumberOfChannels; ++i)
+		adlibSetChannelVolume(i, volume * 64 / 256 + 64);
+}
+
 void AdLibMidiDriver::metaEvent(byte type, byte *data, uint16 length) {
 	int event = 0;
 	if (length > 4 && READ_BE_UINT32(data) == 0x3F00) {
@@ -192,9 +108,14 @@ void AdLibMidiDriver::metaEvent(byte type, byte *data, uint16 length) {
 	warning("Unhandled meta event %d len %d", event, length);
 }
 
-void AdLibMidiDriver::generateSamples(int16 *data, int len) {
-	memset(data, 0, sizeof(int16) * len);
-	YM3812UpdateOne(_opl, data, len);
+void AdLibMidiDriver::setTimerCallback(void *timerParam, Common::TimerManager::TimerProc timerProc) {
+	_adlibTimerProc = timerProc;
+	_adlibTimerParam = timerParam;
+}
+
+void AdLibMidiDriver::onTimer() {
+	if (_adlibTimerProc)
+		(*_adlibTimerProc)(_adlibTimerParam);
 }
 
 void AdLibMidiDriver::handleSequencerSpecificMetaEvent1(int channel, const uint8 *data) {
@@ -238,7 +159,7 @@ void AdLibMidiDriver::handleMidiEvent0x90_NoteOn(int channel, int param1, int pa
 }
 
 void AdLibMidiDriver::adlibWrite(uint8 port, uint8 value) {
-	OPLWriteReg(_opl, port, value);
+	_opl->writeReg(port, value);
 }
 
 void AdLibMidiDriver::adlibSetupCard() {
@@ -253,6 +174,7 @@ void AdLibMidiDriver::adlibSetupCard() {
 		_midiChannelsFreqTable[i] = 0;
 	}
 	memset(_adlibChannelsLevelKeyScalingTable, 127, 11);
+	memset(_adlibChannelsVolumeTable, 128, 11);
 	adlibSetupChannels(0);
 	adlibResetAmpVibratoRhythm(0, 0, 0);
 	adlibSetNoteMul(1);
@@ -448,6 +370,11 @@ void AdLibMidiDriver::adlibSetNoteVolume(int channel, int volume) {
 	}
 }
 
+void AdLibMidiDriver::adlibSetChannelVolume(int channel, uint8 volume) {
+	if (channel < (_adlibRhythmEnabled ? 11 : 9))
+		_adlibChannelsVolumeTable[channel] = volume;
+}
+
 void AdLibMidiDriver::adlibSetupChannelHelper(int channel) {
 	adlibSetAmpVibratoRhythm();
 	adlibSetCSMKeyboardSplit();
@@ -558,10 +485,6 @@ const uint8 AdLibMidiDriver::_adlibChannelsKeyScalingTable2[] = {
 	0, 3, 1, 4, 2, 5, 6, 9, 7, 10, 8, 11, 12, 15, 16, 255, 14, 255, 17, 255, 13, 255
 };
 
-const uint8 AdLibMidiDriver::_adlibChannelsVolumeTable[] = {
-	128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128
-};
-
 const uint8 AdLibMidiDriver::_adlibInitSequenceData1[] = {
 	1, 1, 3, 15, 5, 0, 1, 3, 15, 0, 0, 0, 1, 0
 };
@@ -617,8 +540,4 @@ const int16 AdLibMidiDriver::_midiNoteFreqTable[] = {
 	-363, -361, -359, -356, -354, -351, -349, -347, -344, -342, -339, -337
 };
 
-MidiDriver *C_Player_CreateAdLibMidiDriver(Audio::Mixer *mixer) {
-	return new AdLibMidiDriver(mixer);
-}
-
 } // End of namespace Queen
diff --git a/engines/queen/midiadlib.h b/engines/queen/midiadlib.h
new file mode 100644
index 0000000000..8692e51840
--- /dev/null
+++ b/engines/queen/midiadlib.h
@@ -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 "audio/fmopl.h"
+#include "audio/mididrv.h"
+
+namespace Queen {
+
+class AdLibMidiDriver : public MidiDriver {
+public:
+
+	AdLibMidiDriver() {
+		_adlibWaveformSelect = 0;
+		_isOpen = false;
+	}
+
+	~AdLibMidiDriver() {}
+
+	// MidiDriver
+	int open();
+	void close();
+	void send(uint32 b);
+	void metaEvent(byte type, byte *data, uint16 length);
+	MidiChannel *allocateChannel() { return 0; }
+	MidiChannel *getPercussionChannel() { return 0; }
+	void setTimerCallback(void *timerParam, Common::TimerManager::TimerProc timerProc);
+	bool isOpen() const { return _isOpen; }
+	uint32 getBaseTempo() { return 1000000 / OPL::OPL::kDefaultCallbackFrequency; }
+
+	void setVolume(uint32 volume);
+
+private:
+
+	void handleMidiEvent0x90_NoteOn(int channel, int param1, int param2);
+	void handleSequencerSpecificMetaEvent1(int channel, const uint8 *data);
+	void handleSequencerSpecificMetaEvent2(uint8 value);
+	void handleSequencerSpecificMetaEvent3(uint8 value);
+
+	void adlibWrite(uint8 port, uint8 value);
+	void adlibSetupCard();
+	void adlibSetupChannels(int fl);
+	void adlibResetAmpVibratoRhythm(int am, int vib, int kso);
+	void adlibResetChannels();
+	void adlibSetAmpVibratoRhythm();
+	void adlibSetCSMKeyboardSplit();
+	void adlibSetNoteMul(int mul);
+	void adlibSetWaveformSelect(int fl);
+	void adlibSetPitchBend(int channel, int range);
+	void adlibPlayNote(int channel);
+	uint8 adlibPlayNoteHelper(int channel, int note1, int note2, int oct);
+	void adlibTurnNoteOff(int channel);
+	void adlibTurnNoteOn(int channel, int note);
+	void adlibSetupChannelFromSequence(int channel, const uint8 *src, int fl);
+	void adlibSetupChannel(int channel, const uint16 *src, int fl);
+	void adlibSetNoteVolume(int channel, int volume);
+	void adlibSetChannelVolume(int channel, uint8 volume);
+	void adlibSetupChannelHelper(int channel);
+	void adlibSetChannel0x40(int channel);
+	void adlibSetChannel0xC0(int channel);
+	void adlibSetChannel0x60(int channel);
+	void adlibSetChannel0x80(int channel);
+	void adlibSetChannel0x20(int channel);
+	void adlibSetChannel0xE0(int channel);
+
+	void onTimer();
+
+	OPL::OPL *_opl;
+	int _midiNumberOfChannels;
+	int _adlibNoteMul;
+	int _adlibWaveformSelect;
+	int _adlibAMDepthEq48;
+	int _adlibVibratoDepthEq14;
+	int _adlibRhythmEnabled;
+	int _adlibKeyboardSplitOn;
+	int _adlibVibratoRhythm;
+	uint8 _midiChannelsFreqTable[9];
+	uint8 _adlibChannelsLevelKeyScalingTable[11];
+	uint8 _adlibSetupChannelSequence1[14 * 18];
+	uint16 _adlibSetupChannelSequence2[14];
+	int16 _midiChannelsNote2Table[9];
+	uint8 _midiChannelsNote1Table[9];
+	uint8 _midiChannelsOctTable[9];
+	uint16 _adlibChannelsVolume[11];
+	uint16 _adlibMetaSequenceData[28];
+	uint8 _adlibChannelsVolumeTable[11];
+
+	bool _isOpen;
+	Common::TimerManager::TimerProc _adlibTimerProc;
+	void *_adlibTimerParam;
+
+	static const uint8 _adlibChannelsMappingTable1[];
+	static const uint8 _adlibChannelsNoFeedback[];
+	static const uint8 _adlibChannelsMappingTable2[];
+	static const uint8 _adlibChannelsMappingTable3[];
+	static const uint8 _adlibChannelsKeyScalingTable1[];
+	static const uint8 _adlibChannelsKeyScalingTable2[];
+	static const uint8 _adlibInitSequenceData1[];
+	static const uint8 _adlibInitSequenceData2[];
+	static const uint8 _adlibInitSequenceData3[];
+	static const uint8 _adlibInitSequenceData4[];
+	static const uint8 _adlibInitSequenceData5[];
+	static const uint8 _adlibInitSequenceData6[];
+	static const uint8 _adlibInitSequenceData7[];
+	static const uint8 _adlibInitSequenceData8[];
+	static const int16 _midiChannelsNoteTable[];
+	static const int16 _midiNoteFreqTable[];
+};
+
+} // End of namespace Queen
diff --git a/engines/queen/music.cpp b/engines/queen/music.cpp
index 93d6527622..9f74aab915 100644
--- a/engines/queen/music.cpp
+++ b/engines/queen/music.cpp
@@ -23,6 +23,7 @@
 #include "common/config-manager.h"
 #include "common/events.h"
 
+#include "queen/midiadlib.h"
 #include "queen/music.h"
 #include "queen/queen.h"
 #include "queen/resource.h"
@@ -33,8 +34,6 @@
 
 namespace Queen {
 
-extern MidiDriver *C_Player_CreateAdLibMidiDriver(Audio::Mixer *);
-
 MidiMusic::MidiMusic(QueenEngine *vm)
 	: _isPlaying(false), _isLooping(false),
 	_randomLoop(false), _masterVolume(192),
@@ -69,7 +68,7 @@ MidiMusic::MidiMusic(QueenEngine *vm)
 //		if (READ_LE_UINT16(_musicData + 2) != infoOffset) {
 //			defaultAdLibVolume = _musicData[infoOffset];
 //		}
-		_driver = C_Player_CreateAdLibMidiDriver(vm->_mixer);
+		_driver = new AdLibMidiDriver();
 	} else {
 		_driver = MidiDriver::createMidi(dev);
 		if (_nativeMT32) {
@@ -117,6 +116,9 @@ void MidiMusic::setVolume(int volume) {
 		if (_channelsTable[i])
 			_channelsTable[i]->volume(_channelsVolume[i] * _masterVolume / 255);
 	}
+
+	if (_adlib)
+		static_cast<AdLibMidiDriver*>(_driver)->setVolume(volume);
 }
 
 void MidiMusic::playSong(uint16 songNum) {
diff --git a/engines/queen/walk.cpp b/engines/queen/walk.cpp
index dd7e46c765..17d12b0b9f 100644
--- a/engines/queen/walk.cpp
+++ b/engines/queen/walk.cpp
@@ -130,7 +130,7 @@ void Walk::animateJoe() {
 			_vm->logic()->joeScale(pbs->scale);
 			pbs->scaleWalkSpeed(6);
 			_vm->update(true);
-			if (_vm->input()->cutawayQuit() || _vm->logic()->joeWalk() == JWM_EXECUTE) {
+			if (_vm->input()->cutawayQuit() || _vm->logic()->joeWalk() == JWM_EXECUTE || _vm->shouldQuit()) {
 				stopJoe();
 				break;
 			}
@@ -249,7 +249,7 @@ void Walk::animatePerson(const MovePersonData *mpd, uint16 image, uint16 bobNum,
 			_vm->update();
 			pbs->scale = pwd->area->calcScale(pbs->y);
 			pbs->scaleWalkSpeed(mpd->moveSpeed);
-			if (_vm->input()->cutawayQuit()) {
+			if (_vm->input()->cutawayQuit() || _vm->shouldQuit()) {
 				stopPerson(bobNum);
 				break;
 			}
diff --git a/engines/saga/detection_tables.h b/engines/saga/detection_tables.h
index 2f72e7a13c..98009326ae 100644
--- a/engines/saga/detection_tables.h
+++ b/engines/saga/detection_tables.h
@@ -192,9 +192,9 @@ static const SAGAGameDescription gameDescriptions[] = {
 			ADGF_DEMO,
 			GUIO1(GUIO_NOSPEECH)
 		},
-		GID_ITE, // Game id
-		GF_OLD_ITE_DOS, // features
-		ITE_DEFAULT_SCENE, // Starting scene number
+		GID_ITE,
+		GF_ITE_DOS_DEMO,
+		ITE_DEFAULT_SCENE,
 		&ITEDemo_Resources,
 		ARRAYSIZE(ITEDEMO_GameFonts),
 		ITEDEMO_GameFonts,
@@ -393,6 +393,33 @@ static const SAGAGameDescription gameDescriptions[] = {
 		NULL,
 	},
 
+	// Inherit the earth - German Wyrmkeep combined Windows/Mac/Linux CD
+
+	// Supplied by user nicode in bug #6428.
+	// Contains voices.rsc instead of "Inherit the Earth Voices".
+	{
+		{
+			"ite",
+			"Multi-OS CD Version",
+			{
+	{"ite.rsc",						GAME_RESOURCEFILE,					"420e09cfdbb4db12baefd4bc81d8e154", 8925349},
+	{"scripts.rsc",					GAME_SCRIPTFILE,					"a891405405edefc69c9d6c420c868b84", -1},
+	{ NULL, 0, NULL, 0}
+			},
+			Common::DE_DEU,
+			Common::kPlatformUnknown,
+			ADGF_CD,
+			GUIO0()
+		},
+		GID_ITE,
+		0,
+		ITE_DEFAULT_SCENE,
+		&ITE_Resources,
+		ARRAYSIZE(ITE_GameFonts),
+		ITE_GameFonts,
+		NULL,
+	},
+
 	// Inherit the earth - Italian Wyrmkeep combined Windows/Mac/Linux CD (fan translation)
 
 	// version is different from the other Wyrmkeep re-releases in that it does
diff --git a/engines/saga/introproc_ihnm.cpp b/engines/saga/introproc_ihnm.cpp
index fc28d2372f..dc3f55e8c1 100644
--- a/engines/saga/introproc_ihnm.cpp
+++ b/engines/saga/introproc_ihnm.cpp
@@ -68,7 +68,7 @@ int Scene::IHNMStartProc() {
 				// Play the title music
 				_vm->_music->play(1, MUSIC_NORMAL);
 				// Play title screen
-				playTitle(2, 17);
+				playTitle(2, _vm->_music->isAdlib() ? 20 : 27);
 			}
 		}
 	} else {
@@ -150,7 +150,7 @@ bool Scene::checkKey() {
 			break;
 		case Common::EVENT_KEYDOWN:
 			// Don't react to modifier keys alone. The original did
-			// non, and the user may want to change scaler without
+			// not, and the user may want to change scaler without
 			// terminating the intro.
 			if (event.kbd.ascii)
 				res = true;
diff --git a/engines/saga/introproc_ite.cpp b/engines/saga/introproc_ite.cpp
index 0b129dbcc0..3c10cbe1dd 100644
--- a/engines/saga/introproc_ite.cpp
+++ b/engines/saga/introproc_ite.cpp
@@ -59,6 +59,11 @@ namespace Saga {
 #define RID_ITE_FAIREPATH_SCENE 1564
 #define RID_ITE_FAIRETENT_SCENE 1567
 
+// Intro scenes - DOS demo
+#define RID_ITE_INTRO_ANIM_SCENE_DOS_DEMO 298
+#define RID_ITE_CAVE_SCENE_DOS_DEMO 302
+#define RID_ITE_VALLEY_SCENE_DOS_DEMO 310
+
 // ITE intro music
 #define MUSIC_INTRO 9
 #define MUSIC_TITLE_THEME 10
@@ -75,22 +80,24 @@ LoadSceneParams ITE_IntroList[] = {
 	{RID_ITE_FAIRETENT_SCENE, kLoadByResourceId, Scene::SC_ITEIntroFaireTentProc, false, kTransitionNoFade, 0, NO_CHAPTER_CHANGE}
 };
 
-int Scene::ITEStartProc() {
-	size_t scenesCount;
-	size_t i;
+LoadSceneParams ITE_DOS_Demo_IntroList[] = {
+	{RID_ITE_INTRO_ANIM_SCENE_DOS_DEMO, kLoadByResourceId, Scene::SC_ITEIntroAnimProc, false, kTransitionNoFade, 0, NO_CHAPTER_CHANGE},
+	{RID_ITE_CAVE_SCENE_DOS_DEMO, kLoadByResourceId, Scene::SC_ITEIntroCaveDemoProc, false, kTransitionFade, 0, NO_CHAPTER_CHANGE},
+	{RID_ITE_VALLEY_SCENE_DOS_DEMO, kLoadByResourceId, Scene::SC_ITEIntroValleyProc, false, kTransitionFade, 0, NO_CHAPTER_CHANGE},
+};
 
+int Scene::ITEStartProc() {
 	LoadSceneParams firstScene;
 	LoadSceneParams tempScene;
+	bool dosDemo = (_vm->getFeatures() & GF_ITE_DOS_DEMO);
+	int scenesCount = (!dosDemo) ? ARRAYSIZE(ITE_IntroList) : ARRAYSIZE(ITE_DOS_Demo_IntroList);
 
-	scenesCount = ARRAYSIZE(ITE_IntroList);
-
-	for (i = 0; i < scenesCount; i++) {
-		tempScene = ITE_IntroList[i];
+	for (int i = 0; i < scenesCount; i++) {
+		tempScene = (!dosDemo) ? ITE_IntroList[i] : ITE_DOS_Demo_IntroList[i];
 		tempScene.sceneDescriptor = _vm->_resource->convertResourceId(tempScene.sceneDescriptor);
 		_vm->_scene->queueScene(tempScene);
 	}
 
-
 	firstScene.loadFlag = kLoadBySceneNumber;
 	firstScene.sceneDescriptor = _vm->getStartSceneNumber();
 	firstScene.sceneSkipTarget = true;
@@ -437,6 +444,53 @@ int Scene::ITEIntroCaveCommonProc(int param, int caveScene) {
 	return 0;
 }
 
+int Scene::ITEIntroCaveDemoProc(int param) {
+	Event event;
+	EventColumns *eventColumns = NULL;
+
+	switch (param) {
+	case SCENE_BEGIN:
+		// Begin palette cycling animation for candles
+		event.type = kEvTOneshot;
+		event.code = kPalAnimEvent;
+		event.op = kEventCycleStart;
+		event.time = 0;
+		eventColumns = _vm->_events->chain(eventColumns, event);
+
+		// Queue narrator dialogue list
+		for (int i = 0; i < 11; i++) {
+			// Play voice
+			event.type = kEvTOneshot;
+			event.code = kVoiceEvent;
+			event.op = kEventPlay;
+			event.param = i;
+			event.time = _vm->_sndRes->getVoiceLength(i);
+			_vm->_events->chain(eventColumns, event);
+		}
+
+		// End scene after last dialogue over
+		event.type = kEvTOneshot;
+		event.code = kSceneEvent;
+		event.op = kEventEnd;
+		event.time = INTRO_VOICE_PAD;
+		_vm->_events->chain(eventColumns, event);
+
+		break;
+	case SCENE_END:
+		break;
+
+	default:
+		warning("Illegal scene procedure parameter");
+		break;
+	}
+
+	return 0;
+}
+
+int Scene::SC_ITEIntroCaveDemoProc(int param, void *refCon) {
+	return ((Scene *)refCon)->ITEIntroCaveDemoProc(param);
+}
+
 // Handles first introductory cave painting scene
 int Scene::SC_ITEIntroCave1Proc(int param, void *refCon) {
 	return ((Scene *)refCon)->ITEIntroCaveCommonProc(param, 1);
diff --git a/engines/saga/music.cpp b/engines/saga/music.cpp
index d20882ca26..663f5991d0 100644
--- a/engines/saga/music.cpp
+++ b/engines/saga/music.cpp
@@ -31,6 +31,7 @@
 #include "audio/mididrv.h"
 #include "audio/midiparser.h"
 #include "audio/midiparser_qt.h"
+#include "audio/miles.h"
 #include "audio/decoders/raw.h"
 #include "common/config-manager.h"
 #include "common/file.h"
@@ -42,24 +43,51 @@ namespace Saga {
 #define MUSIC_SUNSPOT 26
 
 MusicDriver::MusicDriver() : _isGM(false) {
-
-	MidiPlayer::createDriver();
-
 	MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_GM);
 	_driverType = MidiDriver::getMusicType(dev);
 
+	switch (_driverType) {
+	case MT_ADLIB:
+		if (Common::File::exists("INSTR.AD") && Common::File::exists("INSTR.OPL")) {
+			_milesAudioMode = true;
+			_driver = Audio::MidiDriver_Miles_AdLib_create("INSTR.AD", "INSTR.OPL");
+		} else if (Common::File::exists("SAMPLE.AD") && Common::File::exists("SAMPLE.OPL")) {
+			_milesAudioMode = true;
+			_driver = Audio::MidiDriver_Miles_AdLib_create("SAMPLE.AD", "SAMPLE.OPL");
+		} else {
+			_milesAudioMode = false;
+			MidiPlayer::createDriver();
+		}
+		break;
+	case MT_MT32:
+		_milesAudioMode = true;
+		_driver = Audio::MidiDriver_Miles_MT32_create("");
+		break;
+	default:
+		_milesAudioMode = false;
+		MidiPlayer::createDriver();
+		break;
+	}
+
 	int retValue = _driver->open();
 	if (retValue == 0) {
-		if (_nativeMT32)
-			_driver->sendMT32Reset();
-		else
-			_driver->sendGMReset();
+		if (_driverType != MT_ADLIB) {
+			if (_driverType == MT_MT32 || _nativeMT32)
+				_driver->sendMT32Reset();
+			else
+				_driver->sendGMReset();
+		}
 
 		_driver->setTimerCallback(this, &timerCallback);
 	}
 }
 
 void MusicDriver::send(uint32 b) {
+	if (_milesAudioMode) {
+		_driver->send(b);
+		return;
+	}
+
 	if ((b & 0xF0) == 0xC0 && !_isGM && !_nativeMT32) {
 		// Remap MT32 instruments to General Midi
 		b = (b & 0xFFFF00FF) | MidiDriver::_mt32ToGm[(b >> 8) & 0xFF] << 8;
@@ -249,7 +277,11 @@ void Music::play(uint32 resourceId, MusicFlags flags) {
 
 	debug(2, "Music::play %d, %d", resourceId, flags);
 
-	if (isPlaying() && _trackNumber == resourceId) {
+	if (isPlaying() && _trackNumber == resourceId)
+		return;
+
+	if (_vm->getFeatures() & GF_ITE_DOS_DEMO) {
+		warning("TODO: Music::play %d, %d for ITE DOS demo", resourceId, flags);
 		return;
 	}
 
diff --git a/engines/saga/music.h b/engines/saga/music.h
index 2106fb6fa6..2e7cc4c5ec 100644
--- a/engines/saga/music.h
+++ b/engines/saga/music.h
@@ -61,6 +61,7 @@ public:
 protected:
 	MusicType _driverType;
 	bool _isGM;
+	bool _milesAudioMode;
 };
 
 class Music {
@@ -79,6 +80,8 @@ public:
 	void setVolume(int volume, int time = 1);
 	int getVolume() { return _currentVolume; }
 
+	bool isAdlib() const { return _player->isAdlib(); }
+
 	Common::Array<int32> _songTable;
 
 private:
diff --git a/engines/saga/saga.cpp b/engines/saga/saga.cpp
index 3d38b3ea52..b94bb66bb4 100644
--- a/engines/saga/saga.cpp
+++ b/engines/saga/saga.cpp
@@ -117,6 +117,9 @@ SagaEngine::SagaEngine(OSystem *syst, const SAGAGameDescription *gameDesc)
 	SearchMan.addSubDirectoryMatching(gameDataDir, "music");
 	SearchMan.addSubDirectoryMatching(gameDataDir, "sound");
 
+	// Location of Miles audio files (sample.ad and sample.opl) in IHNM
+	SearchMan.addSubDirectoryMatching(gameDataDir, "drivers");
+
 	// The Multi-OS version puts the voices file in the root directory of
 	// the CD. The rest of the data files are in game/itedata
 	SearchMan.addSubDirectoryMatching(gameDataDir, "game/itedata");
@@ -634,6 +637,9 @@ void SagaEngine::syncSoundSettings() {
 }
 
 void SagaEngine::pauseEngineIntern(bool pause) {
+	if (!_render || !_music)
+		return;
+
 	bool engineIsPaused = (_render->getFlags() & RF_RENDERPAUSE);
 	if (engineIsPaused == pause)
 		return;
diff --git a/engines/saga/saga.h b/engines/saga/saga.h
index 6077e55094..9c7b2f5295 100644
--- a/engines/saga/saga.h
+++ b/engines/saga/saga.h
@@ -137,9 +137,7 @@ enum GameFileTypes {
 
 enum GameFeatures {
 	GF_ITE_FLOPPY        = 1 << 0,
-#if 0
-	GF_OLD_ITE_DOS       = 1 << 1,     // Currently unused
-#endif
+	GF_ITE_DOS_DEMO      = 1 << 1,
 	GF_EXTRA_ITE_CREDITS = 1 << 2,
 	GF_8BIT_UNSIGNED_PCM = 1 << 3
 };
diff --git a/engines/saga/scene.cpp b/engines/saga/scene.cpp
index f19645dd99..efd4c371b1 100644
--- a/engines/saga/scene.cpp
+++ b/engines/saga/scene.cpp
@@ -835,13 +835,14 @@ void Scene::loadScene(LoadSceneParams &loadSceneParams) {
 		loadSceneParams.sceneProc(SCENE_BEGIN, this);
 	}
 
-	// We probably don't want "followers" to go into scene -1 , 0. At the very
-	// least we don't want garbage to be drawn that early in the ITE intro.
-	if (_sceneNumber > 0 && _sceneNumber != ITE_SCENE_PUZZLE)
-		_vm->_actor->updateActorsScene(loadSceneParams.actorsEntrance);
-
-	if (_sceneNumber == ITE_SCENE_PUZZLE)
+	if (_vm->getGameId() == GID_ITE && _sceneNumber == ITE_SCENE_PUZZLE) {
 		_vm->_puzzle->execute();
+	} else {
+		// We probably don't want "followers" to go into scene -1 , 0. At the very
+		// least we don't want garbage to be drawn that early in the ITE intro.
+		if (_sceneNumber > 0)
+			_vm->_actor->updateActorsScene(loadSceneParams.actorsEntrance);
+	}
 
 	if (getFlags() & kSceneFlagShowCursor) {
 		// Activate user interface
@@ -865,15 +866,13 @@ void Scene::loadSceneDescriptor(uint32 resourceId) {
 
 	_sceneDescription.reset();
 
-	if (resourceId == 0) {
+	if (resourceId == 0)
 		return;
-	}
 
 	_vm->_resource->loadResource(_sceneContext, resourceId, sceneDescriptorData);
+	ByteArrayReadStreamEndian readS(sceneDescriptorData, _sceneContext->isBigEndian());
 
-	if (sceneDescriptorData.size() == 16) {
-		ByteArrayReadStreamEndian readS(sceneDescriptorData, _sceneContext->isBigEndian());
-
+	if (sceneDescriptorData.size() == 14 || sceneDescriptorData.size() == 16) {
 		_sceneDescription.flags = readS.readSint16();
 		_sceneDescription.resourceListResourceId = readS.readSint16();
 		_sceneDescription.endSlope = readS.readSint16();
@@ -881,7 +880,10 @@ void Scene::loadSceneDescriptor(uint32 resourceId) {
 		_sceneDescription.scriptModuleNumber = readS.readUint16();
 		_sceneDescription.sceneScriptEntrypointNumber = readS.readUint16();
 		_sceneDescription.startScriptEntrypointNumber = readS.readUint16();
-		_sceneDescription.musicResourceId = readS.readSint16();
+		if (sceneDescriptorData.size() == 16)
+			_sceneDescription.musicResourceId = readS.readSint16();
+	} else {
+		warning("Scene::loadSceneDescriptor: Unknown scene descriptor data size (%d)", sceneDescriptorData.size());
 	}
 }
 
diff --git a/engines/saga/scene.h b/engines/saga/scene.h
index 410713c5d5..1a710cfe9c 100644
--- a/engines/saga/scene.h
+++ b/engines/saga/scene.h
@@ -400,12 +400,14 @@ class Scene {
 	static int SC_ITEIntroTreeHouseProc(int param, void *refCon);
 	static int SC_ITEIntroFairePathProc(int param, void *refCon);
 	static int SC_ITEIntroFaireTentProc(int param, void *refCon);
+	static int SC_ITEIntroCaveDemoProc(int param, void *refCon);
 
  private:
 	EventColumns *queueIntroDialogue(EventColumns *eventColumns, int n_dialogues, const IntroDialogue dialogue[]);
 	EventColumns *queueCredits(int delta_time, int duration, int n_credits, const IntroCredit credits[]);
 	int ITEIntroAnimProc(int param);
 	int ITEIntroCaveCommonProc(int param, int caveScene);
+	int ITEIntroCaveDemoProc(int param);
 	int ITEIntroValleyProc(int param);
 	int ITEIntroTreeHouseProc(int param);
 	int ITEIntroFairePathProc(int param);
diff --git a/engines/saga/script.cpp b/engines/saga/script.cpp
index 94b26c8da3..3cc6586432 100644
--- a/engines/saga/script.cpp
+++ b/engines/saga/script.cpp
@@ -977,19 +977,15 @@ void Script::opSpeak(SCRIPTOP_PARAMS) {
 
 	// now data contains last string index
 
-#if 0
-	if (_vm->getFeatures() & GF_OLD_ITE_DOS) { // special ITE dos
+	if (_vm->getFeatures() & GF_ITE_DOS_DEMO) {
 		if ((_vm->_scene->currentSceneNumber() == ITE_DEFAULT_SCENE) &&
 			(iparam1 >= 288) && (iparam1 <= (RID_SCENE1_VOICE_END - RID_SCENE1_VOICE_START + 288))) {
 			sampleResourceId = RID_SCENE1_VOICE_START + iparam1 - 288;
 		}
 	} else {
-#endif
 		if (thread->_voiceLUT->size() > uint16(first))
 			sampleResourceId = (*thread->_voiceLUT)[uint16(first)];
-#if 0
 	}
-#endif
 
 	if (sampleResourceId < 0 || sampleResourceId > 4000)
 		sampleResourceId = -1;
diff --git a/engines/saga/sndres.cpp b/engines/saga/sndres.cpp
index 39578e96f0..b8d03c9c08 100644
--- a/engines/saga/sndres.cpp
+++ b/engines/saga/sndres.cpp
@@ -327,9 +327,18 @@ bool SndRes::load(ResourceContext *context, uint32 resourceId, SoundBuffer &buff
 		result = true;
 		} break;
 	case kSoundAIFF: {
-		Audio::SeekableAudioStream *audStream = Audio::makeAIFFStream(READ_STREAM(soundResourceLength), DisposeAfterUse::YES);
-		buffer.stream = audStream;
-		buffer.streamLength = audStream->getLength();
+		Audio::RewindableAudioStream *audStream = Audio::makeAIFFStream(READ_STREAM(soundResourceLength), DisposeAfterUse::YES);
+		Audio::SeekableAudioStream *seekStream = dynamic_cast<Audio::SeekableAudioStream *>(audStream);
+
+		if (!seekStream) {
+			warning("AIFF file is not seekable");
+			delete audStream;
+			result = false;
+			break;
+		}
+
+		buffer.stream = seekStream;
+		buffer.streamLength = seekStream->getLength();
 		result = true;
 		} break;
 	case kSoundVOC: {
diff --git a/engines/sci/console.cpp b/engines/sci/console.cpp
index e233c4cba4..1e95393e4d 100644
--- a/engines/sci/console.cpp
+++ b/engines/sci/console.cpp
@@ -209,6 +209,11 @@ Console::Console(SciEngine *engine) : GUI::Debugger(),
 	registerCmd("bpe",				WRAP_METHOD(Console, cmdBreakpointFunction));		// alias
 	// VM
 	registerCmd("script_steps",		WRAP_METHOD(Console, cmdScriptSteps));
+	registerCmd("script_objects",   WRAP_METHOD(Console, cmdScriptObjects));
+	registerCmd("scro",             WRAP_METHOD(Console, cmdScriptObjects));
+	registerCmd("script_strings",   WRAP_METHOD(Console, cmdScriptStrings));
+	registerCmd("scrs",             WRAP_METHOD(Console, cmdScriptStrings));
+	registerCmd("script_said",      WRAP_METHOD(Console, cmdScriptSaid));
 	registerCmd("vm_varlist",			WRAP_METHOD(Console, cmdVMVarlist));
 	registerCmd("vmvarlist",			WRAP_METHOD(Console, cmdVMVarlist));				// alias
 	registerCmd("vl",					WRAP_METHOD(Console, cmdVMVarlist));				// alias
@@ -660,10 +665,33 @@ bool Console::cmdRegisters(int argc, const char **argv) {
 	return true;
 }
 
+bool Console::parseResourceNumber36(const char *userParameter, uint16 &resourceNumber, uint32 &resourceTuple) {
+	int userParameterLen = strlen(userParameter);
+	
+	if (userParameterLen != 10) {
+		debugPrintf("Audio36/Sync36 resource numbers must be specified as RRRNNVVCCS\n");
+		debugPrintf("where RRR is the resource number/map\n");
+		debugPrintf("      NN is the noun\n");
+		debugPrintf("      VV is the verb\n");
+		debugPrintf("      CC is the cond\n");
+		debugPrintf("      S  is the seq\n");
+		return false;
+	}
+
+	// input: RRRNNVVCCS
+	resourceNumber = strtol(Common::String(userParameter, 3).c_str(), 0, 36);
+	uint16 noun = strtol(Common::String(userParameter + 3, 2).c_str(), 0, 36);
+	uint16 verb = strtol(Common::String(userParameter + 5, 2).c_str(), 0, 36);
+	uint16 cond = strtol(Common::String(userParameter + 7, 2).c_str(), 0, 36);
+	uint16 seq = strtol(Common::String(userParameter + 9, 1).c_str(), 0, 36);
+	resourceTuple = ((noun & 0xff) << 24) | ((verb & 0xff) << 16) | ((cond & 0xff) << 8) | (seq & 0xff);
+	return true;
+}
+
 bool Console::cmdDiskDump(int argc, const char **argv) {
-	int resNumFrom = 0;
-	int resNumTo = 0;
-	int resNumCur = 0;
+	bool resourceAll = false;
+	uint16 resourceNumber = 0;
+	uint32 resourceTuple = 0;
 
 	if (argc != 3) {
 		debugPrintf("Dumps the specified resource to disk as a patch file\n");
@@ -673,42 +701,90 @@ bool Console::cmdDiskDump(int argc, const char **argv) {
 		return true;
 	}
 
+	ResourceType resourceType = parseResourceType(argv[1]);
+	if (resourceType == kResourceTypeInvalid) {
+		debugPrintf("Resource type '%s' is not valid\n", argv[1]);
+		return true;
+	}
+
 	if (strcmp(argv[2], "*") == 0) {
-		resNumFrom = 0;
-		resNumTo   = 65535;
+		resourceAll = true;
 	} else {
-		resNumFrom = atoi(argv[2]);
-		resNumTo   = resNumFrom;
+		switch (resourceType) {
+		case kResourceTypeAudio36:
+		case kResourceTypeSync36:
+			if (!parseResourceNumber36(argv[2], resourceNumber, resourceTuple)) {
+				return true;
+			}
+			break;
+		default:
+			resourceNumber = atoi(argv[2]);
+			break;
+		}
 	}
 
-	ResourceType res = parseResourceType(argv[1]);
-
-	if (res == kResourceTypeInvalid)
+	if (resourceType == kResourceTypeInvalid) {
 		debugPrintf("Resource type '%s' is not valid\n", argv[1]);
-	else {
-		for (resNumCur = resNumFrom; resNumCur <= resNumTo; resNumCur++) {
-			Resource *resource = _engine->getResMan()->findResource(ResourceId(res, resNumCur), 0);
-			if (resource) {
-				char outFileName[50];
-				sprintf(outFileName, "%s.%03d", getResourceTypeName(res), resNumCur);
-				Common::DumpFile *outFile = new Common::DumpFile();
-				outFile->open(outFileName);
-				resource->writeToStream(outFile);
-				outFile->finalize();
-				outFile->close();
-				delete outFile;
-				debugPrintf("Resource %s.%03d (located in %s) has been dumped to disk\n", argv[1], resNumCur, resource->getResourceLocation().c_str());
-			} else {
-				if (resNumFrom == resNumTo) {
-					debugPrintf("Resource %s.%03d not found\n", argv[1], resNumCur);
-				}
-			}
+		return true;
+	}
+
+	if (resourceAll) {
+		// "*" used, dump everything of that type
+		Common::List<ResourceId> resources = _engine->getResMan()->listResources(resourceType, -1);
+		Common::sort(resources.begin(), resources.end());
+
+		Common::List<ResourceId>::iterator itr;
+		for (itr = resources.begin(); itr != resources.end(); ++itr) {
+			resourceNumber = itr->getNumber();
+			resourceTuple = itr->getTuple();
+			cmdDiskDumpWorker(resourceType, resourceNumber, resourceTuple);
 		}
+	} else {
+		// id was given, dump only this resource
+		cmdDiskDumpWorker(resourceType, resourceNumber, resourceTuple);
 	}
 
 	return true;
 }
 
+void Console::cmdDiskDumpWorker(ResourceType resourceType, int resourceNumber, uint32 resourceTuple) {
+	const char *resourceTypeName = getResourceTypeName(resourceType);
+	ResourceId resourceId;
+	Resource *resource = NULL;
+	char outFileName[50];
+	
+	switch (resourceType) {
+	case kResourceTypeAudio36:
+	case kResourceTypeSync36: {
+		resourceId = ResourceId(resourceType, resourceNumber, resourceTuple);
+		resource = _engine->getResMan()->findResource(resourceId, 0);
+		sprintf(outFileName, "%s", resourceId.toPatchNameBase36().c_str());
+		// patch filename is: [type:1 char] [map:3 chars] [noun:2 chars] [verb:2 chars] "." [cond: 2 chars] [seq:1 char]
+		//  e.g. "@5EG0000.014"
+		break;
+	}
+	default:
+		resourceId = ResourceId(resourceType, resourceNumber);
+		resource = _engine->getResMan()->findResource(resourceId, 0);
+		sprintf(outFileName, "%s.%03d", resourceTypeName, resourceNumber);
+		// patch filename is: [resourcetype].[resourcenumber]
+		//  e.g. "Script.0"
+		break;
+	}
+
+	if (resource) {
+		Common::DumpFile *outFile = new Common::DumpFile();
+		outFile->open(outFileName);
+		resource->writeToStream(outFile);
+		outFile->finalize();
+		outFile->close();
+		delete outFile;
+		debugPrintf("Resource %s (located in %s) has been dumped to disk\n", outFileName, resource->getResourceLocation().c_str());
+	} else {
+		debugPrintf("Resource %s not found\n", outFileName);
+	}
+}
+
 bool Console::cmdHexDump(int argc, const char **argv) {
 	if (argc != 3) {
 		debugPrintf("Dumps the specified resource to standard output\n");
@@ -748,6 +824,77 @@ bool Console::cmdResourceId(int argc, const char **argv) {
 	return true;
 }
 
+bool Console::cmdList(int argc, const char **argv) {
+	int selectedMapNumber = -1;
+	Common::List<ResourceId> resources;
+	Common::List<ResourceId>::iterator itr;
+	int displayCount = 0;
+	int currentMap = -1;
+
+	if (argc < 2) {
+		debugPrintf("Lists all the resources of a given type\n");
+		cmdResourceTypes(argc, argv);
+		return true;
+	}
+
+	ResourceType resourceType = parseResourceType(argv[1]);
+	if (resourceType == kResourceTypeInvalid) {
+		debugPrintf("Unknown resource type: '%s'\n", argv[1]);
+		return true;
+	}
+
+	switch (resourceType) {
+	case kResourceTypeAudio36:
+	case kResourceTypeSync36:
+		if (argc != 3) {
+			debugPrintf("Please specify map number (-1: all maps)\n");
+			return true;
+		}
+		selectedMapNumber = atoi(argv[2]);
+		resources = _engine->getResMan()->listResources(resourceType, selectedMapNumber);
+		Common::sort(resources.begin(), resources.end());
+
+		for (itr = resources.begin(); itr != resources.end(); ++itr) {
+			const uint16 map = itr->getNumber();
+			const uint32 resourceTuple = itr->getTuple();
+			const uint16 noun = (resourceTuple >> 24) & 0xff;
+			const uint16 verb = (resourceTuple >> 16) & 0xff;
+			const uint16 cond = (resourceTuple >> 8) & 0xff;
+			const uint16 seq = resourceTuple & 0xff;
+
+			if (currentMap != map) {
+				if (displayCount % 3)
+					debugPrintf("\n");
+				debugPrintf("Map %04x (%i):\n", map, map);
+				currentMap = map;
+				displayCount = 0;
+			}
+			
+			if (displayCount % 3 == 0)
+				debugPrintf("  ");
+
+			debugPrintf("%02x %02x %02x %02x (%3i %3i %3i %3i)    ", noun, verb, cond, seq, noun, verb, cond, seq);
+
+			if (++displayCount % 3 == 0)
+				debugPrintf("\n");
+		}
+		break;
+	default:
+		resources = _engine->getResMan()->listResources(resourceType);
+		Common::sort(resources.begin(), resources.end());
+
+		for (itr = resources.begin(); itr != resources.end(); ++itr) {
+			debugPrintf("%8i", itr->getNumber());
+			if (++displayCount % 10 == 0)
+				debugPrintf("\n");
+		}
+		break;
+	}
+
+	debugPrintf("\n");
+	return true;
+}
+
 bool Console::cmdDissectScript(int argc, const char **argv) {
 	if (argc != 2) {
 		debugPrintf("Examines a script\n");
@@ -1124,52 +1271,6 @@ bool Console::cmdMapInstrument(int argc, const char **argv) {
 	return true;
 }
 
-bool Console::cmdList(int argc, const char **argv) {
-	if (argc < 2) {
-		debugPrintf("Lists all the resources of a given type\n");
-		cmdResourceTypes(argc, argv);
-		return true;
-	}
-
-
-	ResourceType res = parseResourceType(argv[1]);
-	if (res == kResourceTypeInvalid)
-		debugPrintf("Unknown resource type: '%s'\n", argv[1]);
-	else {
-		int number = -1;
-
-		if ((res == kResourceTypeAudio36) || (res == kResourceTypeSync36)) {
-			if (argc != 3) {
-				debugPrintf("Please specify map number (-1: all maps)\n");
-				return true;
-			}
-			number = atoi(argv[2]);
-		}
-
-		Common::List<ResourceId> resources = _engine->getResMan()->listResources(res, number);
-		Common::sort(resources.begin(), resources.end());
-
-		int cnt = 0;
-		Common::List<ResourceId>::iterator itr;
-		for (itr = resources.begin(); itr != resources.end(); ++itr) {
-			if (number == -1) {
-				debugPrintf("%8i", itr->getNumber());
-				if (++cnt % 10 == 0)
-					debugPrintf("\n");
-			} else if (number == (int)itr->getNumber()) {
-				const uint32 tuple = itr->getTuple();
-				debugPrintf("(%3i, %3i, %3i, %3i)   ", (tuple >> 24) & 0xff, (tuple >> 16) & 0xff,
-							(tuple >> 8) & 0xff, tuple & 0xff);
-				if (++cnt % 4 == 0)
-					debugPrintf("\n");
-			}
-		}
-		debugPrintf("\n");
-	}
-
-	return true;
-}
-
 bool Console::cmdSaveGame(int argc, const char **argv) {
 	if (argc != 2) {
 		debugPrintf("Saves the current game state to the hard disk\n");
@@ -2172,6 +2273,7 @@ bool Console::cmdStartSound(int argc, const char **argv) {
 		return true;
 	}
 
+	// TODO: Maybe also add a playBed option.
 	g_sci->_soundCmd->startNewSound(number);
 	return cmdExit(0, 0);
 }
@@ -2198,9 +2300,10 @@ bool Console::cmdToggleSound(int argc, const char **argv) {
 	Common::String newState = argv[2];
 	newState.toLowercase();
 
-	if (newState == "play")
-		g_sci->_soundCmd->processPlaySound(id);
-	else if (newState == "stop")
+	if (newState == "play") {
+		// Maybe also have a 'playbed' option. (Second argument to processPlaySound.)
+		g_sci->_soundCmd->processPlaySound(id, false);
+	} else if (newState == "stop")
 		g_sci->_soundCmd->processStopSound(id, false);
 	else
 		debugPrintf("New state can either be 'play' or 'stop'");
@@ -2730,6 +2833,186 @@ bool Console::cmdScriptSteps(int argc, const char **argv) {
 	return true;
 }
 
+bool Console::cmdScriptObjects(int argc, const char **argv) {
+	int curScriptNr = -1;
+
+	if (argc < 2) {
+		debugPrintf("Shows all objects inside a specified script.\n");
+		debugPrintf("Usage: %s <script number>\n", argv[0]);
+		debugPrintf("Example: %s 999\n", argv[0]);
+		debugPrintf("<script number> may be * to show objects inside all loaded scripts\n");
+		return true;
+	}
+	
+	if (strcmp(argv[1], "*") == 0) {
+		// get said-strings of all currently loaded scripts
+		curScriptNr = -1;
+	} else {
+		curScriptNr = atoi(argv[1]);
+	}
+
+	printOffsets(curScriptNr, SCI_SCR_OFFSET_TYPE_OBJECT);
+	return true;
+}
+
+bool Console::cmdScriptStrings(int argc, const char **argv) {
+	int curScriptNr = -1;
+
+	if (argc < 2) {
+		debugPrintf("Shows all strings inside a specified script.\n");
+		debugPrintf("Usage: %s <script number>\n", argv[0]);
+		debugPrintf("Example: %s 999\n", argv[0]);
+		debugPrintf("<script number> may be * to show strings inside all loaded scripts\n");
+		return true;
+	}
+	
+	if (strcmp(argv[1], "*") == 0) {
+		// get strings of all currently loaded scripts
+		curScriptNr = -1;
+	} else {
+		curScriptNr = atoi(argv[1]);
+	}
+
+	printOffsets(curScriptNr, SCI_SCR_OFFSET_TYPE_STRING);
+	return true;
+}
+
+bool Console::cmdScriptSaid(int argc, const char **argv) {
+	int curScriptNr = -1;
+
+	if (argc < 2) {
+		debugPrintf("Shows all said-strings inside a specified script.\n");
+		debugPrintf("Usage: %s <script number>\n", argv[0]);
+		debugPrintf("Example: %s 999\n", argv[0]);
+		debugPrintf("<script number> may be * to show said-strings inside all loaded scripts\n");
+		return true;
+	}
+	
+	if (strcmp(argv[1], "*") == 0) {
+		// get said-strings of all currently loaded scripts
+		curScriptNr = -1;
+	} else {
+		curScriptNr = atoi(argv[1]);
+	}
+
+	printOffsets(curScriptNr, SCI_SCR_OFFSET_TYPE_SAID);
+	return true;
+}
+
+void Console::printOffsets(int scriptNr, uint16 showType) {
+	SegManager *segMan = _engine->_gamestate->_segMan;
+	Vocabulary *vocab = _engine->_vocabulary;
+	SegmentId curSegmentNr;
+	Common::List<SegmentId> segmentNrList;
+
+	SegmentType curSegmentType = SEG_TYPE_INVALID;
+	SegmentObj *curSegmentObj = NULL;
+	Script *curScriptObj = NULL;
+	const byte *curScriptData = NULL;
+
+	segmentNrList.clear();
+	if (scriptNr < 0) {
+		// get offsets of all currently loaded scripts
+		for (curSegmentNr = 0; curSegmentNr < segMan->_heap.size(); curSegmentNr++) {
+			curSegmentObj = segMan->_heap[curSegmentNr];
+			if (curSegmentObj && curSegmentObj->getType() == SEG_TYPE_SCRIPT) {
+				segmentNrList.push_back(curSegmentNr);
+			}
+		}
+
+	} else {
+		curSegmentNr = segMan->getScriptSegment(scriptNr);
+		if (!curSegmentNr) {
+			debugPrintf("Script %d is currently not loaded/available\n", scriptNr);
+			return;
+		}
+		segmentNrList.push_back(curSegmentNr);
+	}
+
+	const offsetLookupArrayType *scriptOffsetLookupArray;
+	offsetLookupArrayType::const_iterator arrayIterator;
+	int showTypeCount = 0;
+
+	reg_t objectPos;
+	const char *objectNamePtr = NULL;
+	const byte *stringPtr = NULL;
+	const byte *saidPtr = NULL;
+
+	Common::List<SegmentId>::iterator it;
+	const Common::List<SegmentId>::iterator end = segmentNrList.end();
+
+	for (it = segmentNrList.begin(); it != end; it++) {
+		curSegmentNr = *it;
+		// get object of this segment
+		curSegmentObj = segMan->getSegmentObj(curSegmentNr);
+		if (!curSegmentObj)
+			continue;
+
+		curSegmentType = curSegmentObj->getType();
+		if (curSegmentType != SEG_TYPE_SCRIPT) // safety check
+			continue;
+
+		curScriptObj = (Script *)curSegmentObj;
+		debugPrintf("=== SCRIPT %d inside Segment %d ===\n", curScriptObj->getScriptNumber(), curSegmentNr);
+		debugN("=== SCRIPT %d inside Segment %d ===\n", curScriptObj->getScriptNumber(), curSegmentNr);
+
+		// now print the list
+		scriptOffsetLookupArray = curScriptObj->getOffsetArray();
+		curScriptData = curScriptObj->getBuf();
+		showTypeCount = 0;
+
+		for (arrayIterator = scriptOffsetLookupArray->begin(); arrayIterator != scriptOffsetLookupArray->end(); arrayIterator++) {
+			if (arrayIterator->type == showType) {
+				switch (showType) {
+				case SCI_SCR_OFFSET_TYPE_OBJECT:
+					objectPos = make_reg(curSegmentNr, arrayIterator->offset);
+					objectNamePtr = segMan->getObjectName(objectPos);
+					debugPrintf(" %03d:%04x: %s\n", arrayIterator->id, arrayIterator->offset, objectNamePtr);
+					debugN(" %03d:%04x: %s\n", arrayIterator->id, arrayIterator->offset, objectNamePtr);
+					break;
+				case SCI_SCR_OFFSET_TYPE_STRING:
+					stringPtr = curScriptData + arrayIterator->offset;
+					debugPrintf(" %03d:%04x: '%s' (size %d)\n", arrayIterator->id, arrayIterator->offset, stringPtr, arrayIterator->stringSize);
+					debugN(" %03d:%04x: '%s' (size %d)\n", arrayIterator->id, arrayIterator->offset, stringPtr, arrayIterator->stringSize);
+					break;
+				case SCI_SCR_OFFSET_TYPE_SAID:
+					saidPtr = curScriptData + arrayIterator->offset;
+					debugPrintf(" %03d:%04x:\n", arrayIterator->id, arrayIterator->offset);
+					debugN(" %03d:%04x: ", arrayIterator->id, arrayIterator->offset);
+					vocab->debugDecipherSaidBlock(saidPtr);
+					debugN("\n");
+					break;
+				default:
+					break;
+				}
+				showTypeCount++;
+			}
+		}
+
+		if (showTypeCount == 0) {
+			switch (showType) {
+			case SCI_SCR_OFFSET_TYPE_OBJECT:
+				debugPrintf(" no objects\n");
+				debugN(" no objects\n");
+				break;
+			case SCI_SCR_OFFSET_TYPE_STRING:
+				debugPrintf(" no strings\n");
+				debugN(" no strings\n");
+				break;
+			case SCI_SCR_OFFSET_TYPE_SAID:
+				debugPrintf(" no said-strings\n");
+				debugN(" no said-strings\n");
+				break;
+			default:
+				break;
+			}
+		}
+
+		debugPrintf("\n");
+		debugN("\n");
+	}
+}
+
 bool Console::cmdBacktrace(int argc, const char **argv) {
 	debugPrintf("Call stack (current base: 0x%x):\n", _engine->_gamestate->executionStackBase);
 	Common::List<ExecStack>::const_iterator iter;
@@ -3209,6 +3492,7 @@ bool Console::cmdSend(int argc, const char **argv) {
 		// We call run_engine explictly so we can restore the value of r_acc
 		// after execution.
 		run_vm(_engine->_gamestate);
+		_engine->_gamestate->xs = old_xstack;
 
 	}
 
diff --git a/engines/sci/console.h b/engines/sci/console.h
index c8e99f78f7..8b10912fbe 100644
--- a/engines/sci/console.h
+++ b/engines/sci/console.h
@@ -68,6 +68,7 @@ private:
 	bool cmdSaid(int argc, const char **argv);
 	// Resources
 	bool cmdDiskDump(int argc, const char **argv);
+	void cmdDiskDumpWorker(ResourceType resourceType, int resourceNumber, uint32 resourceTuple);
 	bool cmdHexDump(int argc, const char **argv);
 	bool cmdResourceId(int argc, const char **argv);
 	bool cmdResourceInfo(int argc, const char **argv);
@@ -146,6 +147,9 @@ private:
 	bool cmdBreakpointFunction(int argc, const char **argv);
 	// VM
 	bool cmdScriptSteps(int argc, const char **argv);
+	bool cmdScriptObjects(int argc, const char **argv);
+	bool cmdScriptStrings(int argc, const char **argv);
+	bool cmdScriptSaid(int argc, const char **argv);
 	bool cmdVMVarlist(int argc, const char **argv);
 	bool cmdVMVars(int argc, const char **argv);
 	bool cmdStack(int argc, const char **argv);
@@ -157,6 +161,7 @@ private:
 	bool cmdViewAccumulatorObject(int argc, const char **argv);
 
 	bool parseInteger(const char *argument, int &result);
+	bool parseResourceNumber36(const char *userParameter, uint16 &resourceNumber, uint32 &resourceTuple);
 
 	void printBasicVarInfo(reg_t variable);
 
@@ -164,6 +169,7 @@ private:
 	void printList(List *list);
 	int printNode(reg_t addr);
 	void hexDumpReg(const reg_t *data, int len, int regsPerLine = 4, int startOffset = 0, bool isArray = false);
+	void printOffsets(int scriptNr, uint16 showType);
 
 private:
 	/**
diff --git a/engines/sci/detection.cpp b/engines/sci/detection.cpp
index 85ff1c0062..bac9b3467a 100644
--- a/engines/sci/detection.cpp
+++ b/engines/sci/detection.cpp
@@ -371,8 +371,8 @@ static const ADExtraGuiOptionsMap optionsList[] = {
 	{
 		GAMEOPTION_EGA_UNDITHER,
 		{
-			_s("EGA undithering"),
-			_s("Enable undithering in EGA games"),
+			_s("Skip EGA dithering pass (full color backgrounds)"),
+			_s("Skip dithering pass in EGA games, graphics are shown with full colors"),
 			"disable_dithering",
 			false
 		}
@@ -791,22 +791,9 @@ void SciMetaEngine::removeSaveState(const char *target, int slot) const {
 }
 
 Common::Error SciEngine::loadGameState(int slot) {
-	Common::String fileName = Common::String::format("%s.%03d", _targetName.c_str(), slot);
-	Common::SaveFileManager *saveFileMan = g_engine->getSaveFileManager();
-	Common::SeekableReadStream *in = saveFileMan->openForLoading(fileName);
-
-	if (in) {
-		// found a savegame file
-		gamestate_restore(_gamestate, in);
-		delete in;
-	}
-
-	if (_gamestate->r_acc != make_reg(0, 1)) {
-		return Common::kNoError;
-	} else {
-		warning("Restoring gamestate '%s' failed", fileName.c_str());
-		return Common::kUnknownError;
-	}
+	_gamestate->_delayedRestoreGameId = slot;
+	_gamestate->_delayedRestoreGame = true;
+	return Common::kNoError;
 }
 
 Common::Error SciEngine::saveGameState(int slot, const Common::String &desc) {
@@ -834,16 +821,12 @@ Common::Error SciEngine::saveGameState(int slot, const Common::String &desc) {
 	return Common::kNoError;
 }
 
-// Before enabling the load option in the ScummVM menu, the main game loop must
-// have run at least once. When the game loop runs, kGameIsRestarting is invoked,
-// thus the speed throttler is initialized. Hopefully fixes bug #3565505.
-
 bool SciEngine::canLoadGameStateCurrently() {
-	return !_gamestate->executionStackBase && (_gamestate->_throttleLastTime > 0 || _gamestate->_throttleTrigger);
+	return !_gamestate->executionStackBase;
 }
 
 bool SciEngine::canSaveGameStateCurrently() {
-	return !_gamestate->executionStackBase && (_gamestate->_throttleLastTime > 0 || _gamestate->_throttleTrigger);
+	return !_gamestate->executionStackBase;
 }
 
 } // End of namespace Sci
diff --git a/engines/sci/detection_tables.h b/engines/sci/detection_tables.h
index 32d1a58765..4482375d19 100644
--- a/engines/sci/detection_tables.h
+++ b/engines/sci/detection_tables.h
@@ -904,16 +904,14 @@ static const struct ADGameDescription SciGameDescriptions[] = {
 		AD_LISTEND},
 		Common::EN_ANY, Common::kPlatformDOS, 0, GUIO5(GUIO_NOSPEECH, GAMEOPTION_EGA_UNDITHER, GAMEOPTION_PREFER_DIGITAL_SFX, GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_FB01_MIDI)	},
 
-#if 0 // TODO: unknown if these files are corrupt
-	// Hoyle 1 - English Amiga (from www.back2roots.org)
-	// SCI interpreter version 0.000.519 - FIXME: some have 0.000.530, others x.yyy.zzz
+	// Hoyle 1 - English Amiga (from www.back2roots.org - verified by waltervn in bug report #6870)
+	// Game version 1.000.139, SCI interpreter version x.yyy.zzz
 	{"hoyle1", "", {
 		{"resource.map", 0, "2a72b1aba65fa6e339370eb86d8601d1", 5166},
 		{"resource.001", 0, "e0dd44069a62a463fd124974b915f10d", 218755},
 		{"resource.002", 0, "e0dd44069a62a463fd124974b915f10d", 439502},
 		AD_LISTEND},
 		Common::EN_ANY, Common::kPlatformAmiga, 0, GUIO4(GUIO_NOSPEECH, GAMEOPTION_PREFER_DIGITAL_SFX, GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_FB01_MIDI)	},
-#endif
 
 	// Hoyle 2 - English DOS
 	// SCI interpreter version 0.000.572
@@ -1552,6 +1550,17 @@ static const struct ADGameDescription SciGameDescriptions[] = {
 		AD_LISTEND},
 		Common::EN_ANY, Common::kPlatformDOS, ADGF_DEMO, GUIO4(GUIO_NOSPEECH, GAMEOPTION_PREFER_DIGITAL_SFX, GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_FB01_MIDI)	},
 
+	// King's Quest 6 - English DOS Playable CD "Sneak Peaks" Demo (first island fully playable)
+	//  (supplied by KQ5 G5 in bug report #6824)
+	// Executable scanning reports "1.cfs.158 Not a release version", VERSION file reports "1.000.000"
+	// SCI interpreter version ???
+	{"kq6", "Demo/CD", {
+		{"resource.000", 0, "233394a5f33b475ae5975e7e9a420865", 8345598},
+		{"resource.map", 0, "eb9e177281b7cde188dc0d83194cd365", 8960},
+		{"resource.msg", 0, "3cf5de44de36191f109d425b8450efc8", 259510},
+		AD_LISTEND},
+		Common::EN_ANY, Common::kPlatformDOS, ADGF_CD | ADGF_DEMO, GUIO4(GUIO_NOSPEECH, GAMEOPTION_PREFER_DIGITAL_SFX, GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_FB01_MIDI)	},
+
 	// King's Quest 6 - English DOS Floppy
 	// SCI interpreter version 1.001.054
 	{"kq6", "", {
@@ -2436,6 +2445,16 @@ static const struct ADGameDescription SciGameDescriptions[] = {
 		AD_LISTEND},
 		Common::EN_ANY, Common::kPlatformDOS, ADGF_UNSTABLE, GUIO5(GUIO_NOSPEECH, GUIO_NOASPECT, GAMEOPTION_PREFER_DIGITAL_SFX, GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_FB01_MIDI)	},
 
+	// Lighthouse - Japanese DOS (from m_kiewitz)
+	// Executable scanning reports "3.000.000", VERSION file reports "1.0C"
+	{"lighthouse", "", {
+		{"resmap.001", 0, "18e0ac1597fe1cf6dc663118fe983e3b", 7885},
+		{"ressci.001", 0, "14e922c47b92156377cb49e241691792", 99573473},
+		{"resmap.002", 0, "723fc742c623d8933e5753a264324cb0", 7657},
+		{"ressci.002", 0, "175468431a979b9f317c294ce3bc1430", 94627469},
+		AD_LISTEND},
+		Common::JA_JPN, Common::kPlatformDOS, ADGF_UNSTABLE, GUIO5(GUIO_NOSPEECH, GUIO_NOASPECT, GAMEOPTION_PREFER_DIGITAL_SFX, GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_FB01_MIDI)	},
+
 	// Lighthouse - Spanish DOS (from jvprat)
 	// Executable scanning reports "3.000.000", VERSION file reports "1.1"
 	{"lighthouse", "", {
@@ -4108,6 +4127,15 @@ static const struct ADGameDescription SciGameDescriptions[] = {
 		AD_LISTEND},
 		Common::FR_FRA, Common::kPlatformWindows, ADGF_UNSTABLE, GUIO4(GUIO_NOASPECT, GAMEOPTION_PREFER_DIGITAL_SFX, GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_FB01_MIDI)	},
 
+	// Torin's Passage - German Windows CD (from m_kiewitz)
+	// SCI interpreter version 2.100.002
+	// VERSION file "1.0"
+	{"torin", "", {
+		{"resmap.000", 0, "e55c3097329b3c53752301e01c6af2fb", 9787},
+		{"ressci.000", 0, "118f9bec04bfe17c4f87bbb5ddb43c18", 56127540},
+		AD_LISTEND},
+		Common::DE_DEU, Common::kPlatformWindows, ADGF_UNSTABLE, GUIO4(GUIO_NOASPECT, GAMEOPTION_PREFER_DIGITAL_SFX, GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_FB01_MIDI)	},
+
 	// Torin's Passage (Multilingual) - German Windows CD
 	// SCI interpreter version 2.100.002
 	{"torin", "", {
@@ -4166,7 +4194,7 @@ static const struct ADGameDescription SciGameDescriptions[] = {
 	FANMADE_L("Grostesteing: Plus Mechant que Jamais", "ec9a97ccb134f69249f6ea8b16c13d8e", 1500, "b869f5f11bfe2ab5f67f4f0c618f2ce1", 464657, Common::FR_FRA), // FIXME: Accent
 	FANMADE("Humanoid Demo", "97d8331293a6d57e8bad58c1efc89a63", 624, "fb354b9abe64011b12159e45d724633f", 452320),
 	FANMADE("Island of Secrets Demo 0.3", "61279176c3e4530fec9b578877aecda7", 504, "7f4ed7a81b86bea22c62bc98e6d9ec39", 197790),
-	FANMADE("Jim’s Quest 1: The Phantom Thesis", "0af50be1d3f0cb77a09137709a76ef4f", 960, "9c042c136548b20d9183495668e03526", 496446),
+	FANMADE("Jim's Quest 1: The Phantom Thesis", "0af50be1d3f0cb77a09137709a76ef4f", 960, "9c042c136548b20d9183495668e03526", 496446),
 	FANMADE("King's Quest II SCI Pre-Alpha Version", "cdea1c081022e7697a1afffb1d2f9f6a", 2646, "fb2ce39002c3e05f3d83533638dea105", 2310356),
 	FANMADE("Knight's Quest Demo 1.0", "5e816edf993956752ed06fccfeeae6d9", 1260, "959321f88a22905fa1f8c6d897874744", 703836),
 	FANMADE("LockerGnome Quest", "3eeff9130206cad0c4e1551e2b9dd2c5", 420, "ae05ca90806fd90cc43f147c82d3547c", 158906),
diff --git a/engines/sci/engine/file.cpp b/engines/sci/engine/file.cpp
index 2ba7d15ac0..623caec856 100644
--- a/engines/sci/engine/file.cpp
+++ b/engines/sci/engine/file.cpp
@@ -252,6 +252,9 @@ void DirSeeker::addAsVirtualFiles(Common::String title, Common::String fileMask)
 	Common::SaveFileManager *saveFileMan = g_sci->getSaveFileManager();
 	Common::StringArray foundFiles = saveFileMan->listSavefiles(fileMask);
 	if (!foundFiles.empty()) {
+		// Sort all filenames alphabetically
+		Common::sort(foundFiles.begin(), foundFiles.end());
+
 		_files.push_back(title);
 		_virtualFiles.push_back("");
 		Common::StringArray::iterator it;
diff --git a/engines/sci/engine/kernel.cpp b/engines/sci/engine/kernel.cpp
index 2b16bb3d99..bfb7bfcd08 100644
--- a/engines/sci/engine/kernel.cpp
+++ b/engines/sci/engine/kernel.cpp
@@ -432,57 +432,66 @@ static const SignatureDebugType signatureDebugTypeList[] = {
 	{ 0,                      NULL }
 };
 
-static void kernelSignatureDebugType(const uint16 type) {
+static void kernelSignatureDebugType(Common::String &signatureDetailsStr, const uint16 type) {
 	bool firstPrint = true;
 
 	const SignatureDebugType *list = signatureDebugTypeList;
 	while (list->typeCheck) {
 		if (type & list->typeCheck) {
 			if (!firstPrint)
-				debugN(", ");
-			debugN("%s", list->text);
+//				debugN(", ");
+				signatureDetailsStr += ", ";
+//			debugN("%s", list->text);
+//			signatureDetailsStr += signatureDetailsStr.format("%s", list->text);
+			signatureDetailsStr += list->text;
 			firstPrint = false;
 		}
 		list++;
 	}
 }
 
-// Shows kernel call signature and current arguments for debugging purposes
-void Kernel::signatureDebug(const uint16 *sig, int argc, const reg_t *argv) {
+// Create string, that holds the details of a kernel call signature and current arguments
+//  For debugging purposes
+void Kernel::signatureDebug(Common::String &signatureDetailsStr, const uint16 *sig, int argc, const reg_t *argv) {
 	int argnr = 0;
+
+	// add ERROR: to debug output
+	debugN("ERROR:");
+
 	while (*sig || argc) {
-		debugN("parameter %d: ", argnr++);
+		// add leading spaces for additional parameters
+		signatureDetailsStr += signatureDetailsStr.format("parameter %d: ", argnr++);
 		if (argc) {
 			reg_t parameter = *argv;
-			debugN("%04x:%04x (", PRINT_REG(parameter));
+			signatureDetailsStr += signatureDetailsStr.format("%04x:%04x (", PRINT_REG(parameter));
 			int regType = findRegType(parameter);
 			if (regType)
-				kernelSignatureDebugType(regType);
+				kernelSignatureDebugType(signatureDetailsStr, regType);
 			else
-				debugN("unknown type of %04x:%04x", PRINT_REG(parameter));
-			debugN(")");
+				signatureDetailsStr += signatureDetailsStr.format("unknown type of %04x:%04x", PRINT_REG(parameter));
+			signatureDetailsStr += ")";
 			argv++;
 			argc--;
 		} else {
-			debugN("not passed");
+			signatureDetailsStr += "not passed";
 		}
 		if (*sig) {
 			const uint16 signature = *sig;
 			if ((signature & SIG_MAYBE_ANY) == SIG_MAYBE_ANY) {
-				debugN(", may be any");
+				signatureDetailsStr += ", may be any";
 			} else {
-				debugN(", should be ");
-				kernelSignatureDebugType(signature);
+				signatureDetailsStr += ", should be ";
+				kernelSignatureDebugType(signatureDetailsStr, signature);
 			}
 			if (signature & SIG_IS_OPTIONAL)
-				debugN(" (optional)");
+				signatureDetailsStr += " (optional)";
 			if (signature & SIG_NEEDS_MORE)
-				debugN(" (needs more)");
+				signatureDetailsStr += " (needs more)";
 			if (signature & SIG_MORE_MAY_FOLLOW)
-				debugN(" (more may follow)");
+				signatureDetailsStr += " (more may follow)";
 			sig++;
 		}
-		debugN("\n");
+		signatureDetailsStr += "\n";
 	}
 }
 
diff --git a/engines/sci/engine/kernel.h b/engines/sci/engine/kernel.h
index a65bcb7df5..57b4d9455b 100644
--- a/engines/sci/engine/kernel.h
+++ b/engines/sci/engine/kernel.h
@@ -186,7 +186,7 @@ public:
 	bool signatureMatch(const uint16 *sig, int argc, const reg_t *argv);
 
 	// Prints out debug information in case a signature check fails
-	void signatureDebug(const uint16 *sig, int argc, const reg_t *argv);
+	void signatureDebug(Common::String &signatureDetails, const uint16 *sig, int argc, const reg_t *argv);
 
 	/**
 	 * Determines the type of the object indicated by reg.
diff --git a/engines/sci/engine/kernel_tables.h b/engines/sci/engine/kernel_tables.h
index 0c2fd4e3ea..2cbd79366d 100644
--- a/engines/sci/engine/kernel_tables.h
+++ b/engines/sci/engine/kernel_tables.h
@@ -105,10 +105,6 @@ static const SciKernelMapSubEntry kDoSound_subops[] = {
 	{ SIG_SOUNDSCI1EARLY,  5, MAP_CALL(DoSoundInit),               NULL,                   NULL },
 	{ SIG_SOUNDSCI1EARLY,  6, MAP_CALL(DoSoundDispose),            NULL,                   NULL },
 	{ SIG_SOUNDSCI1EARLY,  7, MAP_CALL(DoSoundPlay),               "oi",                   NULL },
-	// ^^ TODO: In SCI1-SCI1.1 DoSound (play) is called by 2 methods of the Sound object: play and
-	//  playBed. The methods are the same, apart from the second integer parameter: it's 0 in
-	//  play and 1 in playBed, to distinguish the caller. It's passed on, we should find out what
-	//  it actually does internally
 	{ SIG_SOUNDSCI1EARLY,  8, MAP_CALL(DoSoundStop),               NULL,                   NULL },
 	{ SIG_SOUNDSCI1EARLY,  9, MAP_CALL(DoSoundPause),              "[o0]i",                NULL },
 	{ SIG_SOUNDSCI1EARLY, 10, MAP_CALL(DoSoundFade),               "oiiii",                kDoSoundFade_workarounds },
diff --git a/engines/sci/engine/kevent.cpp b/engines/sci/engine/kevent.cpp
index cb81da2279..8e16e0a07a 100644
--- a/engines/sci/engine/kevent.cpp
+++ b/engines/sci/engine/kevent.cpp
@@ -24,9 +24,10 @@
 
 #include "sci/sci.h"
 #include "sci/engine/features.h"
-#include "sci/engine/state.h"
-#include "sci/engine/selector.h"
 #include "sci/engine/kernel.h"
+#include "sci/engine/savegame.h"
+#include "sci/engine/selector.h"
+#include "sci/engine/state.h"
 #include "sci/console.h"
 #include "sci/debug.h"	// for g_debug_simulated_key
 #include "sci/event.h"
@@ -71,9 +72,15 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
 		g_debug_simulated_key = 0;
 		return make_reg(0, 1);
 	}
-
+	
 	curEvent = g_sci->getEventManager()->getSciEvent(mask);
 
+	if (s->_delayedRestoreGame) {
+		// delayed restore game from ScummVM menu got triggered
+		gamestate_delayedrestore(s);
+		return NULL_REG;
+	}
+
 	// For a real event we use its associated mouse position
 	mousePos = curEvent.mousePos;
 #ifdef ENABLE_SCI32
diff --git a/engines/sci/engine/kfile.cpp b/engines/sci/engine/kfile.cpp
index c56eb09482..61ac76d0a7 100644
--- a/engines/sci/engine/kfile.cpp
+++ b/engines/sci/engine/kfile.cpp
@@ -933,6 +933,11 @@ reg_t kRestoreGame(EngineState *s, int argc, reg_t *argv) {
 				g_sci->_gfxMenu->kernelSetAttribute(1025 >> 8, 1025 & 0xFF, SCI_MENU_ATTRIBUTE_ENABLED, TRUE_REG);  // Status -> Statistics
 				g_sci->_gfxMenu->kernelSetAttribute(1026 >> 8, 1026 & 0xFF, SCI_MENU_ATTRIBUTE_ENABLED, TRUE_REG);  // Status -> Goals
 				break;
+			case GID_PQ2:
+				// HACK: Same as above - enable the save game menu option when loading in PQ2 (bug #6875).
+				// It gets disabled in the game's death screen.
+				g_sci->_gfxMenu->kernelSetAttribute(2, 1, SCI_MENU_ATTRIBUTE_ENABLED, TRUE_REG);	// Game -> Save Game
+				break;
 			default:
 				break;
 			}
diff --git a/engines/sci/engine/kgraphics.cpp b/engines/sci/engine/kgraphics.cpp
index ee2249bd9d..8b790e6a58 100644
--- a/engines/sci/engine/kgraphics.cpp
+++ b/engines/sci/engine/kgraphics.cpp
@@ -32,6 +32,7 @@
 #include "sci/event.h"
 #include "sci/resource.h"
 #include "sci/engine/features.h"
+#include "sci/engine/savegame.h"
 #include "sci/engine/state.h"
 #include "sci/engine/selector.h"
 #include "sci/engine/kernel.h"
@@ -400,6 +401,12 @@ reg_t kWait(EngineState *s, int argc, reg_t *argv) {
 
 	s->wait(sleep_time);
 
+	if (s->_delayedRestoreGame) {
+		// delayed restore game from ScummVM menu got triggered
+		gamestate_delayedrestore(s);
+		return NULL_REG;
+	}
+
 	return s->r_acc;
 }
 
@@ -955,8 +962,9 @@ reg_t kDrawControl(EngineState *s, int argc, reg_t *argv) {
 		reg_t textReference = readSelector(s->_segMan, controlObject, SELECTOR(text));
 		if (!textReference.isNull()) {
 			Common::String text = s->_segMan->getString(textReference);
-			if ((text == "a:hq1_hero.sav") || (text == "a:glory1.sav") || (text == "a:glory2.sav") || (text == "a:glory3.sav")) {
+			if ((text == "a:hq1_hero.sav") || (text == "a:glory1.sav") || (text == "a:glory2.sav") || (text == "a:glory3.sav") || (text == "a:gloire3.sauv")) {
 				// Remove "a:" from hero quest / quest for glory export default filenames
+				// The french version of Quest For Glory 3 uses "gloire3.sauv". It seems a translator translated the filename.
 				text.deleteChar(0);
 				text.deleteChar(0);
 				s->_segMan->strcpy(textReference, text.c_str());
diff --git a/engines/sci/engine/kmovement.cpp b/engines/sci/engine/kmovement.cpp
index 51d49eea9f..9b83dbc52d 100644
--- a/engines/sci/engine/kmovement.cpp
+++ b/engines/sci/engine/kmovement.cpp
@@ -305,12 +305,23 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
 		for (uint i = 0; i < clientVarNum; ++i)
 			clientBackup[i] = clientObject->getVariable(i);
 
-		if (mover_xAxis) {
-			if (ABS(mover_x - client_x) < ABS(mover_dx))
-				completed = true;
+		if ((getSciVersion() <= SCI_VERSION_1_EGA_ONLY)) {
+			if (mover_xAxis) {
+				if (ABS(mover_x - client_x) < ABS(mover_dx))
+					completed = true;
+			} else {
+				if (ABS(mover_y - client_y) < ABS(mover_dy))
+					completed = true;
+			}
 		} else {
-			if (ABS(mover_y - client_y) < ABS(mover_dy))
-				completed = true;
+			// SCI1EARLY+ code
+			if (mover_xAxis) {
+				if (ABS(mover_x - client_x) <= ABS(mover_dx))
+					completed = true;
+			} else {
+				if (ABS(mover_y - client_y) <= ABS(mover_dy))
+					completed = true;
+			}
 		}
 		if (completed) {
 			client_x = mover_x;
@@ -336,10 +347,10 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
 		bool collision = false;
 		reg_t cantBeHere = NULL_REG;
 
+		// adding this here for hoyle 3 to get happy. CantBeHere is a dummy in hoyle 3 and acc is != 0 so we would
+		//  get a collision otherwise. Resetting the result was always done in SSCI
+		s->r_acc = NULL_REG;
 		if (SELECTOR(cantBeHere) != -1) {
-			// adding this here for hoyle 3 to get happy. CantBeHere is a dummy in hoyle 3 and acc is != 0 so we would
-			//  get a collision otherwise
-			s->r_acc = NULL_REG;
 			invokeSelector(s, client, SELECTOR(cantBeHere), argc, argv);
 			if (!s->r_acc.isNull())
 				collision = true;
diff --git a/engines/sci/engine/kparse.cpp b/engines/sci/engine/kparse.cpp
index aa89b963cc..f85f33e3e8 100644
--- a/engines/sci/engine/kparse.cpp
+++ b/engines/sci/engine/kparse.cpp
@@ -117,6 +117,8 @@ reg_t kParse(EngineState *s, int argc, reg_t *argv) {
 		}
 #endif
 
+		voc->replacePronouns(words);
+
 		int syntax_fail = voc->parseGNF(words);
 
 		if (syntax_fail) {
@@ -130,6 +132,7 @@ reg_t kParse(EngineState *s, int argc, reg_t *argv) {
 
 		} else {
 			voc->parserIsValid = true;
+			voc->storePronounReference();
 			writeSelectorValue(segMan, event, SELECTOR(claimed), 0);
 
 #ifdef DEBUG_PARSER
diff --git a/engines/sci/engine/kvideo.cpp b/engines/sci/engine/kvideo.cpp
index 319469cb08..f925111fc9 100644
--- a/engines/sci/engine/kvideo.cpp
+++ b/engines/sci/engine/kvideo.cpp
@@ -123,6 +123,8 @@ void playVideo(Video::VideoDecoder *videoDecoder, VideoState videoState) {
 			if ((event.type == Common::EVENT_KEYDOWN && event.kbd.keycode == Common::KEYCODE_ESCAPE) || event.type == Common::EVENT_LBUTTONUP)
 				skipVideo = true;
 		}
+		if (g_sci->getEngineState()->_delayedRestoreGame)
+			skipVideo = true;
 
 		g_system->delayMillis(10);
 	}
diff --git a/engines/sci/engine/savegame.cpp b/engines/sci/engine/savegame.cpp
index 0b55425406..93b3a997cc 100644
--- a/engines/sci/engine/savegame.cpp
+++ b/engines/sci/engine/savegame.cpp
@@ -20,6 +20,7 @@
  *
  */
 
+#include "common/savefile.h"
 #include "common/stream.h"
 #include "common/system.h"
 #include "common/func.h"
@@ -40,6 +41,7 @@
 #include "sci/graphics/helpers.h"
 #include "sci/graphics/palette.h"
 #include "sci/graphics/ports.h"
+#include "sci/graphics/screen.h"
 #include "sci/parser/vocabulary.h"
 #include "sci/sound/audio.h"
 #include "sci/sound/music.h"
@@ -132,13 +134,6 @@ void SegManager::saveLoadWithSerializer(Common::Serializer &s) {
 
 		// Reset _scriptSegMap, to be restored below
 		_scriptSegMap.clear();
-
-#ifdef ENABLE_SCI32
-		// Clear any planes/screen items currently showing so they
-		// don't show up after the load.
-		if (getSciVersion() >= SCI_VERSION_2)
-			g_sci->_gfxFrameout->clear();
-#endif
 	}
 
 	s.skip(4, VER(14), VER(18));		// OBSOLETE: Used to be _exportsAreWide
@@ -617,6 +612,14 @@ void MusicEntry::saveLoadWithSerializer(Common::Serializer &s) {
 	s.syncAsSint32LE(fadeTicker);
 	s.syncAsSint32LE(fadeTickerStep);
 	s.syncAsByte(status);
+	if (s.getVersion() >= 32)
+		s.syncAsByte(playBed);
+	else if (s.isLoading())
+		playBed = false;
+	if (s.getVersion() >= 33)
+		s.syncAsByte(overridePriority);
+	else if (s.isLoading())
+		overridePriority = false;
 
 	// pMidiParser and pStreamAud will be initialized when the
 	// sound list is reconstructed in gamestate_restore()
@@ -635,8 +638,12 @@ void SoundCommandParser::syncPlayList(Common::Serializer &s) {
 void SoundCommandParser::reconstructPlayList() {
 	Common::StackLock lock(_music->_mutex);
 
-	const MusicList::iterator end = _music->getPlayListEnd();
-	for (MusicList::iterator i = _music->getPlayListStart(); i != end; ++i) {
+	// We store all songs here because starting songs may re-shuffle their order
+	MusicList songs;
+	for (MusicList::iterator i = _music->getPlayListStart(); i != _music->getPlayListEnd(); ++i)
+		songs.push_back(*i);
+
+	for (MusicList::iterator i = songs.begin(); i != songs.end(); ++i) {
 		initSoundResource(*i);
 
 		if ((*i)->status == kSoundPlaying) {
@@ -650,7 +657,7 @@ void SoundCommandParser::reconstructPlayList() {
 			if (_soundVersion >= SCI_VERSION_1_EARLY)
 				writeSelectorValue(_segMan, (*i)->soundObj, SELECTOR(vol), (*i)->volume);
 
-			processPlaySound((*i)->soundObj);
+			processPlaySound((*i)->soundObj, (*i)->playBed);
 		}
 	}
 }
@@ -715,9 +722,7 @@ void GfxPalette::saveLoadWithSerializer(Common::Serializer &s) {
 }
 
 void GfxPorts::saveLoadWithSerializer(Common::Serializer &s) {
-	if (s.isLoading())
-		reset();	// remove all script generated windows
-
+	// reset() is called directly way earlier in gamestate_restore()
 	if (s.getVersion() >= 27) {
 		uint windowCount = 0;
 		uint id = PORTS_FIRSTSCRIPTWINDOWID;
@@ -760,10 +765,17 @@ void GfxPorts::saveLoadWithSerializer(Common::Serializer &s) {
 				if (window->counterTillFree) {
 					_freeCounter++;
 				} else {
-					if (window->wndStyle & SCI_WINDOWMGR_STYLE_TOPMOST)
-						_windowList.push_front(window);
-					else
-						_windowList.push_back(window);
+					// we don't put the saved script windows into _windowList[], so that they aren't used
+					//  by kernel functions. This is important and would cause issues otherwise.
+					//  see Conquests of Camelot - bug #6744 - when saving on the map screen (room 103),
+					//                                restoring would result in a black window in place
+					//                                where the area name was displayed before
+					//                                In Sierra's SCI the behaviour is identical to us
+					//                                 Sierra's SCI won't show those windows after restoring
+					// If this should cause issues in another game, we would have to add a flag to simply
+					//  avoid any drawing operations for such windows
+					// We still have to restore script windows, because for example Conquests of Camelot
+					//  will immediately delete windows, that were created before saving the game.
 				}
 
 				windowCount--;
@@ -853,6 +865,22 @@ bool gamestate_save(EngineState *s, Common::WriteStream *fh, const Common::Strin
 
 extern void showScummVMDialog(const Common::String &message);
 
+void gamestate_delayedrestore(EngineState *s) {
+	Common::String fileName = g_sci->getSavegameName(s->_delayedRestoreGameId);
+	Common::SeekableReadStream *in = g_sci->getSaveFileManager()->openForLoading(fileName);
+
+	if (in) {
+		// found a savegame file
+		gamestate_restore(s, in);
+		delete in;
+		if (s->r_acc != make_reg(0, 1)) {
+			return;
+		}
+	}
+
+	error("Restoring gamestate '%s' failed", fileName.c_str());
+}
+
 void gamestate_restore(EngineState *s, Common::SeekableReadStream *fh) {
 	SavegameMetadata meta;
 
@@ -889,6 +917,20 @@ void gamestate_restore(EngineState *s, Common::SeekableReadStream *fh) {
 	// We don't need the thumbnail here, so just read it and discard it
 	Graphics::skipThumbnail(*fh);
 
+	// reset ports is one of the first things we do, because that may free() some hunk memory
+	//  and we don't want to do that after we read in the saved game hunk memory
+	if (g_sci->_gfxPorts)
+		g_sci->_gfxPorts->reset();
+	// clear screen
+	if (g_sci->_gfxScreen)
+		g_sci->_gfxScreen->clearForRestoreGame();
+#ifdef ENABLE_SCI32
+	// Also clear any SCI32 planes/screen items currently showing so they
+	// don't show up after the load.
+	if (getSciVersion() >= SCI_VERSION_2)
+		g_sci->_gfxFrameout->clear();
+#endif
+
 	s->reset(true);
 	s->saveLoadWithSerializer(ser);	// FIXME: Error handling?
 
diff --git a/engines/sci/engine/savegame.h b/engines/sci/engine/savegame.h
index 8f2835654b..5512b90fa8 100644
--- a/engines/sci/engine/savegame.h
+++ b/engines/sci/engine/savegame.h
@@ -37,6 +37,8 @@ struct EngineState;
  *
  * Version - new/changed feature
  * =============================
+ *      33 - new overridePriority flag in MusicEntry
+ *      32 - new playBed flag in MusicEntry
  *      31 - priority for sound effects/music is now a signed int16, instead of a byte
  *      30 - synonyms
  *      29 - system strings
@@ -56,7 +58,7 @@ struct EngineState;
  */
 
 enum {
-	CURRENT_SAVEGAME_VERSION = 31,
+	CURRENT_SAVEGAME_VERSION = 33,
 	MINIMUM_SAVEGAME_VERSION = 14
 };
 
@@ -72,7 +74,6 @@ struct SavegameMetadata {
 	uint16 script0Size;
 };
 
-
 /**
  * Saves a game state to the hard disk in a portable way.
  * @param s			The state to save
@@ -82,6 +83,9 @@ struct SavegameMetadata {
  */
 bool gamestate_save(EngineState *s, Common::WriteStream *save, const Common::String &savename, const Common::String &version);
 
+// does a delayed saved game restore, used by ScummVM game menu - see detection.cpp / SciEngine::loadGameState()
+void gamestate_delayedrestore(EngineState *s);
+
 /**
  * Restores a game state from a directory.
  * @param s			An older state from the same game
diff --git a/engines/sci/engine/script.cpp b/engines/sci/engine/script.cpp
index 2fe1aba975..36e33ccfa6 100644
--- a/engines/sci/engine/script.cpp
+++ b/engines/sci/engine/script.cpp
@@ -20,6 +20,7 @@
  *
  */
 
+#include "sci/console.h"
 #include "sci/sci.h"
 #include "sci/resource.h"
 #include "sci/util.h"
@@ -64,6 +65,11 @@ void Script::freeScript() {
 	_lockers = 1;
 	_markedAsDeleted = false;
 	_objects.clear();
+
+	_offsetLookupArray.clear();
+	_offsetLookupObjectCount = 0;
+	_offsetLookupStringCount = 0;
+	_offsetLookupSaidCount = 0;
 }
 
 void Script::load(int script_nr, ResourceManager *resMan, ScriptPatcher *scriptPatcher) {
@@ -115,8 +121,8 @@ void Script::load(int script_nr, ResourceManager *resMan, ScriptPatcher *scriptP
 		//
 		// TODO: Remove this once such a mechanism is in place
 		if (script->size > 65535)
-			error("TODO: SCI script %d is over 64KB - it's %d bytes long. This can't "
-			      "be handled at the moment, thus stopping", script_nr, script->size);
+			warning("TODO: SCI script %d is over 64KB - it's %d bytes long. This can't "
+			      "be fully handled at the moment", script_nr, script->size);
 	}
 
 	uint extraLocalsWorkaround = 0;
@@ -136,9 +142,6 @@ void Script::load(int script_nr, ResourceManager *resMan, ScriptPatcher *scriptP
 	assert(_bufSize >= script->size);
 	memcpy(_buf, script->data, script->size);
 
-	// Check scripts for matching signatures and patch those, if found
-	scriptPatcher->processScript(_nr, _buf, script->size);
-
 	if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1) {
 		Resource *heap = resMan->findResource(ResourceId(kResourceTypeHeap, _nr), 0);
 		assert(heap != 0);
@@ -149,6 +152,9 @@ void Script::load(int script_nr, ResourceManager *resMan, ScriptPatcher *scriptP
 		memcpy(_heapStart, heap->data, heap->size);
 	}
 
+	// Check scripts (+ possibly SCI 1.1 heap) for matching signatures and patch those, if found
+	scriptPatcher->processScript(_nr, _buf, _bufSize);
+
 	if (getSciVersion() <= SCI_VERSION_1_LATE) {
 		_exportTable = (const uint16 *)findBlockSCI0(SCI_OBJ_EXPORTS);
 		if (_exportTable) {
@@ -204,6 +210,397 @@ void Script::load(int script_nr, ResourceManager *resMan, ScriptPatcher *scriptP
 			//_localsCount = (_bufSize - _localsOffset) >> 1;
 		}
 	}
+
+	// find all strings of this script
+	identifyOffsets();
+}
+
+void Script::identifyOffsets() {
+	offsetLookupArrayEntry arrayEntry;
+	const byte *scriptDataPtr  = NULL;
+	const byte *stringStartPtr = NULL;
+	const byte *stringDataPtr  = NULL;
+	uint32 scriptDataLeft   = 0;
+	uint32 stringDataLeft   = 0;
+	byte stringDataByte  = 0;
+	uint16 typeObject_id = 0;
+	uint16 typeString_id = 0;
+	uint16 typeSaid_id   = 0;
+
+	uint16 blockType = 0;
+	uint16 blockSize = 0;
+
+	_offsetLookupArray.clear();
+	_offsetLookupObjectCount = 0;
+	_offsetLookupStringCount = 0;
+	_offsetLookupSaidCount = 0;
+
+	if (getSciVersion() < SCI_VERSION_1_1) {
+		// SCI0 + SCI1
+		scriptDataPtr  = _buf;
+		scriptDataLeft = _bufSize;
+
+		// Go through all blocks
+		if (getSciVersion() == SCI_VERSION_0_EARLY) {
+			if (scriptDataLeft < 2)
+				error("Script::identifyOffsets(): unexpected end of script %d", _nr);
+			scriptDataPtr  += 2;
+			scriptDataLeft -= 2;
+		}
+
+		do {
+			if (scriptDataLeft < 2)
+				error("Script::identifyOffsets(): unexpected end of script %d", _nr);
+
+			blockType = READ_LE_UINT16(scriptDataPtr);
+			scriptDataPtr  += 2;
+			scriptDataLeft -= 2;
+			if (blockType == 0) // end of blocks detected
+				break;
+
+			if (scriptDataLeft < 2)
+				error("Script::identifyOffsets(): unexpected end of script %d", _nr);
+
+			blockSize = READ_LE_UINT16(scriptDataPtr);
+			if (blockSize < 4)
+				error("Script::identifyOffsets(): invalid block size in script %d", _nr);
+			blockSize      -= 4; // block size includes block-type UINT16 and block-size UINT16
+			scriptDataPtr  += 2;
+			scriptDataLeft -= 2;
+
+			if (scriptDataLeft < blockSize)
+				error("Script::identifyOffsets(): invalid block size in script %d", _nr);
+
+			switch (blockType) {
+			case SCI_OBJ_OBJECT:
+			case SCI_OBJ_CLASS:
+				typeObject_id++;
+				arrayEntry.type       = SCI_SCR_OFFSET_TYPE_OBJECT;
+				arrayEntry.id         = typeObject_id;
+				arrayEntry.offset     = scriptDataPtr - _buf + 8; // Calculate offset inside script data (VM uses +8)
+				arrayEntry.stringSize = 0;
+				_offsetLookupArray.push_back(arrayEntry);
+				_offsetLookupObjectCount++;
+				break;
+
+			case SCI_OBJ_STRINGS:
+				// string block detected, we now grab all NUL terminated strings out of this block
+				stringDataPtr  = scriptDataPtr;
+				stringDataLeft = blockSize;
+
+				arrayEntry.type       = SCI_SCR_OFFSET_TYPE_STRING;
+
+				do {
+					if (stringDataLeft < 1) // no more bytes left
+						break;
+
+					stringStartPtr = stringDataPtr;
+
+					if (stringDataLeft == 1) {
+						// only 1 byte left and that byte is a [00], in that case we also exit
+						stringDataByte = *stringStartPtr;
+						if (stringDataByte == 0x00)
+							break;
+					}
+
+					// now look for terminating [NUL]
+					do {
+						stringDataByte = *stringDataPtr;
+						stringDataPtr++;
+						stringDataLeft--;
+						if (!stringDataByte) // NUL found, exit this loop
+							break;
+						if (stringDataLeft < 1) {
+							// no more bytes left
+							warning("Script::identifyOffsets(): string without terminating NUL in script %d", _nr);
+							break;
+						}
+					} while (1);
+
+					if (stringDataByte)
+						break;
+
+					typeString_id++;
+					arrayEntry.id         = typeString_id;
+					arrayEntry.offset     = stringStartPtr - _buf; // Calculate offset inside script data
+					arrayEntry.stringSize = stringDataPtr - stringStartPtr;
+					_offsetLookupArray.push_back(arrayEntry);
+					_offsetLookupStringCount++;
+				} while (1);
+				break;
+
+			case SCI_OBJ_SAID:
+				// said block detected, we now try to find every single said "string" inside this block
+				// said strings are terminated with a 0xFF, the string itself may contain words (2 bytes), where
+				//  the second byte of a word may also be a 0xFF.
+				stringDataPtr  = scriptDataPtr;
+				stringDataLeft = blockSize;
+
+				arrayEntry.type       = SCI_SCR_OFFSET_TYPE_SAID;
+
+				do {
+					if (stringDataLeft < 1) // no more bytes left
+						break;
+
+					stringStartPtr = stringDataPtr;
+					if (stringDataLeft == 1) {
+						// only 1 byte left and that byte is a [00], in that case we also exit
+						// happens in some scripts, for example Conquests of Camelot, script 997
+						// may have been a bug in the compiler or just an intentional filler byte
+						stringDataByte = *stringStartPtr;
+						if (stringDataByte == 0x00)
+							break;
+					}
+
+					// now look for terminating 0xFF
+					do {
+						stringDataByte = *stringDataPtr;
+						stringDataPtr++;
+						stringDataLeft--;
+						if (stringDataByte == 0xFF) // Terminator found, exit this loop
+							break;
+						if (stringDataLeft < 1) // no more bytes left
+							error("Script::identifyOffsets(): said-string without terminator in script %d", _nr);
+						if (stringDataByte < 0xF0) {
+							// Part of a word, skip second byte
+							stringDataPtr++;
+							stringDataLeft--;
+							if (stringDataLeft < 1) // no more bytes left
+								error("Script::identifyOffsets(): said-string without terminator in script %d", _nr);
+						}
+					} while (1);
+
+					typeSaid_id++;
+					arrayEntry.id         = typeSaid_id;
+					arrayEntry.offset     = stringStartPtr - _buf; // Calculate offset inside script data
+					arrayEntry.stringSize = 0;
+					_offsetLookupArray.push_back(arrayEntry);
+					_offsetLookupSaidCount++;
+				} while (1);
+				break;
+
+			default:
+				break;
+			}
+
+			scriptDataPtr  += blockSize;
+			scriptDataLeft -= blockSize;
+		} while (1);
+
+	} else if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1) {
+		// Strings in SCI1.1 up to SCI2 come after the object instances
+		scriptDataPtr = _heapStart;
+		scriptDataLeft = _heapSize;
+
+		if (scriptDataLeft < 4)
+			error("Script::identifyOffsets(): unexpected end of script in script %d", _nr);
+
+		uint16 endOfStringOffset = READ_SCI11ENDIAN_UINT16(scriptDataPtr);
+		uint16 objectStartOffset = READ_SCI11ENDIAN_UINT16(scriptDataPtr + 2) * 2 + 4;
+
+		if (scriptDataLeft < objectStartOffset)
+			error("Script::identifyOffsets(): object start is beyond heap size in script %d", _nr);
+		if (scriptDataLeft < endOfStringOffset)
+			error("Script::identifyOffsets(): end of string is beyond heap size in script %d", _nr);
+
+		const byte *endOfStringPtr    = scriptDataPtr + endOfStringOffset;
+
+		scriptDataPtr  += objectStartOffset;
+		scriptDataLeft -= objectStartOffset;
+
+		// go through all objects
+		do {
+			if (scriptDataLeft < 2)
+				error("Script::identifyOffsets(): unexpected end of script %d", _nr);
+
+			blockType = READ_SCI11ENDIAN_UINT16(scriptDataPtr);
+			scriptDataPtr  += 2;
+			scriptDataLeft -= 2;
+			if (blockType != SCRIPT_OBJECT_MAGIC_NUMBER)
+				break;
+
+			// Object found, add offset of object
+			typeObject_id++;
+			arrayEntry.type       = SCI_SCR_OFFSET_TYPE_OBJECT;
+			arrayEntry.id         = typeObject_id;
+			arrayEntry.offset     = scriptDataPtr - _buf - 2; // the VM uses a pointer to the Magic-Number
+			arrayEntry.stringSize = 0;
+			_offsetLookupArray.push_back(arrayEntry);
+			_offsetLookupObjectCount++;
+
+			if (scriptDataLeft < 2)
+				error("Script::identifyOffsets(): unexpected end of script in script %d", _nr);
+
+			blockSize = READ_SCI11ENDIAN_UINT16(scriptDataPtr) * 2;
+			if (blockSize < 4)
+				error("Script::identifyOffsets(): invalid block size in script %d", _nr);
+			scriptDataPtr  += 2;
+			scriptDataLeft -= 2;
+			blockSize -= 4; // blocksize contains UINT16 type and UINT16 size
+			if (scriptDataLeft < blockSize)
+				error("Script::identifyOffsets(): invalid block size in script %d", _nr);
+
+			scriptDataPtr  += blockSize;
+			scriptDataLeft -= blockSize;
+		} while (1);
+
+		// now scriptDataPtr points to right at the start of the strings
+		if (scriptDataPtr > endOfStringPtr)
+			error("Script::identifyOffsets(): string block / end-of-string block mismatch in script %d", _nr);
+
+		stringDataPtr  = scriptDataPtr;
+		stringDataLeft = endOfStringPtr - scriptDataPtr; // Calculate byte count within string-block
+
+		arrayEntry.type       = SCI_SCR_OFFSET_TYPE_STRING;
+		do {
+			if (stringDataLeft < 1) // no more bytes left
+				break;
+
+			stringStartPtr = stringDataPtr;
+			// now look for terminating [NUL]
+			do {
+				stringDataByte = *stringDataPtr;
+				stringDataPtr++;
+				stringDataLeft--;
+				if (!stringDataByte) // NUL found, exit this loop
+					break;
+				if (stringDataLeft < 1) {
+				    // no more bytes left
+					warning("Script::identifyOffsets(): string without terminating NUL in script %d", _nr);
+					break;
+				}
+			} while (1);
+
+			if (stringDataByte)
+				break;
+
+			typeString_id++;
+			arrayEntry.id         = typeString_id;
+			arrayEntry.offset     = stringStartPtr - _buf; // Calculate offset inside script data
+			arrayEntry.stringSize = stringDataPtr - stringStartPtr;
+			_offsetLookupArray.push_back(arrayEntry);
+			_offsetLookupStringCount++;
+		} while (1);
+
+	} else if (getSciVersion() == SCI_VERSION_3) {
+		// SCI3
+		uint32 sci3StringOffset = 0;
+		uint32 sci3RelocationOffset = 0;
+		uint32 sci3BoundaryOffset = 0;
+
+		if (_bufSize < 22)
+			error("Script::identifyOffsets(): script %d smaller than expected SCI3-header", _nr);
+
+		sci3StringOffset = READ_LE_UINT32(_buf + 4);
+		sci3RelocationOffset = READ_LE_UINT32(_buf + 8);
+
+		if (sci3RelocationOffset > _bufSize)
+			error("Script::identifyOffsets(): relocation offset is beyond end of script %d", _nr);
+
+		// First we get all the objects
+		scriptDataPtr = getSci3ObjectsPointer();
+		scriptDataLeft = _bufSize - (scriptDataPtr - _buf);
+		do {
+			if (scriptDataLeft < 2)
+				error("Script::identifyOffsets(): unexpected end of script %d", _nr);
+
+			blockType = READ_SCI11ENDIAN_UINT16(scriptDataPtr);
+			scriptDataPtr  += 2;
+			scriptDataLeft -= 2;
+			if (blockType != SCRIPT_OBJECT_MAGIC_NUMBER)
+				break;
+
+			// Object found, add offset of object
+			typeObject_id++;
+			arrayEntry.type       = SCI_SCR_OFFSET_TYPE_OBJECT;
+			arrayEntry.id         = typeObject_id;
+			arrayEntry.offset     = scriptDataPtr - _buf - 2; // the VM uses a pointer to the Magic-Number
+			arrayEntry.stringSize = 0;
+			_offsetLookupArray.push_back(arrayEntry);
+			_offsetLookupObjectCount++;
+
+			if (scriptDataLeft < 2)
+				error("Script::identifyOffsets(): unexpected end of script in script %d", _nr);
+
+			blockSize = READ_SCI11ENDIAN_UINT16(scriptDataPtr);
+			if (blockSize < 4)
+				error("Script::identifyOffsets(): invalid block size in script %d", _nr);
+			scriptDataPtr  += 2;
+			scriptDataLeft -= 2;
+			blockSize -= 4; // blocksize contains UINT16 type and UINT16 size
+			if (scriptDataLeft < blockSize)
+				error("Script::identifyOffsets(): invalid block size in script %d", _nr);
+
+			scriptDataPtr  += blockSize;
+			scriptDataLeft -= blockSize;
+		} while (1);
+
+		// And now we get all the strings
+		if (sci3StringOffset > 0) {
+			// string offset set, we expect strings
+			if (sci3StringOffset > _bufSize)
+				error("Script::identifyOffsets(): string offset is beyond end of script %d", _nr);
+
+			if (sci3RelocationOffset < sci3StringOffset)
+				error("Script::identifyOffsets(): string offset points beyond relocation offset in script %d", _nr);
+
+			stringDataPtr  = _buf + sci3StringOffset;
+			stringDataLeft = sci3RelocationOffset - sci3StringOffset;
+
+			arrayEntry.type       = SCI_SCR_OFFSET_TYPE_STRING;
+
+			do {
+				if (stringDataLeft < 1) // no more bytes left
+					break;
+
+				stringStartPtr = stringDataPtr;
+
+				if (stringDataLeft == 1) {
+					// only 1 byte left and that byte is a [00], in that case we also exit
+					stringDataByte = *stringStartPtr;
+					if (stringDataByte == 0x00)
+						break;
+				}
+
+				// now look for terminating [NUL]
+				do {
+					stringDataByte = *stringDataPtr;
+					stringDataPtr++;
+					stringDataLeft--;
+					if (!stringDataByte) // NUL found, exit this loop
+						break;
+					if (stringDataLeft < 1) {
+						// no more bytes left
+						warning("Script::identifyOffsets(): string without terminating NUL in script %d", _nr);
+						break;
+					}
+				} while (1);
+
+				if (stringDataByte)
+					break;
+
+				typeString_id++;
+				arrayEntry.id         = typeString_id;
+				arrayEntry.offset     = stringStartPtr - _buf; // Calculate offset inside script data
+				arrayEntry.stringSize = stringDataPtr - stringStartPtr;
+				_offsetLookupArray.push_back(arrayEntry);
+				_offsetLookupStringCount++;
+
+				// SCI3 seems to have aligned all string on DWORD boundaries
+				sci3BoundaryOffset = stringDataPtr - _buf; // Calculate current offset inside script data
+				sci3BoundaryOffset = sci3BoundaryOffset & 3; // Check boundary offset
+				if (sci3BoundaryOffset) {
+					// lower 2 bits are set? Then we have to adjust the offset
+					sci3BoundaryOffset = 4 - sci3BoundaryOffset;
+					if (stringDataLeft < sci3BoundaryOffset)
+						error("Script::identifyOffsets(): SCI3 string boundary adjustment goes beyond end of string block in script %d", _nr);
+					stringDataLeft -= sci3BoundaryOffset;
+					stringDataPtr += sci3BoundaryOffset;
+				}
+			} while (1);
+		}
+		return;
+	}
 }
 
 const byte *Script::getSci3ObjectsPointer() {
@@ -689,9 +1086,14 @@ void Script::initializeObjectsSci3(SegManager *segMan, SegmentId segmentId) {
 	const byte *seeker = getSci3ObjectsPointer();
 
 	while (READ_SCI11ENDIAN_UINT16(seeker) == SCRIPT_OBJECT_MAGIC_NUMBER) {
-		reg_t reg = make_reg(segmentId, seeker - _buf);
-		Object *obj = scriptObjInit(reg);
+		// We call setSegment and setOffset directly here, instead of using
+		// make_reg, as in large scripts, seeker - _buf can be larger than
+		// a 16-bit integer
+		reg_t reg;
+		reg.setSegment(segmentId);
+		reg.setOffset(seeker - _buf);
 
+		Object *obj = scriptObjInit(reg);
 		obj->setSuperClassSelector(segMan->getClassAddress(obj->getSuperClassSelector().getOffset(), SCRIPT_GET_LOCK, 0));
 		seeker += READ_SCI11ENDIAN_UINT16(seeker + 2);
 	}
diff --git a/engines/sci/engine/script.h b/engines/sci/engine/script.h
index 46d6ace917..755e2f3698 100644
--- a/engines/sci/engine/script.h
+++ b/engines/sci/engine/script.h
@@ -49,6 +49,21 @@ enum ScriptObjectTypes {
 
 typedef Common::HashMap<uint16, Object> ObjMap;
 
+enum ScriptOffsetEntryTypes {
+	SCI_SCR_OFFSET_TYPE_OBJECT = 0, // classes are handled by this type as well
+	SCI_SCR_OFFSET_TYPE_STRING,
+	SCI_SCR_OFFSET_TYPE_SAID
+};
+
+struct offsetLookupArrayEntry {
+	uint16    type;       // type of entry
+	uint16    id;         // id of this type, first item inside script data is 1, second item is 2, etc.
+	uint32    offset;     // offset of entry within script resource data
+	uint16    stringSize; // size of string, including terminating [NUL]
+};
+
+typedef Common::Array<offsetLookupArrayEntry> offsetLookupArrayType;
+
 class Script : public SegmentObj {
 private:
 	int _nr; /**< Script number */
@@ -75,6 +90,14 @@ private:
 
 	ObjMap _objects;	/**< Table for objects, contains property variables */
 
+protected:
+	offsetLookupArrayType _offsetLookupArray; // Table of all elements of currently loaded script, that may get pointed to
+
+private:
+	uint16 _offsetLookupObjectCount;
+	uint16 _offsetLookupStringCount;
+	uint16 _offsetLookupSaidCount;
+
 public:
 	int getLocalsOffset() const { return _localsOffset; }
 	uint16 getLocalsCount() const { return _localsCount; }
@@ -248,6 +271,14 @@ public:
 	 */
 	int getCodeBlockOffsetSci3() { return READ_SCI11ENDIAN_UINT32(_buf); }
 
+	/**
+	 * Get the offset array
+	 */
+	const offsetLookupArrayType *getOffsetArray() { return &_offsetLookupArray; };
+	uint16 getOffsetObjectCount() { return _offsetLookupObjectCount; };
+	uint16 getOffsetStringCount() { return _offsetLookupStringCount; };
+	uint16 getOffsetSaidCount() { return _offsetLookupSaidCount; };
+
 private:
 	/**
 	 * Processes a relocation block within a SCI0-SCI2.1 script
@@ -294,6 +325,11 @@ private:
 	void initializeObjectsSci3(SegManager *segMan, SegmentId segmentId);
 
 	LocalVariables *allocLocalsSegment(SegManager *segMan);
+
+	/**
+	 * Identifies certain offsets within script data and set up lookup-table
+	 */
+	void identifyOffsets();
 };
 
 } // End of namespace Sci
diff --git a/engines/sci/engine/script_patches.cpp b/engines/sci/engine/script_patches.cpp
index 03cd1d06e9..6915e12a0e 100644
--- a/engines/sci/engine/script_patches.cpp
+++ b/engines/sci/engine/script_patches.cpp
@@ -94,6 +94,8 @@ static const char *const selectorNameTable[] = {
 	"deskSarg",     // Gabriel Knight
 	"localize",     // Freddy Pharkas
 	"put",          // Police Quest 1 VGA
+	"say",          // Quest For Glory 1 VGA
+	"contains",     // Quest For Glory 2
 	"solvePuzzle",  // Quest For Glory 3
 	"timesShownID", // Space Quest 1 VGA
 	"startText",    // King's Quest 6 CD / Laura Bow 2 CD for audio+text support
@@ -119,6 +121,8 @@ enum ScriptPatcherSelectors {
 	SELECTOR_deskSarg,
 	SELECTOR_localize,
 	SELECTOR_put,
+	SELECTOR_say,
+	SELECTOR_contains,
 	SELECTOR_solvePuzzle,
 	SELECTOR_timesShownID,
 	SELECTOR_startText,
@@ -562,12 +566,12 @@ static const uint16 gk1SignatureDay6PoliceSleep[] = {
 	0x34, SIG_UINT16(0x00dc),           // ldi 220
 	0x65, SIG_ADDTOOFFSET(+1),          // aTop cycles (1a for PC, 1c for Mac)
 	0x32,                               // jmp [end]
-	0
+	SIG_END
 };
 
 static const uint16 gk1PatchDay6PoliceSleep[] = {
 	PATCH_ADDTOOFFSET(+5),
-	0x34, SIG_UINT16(0x002a),           // ldi 42
+	0x34, PATCH_UINT16(0x002a),         // ldi 42
 	0x65, PATCH_GETORIGINALBYTEADJUST(+9, +2), // aTop seconds (1c for PC, 1e for Mac)
 	PATCH_END
 };
@@ -1421,6 +1425,37 @@ static const SciScriptPatcherEntry larry2Signatures[] = {
 
 // ===========================================================================
 // Leisure Suit Larry 5
+// In Miami the player can call the green card telephone number and get
+//  green card including limo at the same time in the English 1.000 PC release.
+// This results later in a broken game in case the player doesn't read
+//  the second telephone number for the actual limousine service, because
+//  in that case it's impossible for the player to get back to the airport.
+//
+// We disable the code, that is responsible to make the limo arrive.
+//
+// This bug was fixed in the European (dual language) versions of the game.
+//
+// Applies to at least: English PC floppy (1.000)
+// Responsible method: sPhone::changeState(40)
+static const uint16 larry5SignatureGreenCardLimoBug[] = {
+	0x7a,                               // push2
+	SIG_MAGICDWORD,
+	0x39, 0x07,                         // pushi 07
+	0x39, 0x0c,                         // pushi 0Ch
+	0x45, 0x0a, 0x04,                   // call export 10 of script 0
+	0x78,                               // push1
+	0x39, 0x26,                         // pushi 26h (limo arrived flag)
+	0x45, 0x07, 0x02,                   // call export 7 of script 0 (sets flag)
+	SIG_END
+};
+
+static const uint16 larry5PatchGreenCardLimoBug[] = {
+	PATCH_ADDTOOFFSET(+8),
+	0x34, PATCH_UINT16(0),              // ldi 0000 (dummy)
+	0x34, PATCH_UINT16(0),              // ldi 0000 (dummy)
+	PATCH_END
+};
+
 // In one of the conversations near the end (to be exact - room 380 and the text
 //  about using champagne on Reverse Biaz - only used when you actually did that
 //  in the game), the German text is too large, causing the textbox to get too large.
@@ -1444,6 +1479,7 @@ static const uint16 larry5PatchGermanEndingPattiTalker[] = {
 
 //          script, description,                                      signature                               patch
 static const SciScriptPatcherEntry larry5Signatures[] = {
+	{  true,   280, "English-only: fix green card limo bug",       1, larry5SignatureGreenCardLimoBug,        larry5PatchGreenCardLimoBug },
 	{  true,   380, "German-only: Enlarge Patti Textbox",          1, larry5SignatureGermanEndingPattiTalker, larry5PatchGermanEndingPattiTalker },
 	SCI_SIGNATUREENTRY_TERMINATOR
 };
@@ -2087,21 +2123,30 @@ static const uint16 qfg1vgaPatchMoveToCrusher[] = {
 
 // Same pathfinding bug as above, where Ego is set to move to an impossible
 // spot when sneaking. In GuardsTrumpet::changeState, we change the final
-// location where Ego is moved from 111, 111 to 114, 114.
+// location where Ego is moved from 111, 111 to 116, 116.
+// target coordinate is really problematic here.
+//
+// 114, 114 works when the speed slider is all the way up, but doesn't work
+// when the speed slider is not.
+//
+// It seems that this bug was fixed by Sierra for the Macintosh version.
+//
+// Applies to at least: English PC floppy
+// Responsible method: GuardsTrumpet::changeState(8)
 // Fixes bug: #6248
 static const uint16 qfg1vgaSignatureMoveToCastleGate[] = {
+	0x51, SIG_ADDTOOFFSET(+1),          // class MoveTo
 	SIG_MAGICDWORD,
-	0x51, 0x1f,                         // class MoveTo
 	0x36,                               // push
-	0x39, 0x6f,                         // pushi 6f (111 - x)
-	0x3c,                               // dup (111 - y)
+	0x39, 0x6f,                         // pushi 6f (111d)
+	0x3c,                               // dup (111d) - coordinates 111, 111
 	0x7c,                               // pushSelf
 	SIG_END
 };
 
 static const uint16 qfg1vgaPatchMoveToCastleGate[] = {
 	PATCH_ADDTOOFFSET(+3),
-	0x39, 0x72,                         // pushi 72 (114 - x)
+	0x39, 0x74,                         // pushi 74 (116d), changes coordinates to 116, 116
 	PATCH_END
 };
 
@@ -2116,7 +2161,7 @@ static const uint16 qfg1vgaSignatureCheetaurDescription[] = {
 	0x34, SIG_UINT16(0x01b8),           // ldi 01b8
 	0x1a,                               // eq?
 	0x31, 0x16,                         // bnt 16
-	0x38, SIG_UINT16(0x0127),           // pushi 0127
+	0x38, SIG_SELECTOR16(say),          // pushi 0127h (selector "say")
 	0x39, 0x06,                         // pushi 06
 	0x39, 0x03,                         // pushi 03
 	0x78,                               // push1
@@ -2140,6 +2185,7 @@ static const uint16 qfg1vgaPatchCheetaurDescription[] = {
 // Local 5 of that room is a timer, that closes the door (object door11).
 // Setting it to 1 during happyFace::changeState(0) stops door11::doit from
 //  calling goTo6::init, so the whole issue is stopped from happening.
+//
 // Applies to at least: English floppy
 // Responsible method: happyFace::changeState, door11::doit
 // Fixes bug #6181
@@ -2166,20 +2212,172 @@ static const uint16 qfg1vgaPatchFunnyRoomFix[] = {
 	PATCH_END
 };
 
+// The player is able to buy (and also steal) potions in the healer's hut
+//  Strangely Sierra delays the actual buy/get potion code for 60 ticks
+//  Why they did that is unknown. The code is triggered anyway only after
+//  the relevant dialog boxes are closed.
+//
+// This delay causes problems in case the user quickly enters the inventory.
+// That's why we change the amount of ticks to 1, so that the remaining states
+//  are executed right after the dialog boxes are closed.
+//
+// Applies to at least: English floppy
+// Responsible method: cueItScript::changeState
+// Fixes bug #6706
+static const uint16 qfg1vgaSignatureHealerHutNoDelay[] = {
+	0x65, 0x14,                         // aTop 14 (state)
+	0x36,                               // push
+	0x3c,                               // dup
+	0x35, 0x00,                         // ldi 00
+	0x1a,                               // eq?
+	0x31, 0x07,                         // bnt 07 [-> next state]
+	SIG_MAGICDWORD,
+	0x35, 0x3c,                         // ldi 3c (60 ticks)
+	0x65, 0x20,                         // aTop ticks
+	0x32,                               // jmp [-> end of method]
+	SIG_END
+};
+
+static const uint16 qfg1vgaPatchHealerHutNoDelay[] = {
+	PATCH_ADDTOOFFSET(+9),
+	0x35, 0x01,                         // ldi 01 (1 tick only, so that execution will resume as soon as dialog box is closed)
+	PATCH_END
+};
+
+// When following the white stag, you can actually enter the 2nd room from the mushroom/fairy location,
+//  which results in ego entering from the top. When you then throw a dagger at the stag, one animation
+//  frame will stay on screen, because of a script bug.
+//
+// Applies to at least: English floppy, Mac floppy
+// Responsible method: stagHurt::changeState
+// Fixes bug #6135
+static const uint16 qfg1vgaSignatureWhiteStagDagger[] = {
+	0x87, 0x01,                         // lap param[1]
+	0x65, 0x14,                         // aTop state
+	0x36,                               // push
+	0x3c,                               // dup
+	0x35, 0x00,                         // ldi 0
+	0x1a,                               // eq?
+	0x31, 0x16,                         // bnt [next parameter check]
+	0x76,                               // push0
+	0x45, 0x02, 0x00,                   // callb export 2 from script 0, 0
+	SIG_MAGICDWORD,
+	0x38, SIG_SELECTOR16(say),          // pushi 0127h (selector "say")
+	0x39, 0x05,                         // pushi 05
+	0x39, 0x03,                         // pushi 03
+	0x39, 0x51,                         // pushi 51h
+	0x76,                               // push0
+	0x76,                               // push0
+	0x7c,                               // pushSelf
+	0x81, 0x5b,                         // lag global[5Bh] -> qg1Messager
+	0x4a, 0x0e,                         // send 0Eh -> qg1Messager::say(3, 51h, 0, 0, stagHurt)
+	0x33, 0x12,                         // jmp -> [ret]
+	0x3c,                               // dup
+	0x35, 0x01,                         // ldi 1
+	0x1a,                               // eq?
+	0x31, 0x0c,                         // bnt [ret]
+	0x38,                               // pushi...
+	SIG_ADDTOOFFSET(+11),
+	0x3a,                               // toss
+	0x48,                               // ret
+	SIG_END
+};
+
+static const uint16 qfg1vgaPatchWhiteStagDagger[] = {
+	PATCH_ADDTOOFFSET(+4),
+	0x2f, 0x05,                         // bt [next check] (state != 0)
+	// state = 0 code
+	0x35, 0x01,                         // ldi 1
+	0x65, 0x1a,                         // aTop cycles
+	0x48,                               // ret
+	0x36,                               // push
+	0x35, 0x01,                         // ldi 1
+	0x1a,                               // eq?
+	0x31, 0x16,                         // bnt [state = 2 code]
+	// state = 1 code
+	0x76,                               // push0
+	0x45, 0x02, 0x00,                   // callb export 2 from script 0, 0
+	0x38, PATCH_SELECTOR16(say),        // pushi 0127h (selector "say")
+	0x39, 0x05,                         // pushi 05
+	0x39, 0x03,                         // pushi 03
+	0x39, 0x51,                         // pushi 51h
+	0x76,                               // push0
+	0x76,                               // push0
+	0x7c,                               // pushSelf
+	0x81, 0x5b,                         // lag global[5Bh] -> qg1Messager
+	0x4a, 0x0e,                         // send 0Eh -> qg1Messager::say(3, 51h, 0, 0, stagHurt)
+	0x48,                               // ret
+	// state = 2 code
+	PATCH_ADDTOOFFSET(+13),
+	0x48,                               // ret (remove toss)
+	PATCH_END
+};
+
 //          script, description,                                      signature                            patch
 static const SciScriptPatcherEntry qfg1vgaSignatures[] = {
+	{  true,    41, "moving to castle gate",                       1, qfg1vgaSignatureMoveToCastleGate,    qfg1vgaPatchMoveToCastleGate },
+	{  true,    55, "healer's hut, no delay for buy/steal",        1, qfg1vgaSignatureHealerHutNoDelay,    qfg1vgaPatchHealerHutNoDelay },
+	{  true,    77, "white stag dagger throw animation glitch",    1, qfg1vgaSignatureWhiteStagDagger,     qfg1vgaPatchWhiteStagDagger },
+	{  true,    96, "funny room script bug fixed",                 1, qfg1vgaSignatureFunnyRoomFix,        qfg1vgaPatchFunnyRoomFix },
+	{  true,   210, "cheetaur description fixed",                  1, qfg1vgaSignatureCheetaurDescription, qfg1vgaPatchCheetaurDescription },
 	{  true,   215, "fight event issue",                           1, qfg1vgaSignatureFightEvents,         qfg1vgaPatchFightEvents },
 	{  true,   216, "weapon master event issue",                   1, qfg1vgaSignatureFightEvents,         qfg1vgaPatchFightEvents },
+	{  true,   331, "moving to crusher",                           1, qfg1vgaSignatureMoveToCrusher,       qfg1vgaPatchMoveToCrusher },
 	{  true,   814, "window text temp space",                      1, qfg1vgaSignatureTempSpace,           qfg1vgaPatchTempSpace },
 	{  true,   814, "dialog header offset",                        3, qfg1vgaSignatureDialogHeader,        qfg1vgaPatchDialogHeader },
-	{  true,   331, "moving to crusher",                           1, qfg1vgaSignatureMoveToCrusher,       qfg1vgaPatchMoveToCrusher },
-	{  true,    41, "moving to castle gate",                       1, qfg1vgaSignatureMoveToCastleGate,    qfg1vgaPatchMoveToCastleGate },
-	{  true,   210, "cheetaur description fixed",                  1, qfg1vgaSignatureCheetaurDescription, qfg1vgaPatchCheetaurDescription },
-	{  true,    96, "funny room script bug fixed",                 1, qfg1vgaSignatureFunnyRoomFix,        qfg1vgaPatchFunnyRoomFix },
 	SCI_SIGNATUREENTRY_TERMINATOR
 };
 
 // ===========================================================================
+
+// This is a very complicated bug.
+// When the player encounters an enemy in the desert while riding a saurus and later
+//  tries to get back on it by entering "ride", the game will not give control back
+//  to the player.
+//
+// This is caused by script mountSaurus getting triggered twice.
+//  Once by entering the command "ride" and then a second time by a proximity check.
+//
+// Both are calling mountSaurus::init() in script 20, this one disables controls
+//  then mountSaurus::changeState() from script 660 is triggered
+//  mountSaurus::changeState(5) finally calls mountSaurus::dispose(), which is also in script 20
+//  which finally re-enables controls
+//
+// A fix is difficult to implement. The code in script 20 is generic and used by multiple objects
+//
+// Originally I decided to change the responsible globals (66h and A1h) during mountSaurus::changeState(5).
+//  This worked as far as for controls, but mountSaurus::init changes a few selectors of ego as well, which
+//  won't get restored in that situation, which then messes up room changes and other things.
+//
+// I have now decided to change sheepScript::changeState(2) in script 665 instead.
+//
+// This fix could cause issues in case there is a cutscene, where ego is supposed to get onto the saurus using
+//  sheepScript.
+//
+// Applies to at least: English PC Floppy, English Amiga Floppy
+// Responsible method: mountSaurus::changeState(), mountSaurus::init(), mountSaurus::dispose()
+// Fixes bug: #5156
+static const uint16 qfg2SignatureSaurusFreeze[] = {
+	0x3c,                               // dup
+	0x35, 0x02,                         // ldi 5
+	SIG_MAGICDWORD,
+	0x1a,                               // eq?
+	0x30, SIG_UINT16(0x0043),           // bnt [ret]
+	0x76,                               // push0
+	SIG_ADDTOOFFSET(+61),               // skip to dispose code
+	0x39, SIG_SELECTOR8(dispose),       // pushi "dispose"
+	0x76,                               // push0
+	0x54, 0x04,                         // self 04
+	SIG_END
+};
+
+static const uint16 qfg2PatchSaurusFreeze[] = {
+	0x81, 0x66,                         // lag 66h
+	0x2e, SIG_UINT16(0x0040),           // bt [to dispose code]
+	0x35, 0x00,                         // ldi 0 (waste 2 bytes)
+	PATCH_END
+};
+
 // Script 944 in QFG2 contains the FileSelector system class, used in the
 // character import screen. This gets incorrectly called constantly, whenever
 // the user clicks on a button in order to refresh the file list. This was
@@ -2211,9 +2409,58 @@ static const uint16 qfg2PatchImportDialog[] = {
 	PATCH_END
 };
 
-//          script, description,                                      signature                  patch
+// Quest For Glory 2 character import doesn't properly set the character type
+//  in versions 1.102 and below, which makes all importerted characters a fighter.
+//
+// Sierra released an official patch. However the fix is really easy to
+//  implement on our side, so we also patch the flaw in here in case we find it.
+//
+// The version released on GOG is 1.102 without this patch applied, so us
+//  patching it is quite useful.
+//
+// Applies to at least: English Floppy
+// Responsible method: importHero::changeState
+// Fixes bug: inside versions 1.102 and below
+static const uint16 qfg2SignatureImportCharType[] = {
+	0x35, 0x04,                         // ldi 04
+	0x90, SIG_UINT16(0x023b),           // lagi global[23Bh]
+	0x02,                               // add
+	0x36,                               // push
+	0x35, 0x04,                         // ldi 04
+	0x08,                               // div
+	0x36,                               // push
+	0x35, 0x0d,                         // ldi 0D
+	0xb0, SIG_UINT16(0x023b),           // sagi global[023Bh]
+	0x8b, 0x1f,                         // lsl local[1Fh]
+	0x35, 0x05,                         // ldi 05
+	SIG_MAGICDWORD,
+	0xb0, SIG_UINT16(0x0150),           // sagi global[0150h]
+	0x8b, 0x02,                         // lsl local[02h]
+	SIG_END
+};
+
+static const uint16 qfg2PatchImportCharType[] = {
+	0x80, PATCH_UINT16(0x023f),         // lag global[23Fh] <-- patched to save 2 bytes
+	0x02,                               // add
+	0x36,                               // push
+	0x35, 0x04,                         // ldi 04
+	0x08,                               // div
+	0x36,                               // push
+	0xa8, SIG_UINT16(0x0248),           // ssg global[0248h] <-- patched to save 2 bytes
+	0x8b, 0x1f,                         // lsl local[1Fh]
+	0xa8, SIG_UINT16(0x0155),           // ssg global[0155h] <-- patched to save 2 bytes
+	// new code, directly from the official sierra patch file
+	0x83, 0x01,                         // lal local[01h]
+	0xa1, 0xbb,                         // sag global[BBh]
+	0xa1, 0x73,                         // sag global[73h]
+	PATCH_END
+};
+
+//          script, description,                                      signature                    patch
 static const SciScriptPatcherEntry qfg2Signatures[] = {
-	{  true,   944, "import dialog continuous calls",              1, qfg2SignatureImportDialog, qfg2PatchImportDialog },
+	{  true,   665, "getting back on saurus freeze fix",           1, qfg2SignatureSaurusFreeze,   qfg2PatchSaurusFreeze },
+	{  true,   805, "import character type fix",                   1, qfg2SignatureImportCharType, qfg2PatchImportCharType },
+	{  true,   944, "import dialog continuous calls",              1, qfg2SignatureImportDialog,   qfg2PatchImportDialog },
 	SCI_SIGNATUREENTRY_TERMINATOR
 };
 
@@ -2282,10 +2529,158 @@ static const uint16 qfg3PatchWooDialog[] = {
 	PATCH_END
 };
 
-//          script, description,                                      signature                  patch
+// Alternative version, with uint16 offsets, for GOG release of QfG3.
+static const uint16 qfg3SignatureWooDialogAlt[] = {
+	SIG_MAGICDWORD,
+	0x67, 0x12,                         // pTos 12 (query)
+	0x35, 0xb6,                         // ldi b6
+	0x1a,                               // eq?
+	0x2e, SIG_UINT16(0x0005),           // bt 05
+	0x67, 0x12,                         // pTos 12 (query)
+	0x35, 0x9b,                         // ldi 9b
+	0x1a,                               // eq?
+	0x30, SIG_UINT16(0x000c),           // bnt 0c
+	0x38, SIG_SELECTOR16(solvePuzzle),  // pushi 0297
+	0x7a,                               // push2
+	0x38, SIG_UINT16(0x010c),           // pushi 010c
+	0x7a,                               // push2
+	0x81, 0x00,                         // lag 00
+	0x4a, 0x08,                         // send 08
+	0x67, 0x12,                         // pTos 12 (query)
+	0x35, 0xb5,                         // ldi b5
+	SIG_END
+};
+
+static const uint16 qfg3PatchWooDialogAlt[] = {
+	PATCH_ADDTOOFFSET(+0x2C),
+	0x33, 0x12,                         // jmp to 0x708, the call to hero::solvePuzzle for 0xFFFC
+	PATCH_END
+};
+
+// When exporting characters at the end of Quest for Glory 3, the underlying
+//  code has issues with values, that are above 9999.
+//  For further study: https://github.com/Blazingstix/QFGImporter/blob/master/QFGImporter/QFGImporter/QFG3.txt
+//
+// If a value is above 9999, parts or even the whole character file will get corrupted.
+//
+// We are fixing the code because of that. We are patching code, that is calculating the checksum
+//  and add extra code to lower such values to 9999.
+//
+// Applies to at least: English, French, German, Italian, Spanish floppy
+// Responsible method: saveHero::changeState
+// Fixes bug #6807
+static const uint16 qfg3SignatureExportChar[] = {
+	0x35, SIG_ADDTOOFFSET(+1),          // ldi  00 / ldi 01 (2 loops, we patch both)
+	0xa5, 0x00,                         // sat  temp[0] [contains index to data]
+	0x8d, 0x00,                         // lst  temp[0]
+	SIG_MAGICDWORD,
+	0x35, 0x2c,                         // ldi  2c
+	0x22,                               // lt?  [index above or equal 2Ch (44d)?
+	0x31, 0x23,                         // bnt  [exit loop]
+	// from this point it's actually useless code, maybe a sci compiler bug
+	0x8d, 0x00,                         // lst  temp[0]
+	0x35, 0x01,                         // ldi  01
+	0x02,                               // add
+	0x9b, 0x00,                         // lsli local[0] ---------- load local[0 + ACC] onto stack
+	0x8d, 0x00,                         // lst  temp[0]
+	0x35, 0x01,                         // ldi  01
+	0x02,                               // add
+	0xb3, 0x00,                         // sali local[0] ---------- save stack to local[0 + ACC]
+	// end of useless code
+	0x8b, SIG_ADDTOOFFSET(+1),          // lsl  local[36h/37h] ---- load local[36h/37h] onto stack
+	0x8d, 0x00,                         // lst  temp[0]
+	0x35, 0x01,                         // ldi  01
+	0x02,                               // add
+	0x93, 0x00,                         // lali local[0] ---------- load local[0 + ACC] into ACC
+	0x02,                               // add -------------------- add ACC + stack and put into ACC
+	0xa3, SIG_ADDTOOFFSET(+1),          // sal  local[36h/37h] ---- save ACC to local[36h/37h]
+	0x8d, 0x00,                         // lst temp[0] ------------ temp[0] to stack
+	0x35, 0x02,                         // ldi 02
+	0x02,                               // add -------------------- add 2 to stack
+	0xa5, 0x00,                         // sat temp[0] ------------ save ACC to temp[0]
+	0x33, 0xd6,                         // jmp [loop]
+	SIG_END
+};
+
+static const uint16 qfg3PatchExportChar[] = {
+	PATCH_ADDTOOFFSET(+11),
+	0x85, 0x00,                         // lat  temp[0]
+	0x9b, 0x01,                         // lsli local[0] + 1 ------ load local[ ACC + 1] onto stack
+	0x3c,                               // dup
+	0x34, PATCH_UINT16(0x2710),         // ldi  2710h (10000d)
+	0x2c,                               // ult? ------------------- is value smaller than 10000?
+	0x2f, 0x0a,                         // bt   [jump over]
+	0x3a,                               // toss
+	0x38, PATCH_UINT16(0x270f),         // pushi 270fh (9999d)
+	0x3c,                               // dup
+	0x85, 0x00,                         // lat  temp[0]
+	0xba, PATCH_UINT16(0x0001),         // ssli local[0] + 1 ------ save stack to local[ ACC + 1] (UINT16 to waste 1 byte)
+	// jump offset
+	0x83, PATCH_GETORIGINALBYTE(+26),   // lal  local[37h/36h] ---- load local[37h/36h] into ACC
+	0x02,                               // add -------------------- add local[37h/36h] + data value
+	PATCH_END
+};
+
+// Quest for Glory 3 doesn't properly import the character type of Quest for Glory 1 character files.
+//  This issue was never addressed. It's caused by Sierra reading data directly from the local
+//  area, which is only set by Quest For Glory 2 import data, instead of reading the properly set global variable.
+//
+// We fix it, by also directly setting the local variable.
+//
+// Applies to at least: English, French, German, Italian, Spanish floppy
+// Responsible method: importHero::changeState(4)
+static const uint16 qfg3SignatureImportQfG1Char[] = {
+	SIG_MAGICDWORD,
+	0x82, SIG_UINT16(0x0238),           // lal local[0x0238]
+	0xa0, SIG_UINT16(0x016a),           // sag global[0x016a]
+	0xa1, 0x7d,                         // sag global[0x7d]
+	0x35, 0x01,                         // ldi 01
+	0x99, 0xfb,                         // lsgi global[0xfb]
+	SIG_END
+};
+
+static const uint16 qfg3PatchImportQfG1Char[] = {
+	PATCH_ADDTOOFFSET(+8),
+	0xa3, 0x01,                         // sal 01           -> also set local[01]
+	0x89, 0xfc,                         // lsg global[0xFD] -> save 2 bytes
+	PATCH_END
+};
+
+// The chief in his hut (room 640) is not drawn using the correct priority,
+//  which results in a graphical glitch. This is a game bug and also happens
+//  in Sierra's SCI. We adjust priority accordingly to fix it.
+//
+// Applies to at least: English, French, German, Italian, Spanish floppy
+// Responsible method: heap in script 640
+// Fixes bug #5173
+static const uint16 qfg3SignatureChiefPriority[] = {
+	SIG_MAGICDWORD,
+	SIG_UINT16(0x0002),                 // yStep     0x0002
+	SIG_UINT16(0x0281),                 // view      0x0281
+	SIG_UINT16(0x0000),                 // loop      0x0000
+	SIG_UINT16(0x0000),                 // cel       0x0000
+	SIG_UINT16(0x0000),                 // priority  0x0000
+	SIG_UINT16(0x0000),                 // underbits 0x0000
+	SIG_UINT16(0x1000),                 // signal    0x1000
+	SIG_END
+};
+
+static const uint16 qfg3PatchChiefPriority[] = {
+	PATCH_ADDTOOFFSET(+8),
+	PATCH_UINT16(0x000A),               // new priority 0x000A (10d)
+	PATCH_ADDTOOFFSET(+2),
+	PATCH_UINT16(0x1010),               // signal       0x1010 (set fixed priority flag)
+	PATCH_END
+};
+
+//          script, description,                                      signature                    patch
 static const SciScriptPatcherEntry qfg3Signatures[] = {
-	{  true,   944, "import dialog continuous calls",              1, qfg3SignatureImportDialog, qfg3PatchImportDialog },
-	{  true,   440, "dialog crash when asking about Woo",          1, qfg3SignatureWooDialog,    qfg3PatchWooDialog },
+	{  true,   944, "import dialog continuous calls",              1, qfg3SignatureImportDialog,   qfg3PatchImportDialog },
+	{  true,   440, "dialog crash when asking about Woo",          1, qfg3SignatureWooDialog,      qfg3PatchWooDialog },
+	{  true,   440, "dialog crash when asking about Woo",          1, qfg3SignatureWooDialogAlt,   qfg3PatchWooDialogAlt },
+	{  true,    52, "export character save bug",                   2, qfg3SignatureExportChar,     qfg3PatchExportChar },
+	{  true,    54, "import character from QfG1 bug",              1, qfg3SignatureImportQfG1Char, qfg3PatchImportQfG1Char },
+	{  true,   640, "chief in hut priority fix",                   1, qfg3SignatureChiefPriority, qfg3PatchChiefPriority },
 	SCI_SIGNATUREENTRY_TERMINATOR
 };
 
@@ -2345,6 +2740,102 @@ static const uint16 sq4FloppyPatchThrowStuffAtSequelPoliceBug[] = {
 	PATCH_END
 };
 
+// Right at the start of Space Quest 4 CD, when walking up in the first room, ego will
+//  immediately walk down just after entering the upper room.
+//
+// This is caused by the scripts setting ego's vertical coordinate to 189 (BDh), which is the
+//  trigger in rooms to walk to the room below it. Sometimes this isn't triggered, because
+//  the scripts also initiate a motion to vertical coordinate 188 (BCh). When you lower the game's speed,
+//  this bug normally always triggers. And it triggers of course also in the original interpreter.
+//
+// It doesn't happen in PC floppy, because nsRect is not the same as in CD.
+//
+// We fix it by setting ego's vertical coordinate to 188 and we also initiate a motion to 187.
+//
+// Applies to at least: English PC CD
+// Responsible method: rm045::doit
+// Fixes bug: #5468
+static const uint16 sq4CdSignatureWalkInFromBelowRoom45[] = {
+	0x76,                               // push0
+	SIG_MAGICDWORD,
+	0x78,                               // push1
+	0x38, SIG_UINT16(0x00bd),           // pushi 00BDh
+	0x38, SIG_ADDTOOFFSET(+2),          // pushi [setMotion selector]
+	0x39, 0x03,                         // pushi 3
+	0x51, SIG_ADDTOOFFSET(+1),          // class [MoveTo]
+	0x36,                               // push
+	0x78,                               // push1
+	0x76,                               // push0
+	0x81, 0x00,                         // lag global[0]
+	0x4a, 0x04,                         // send 04 -> get ego::x
+	0x36,                               // push
+	0x38, SIG_UINT16(0x00bc),           // pushi 00BCh
+	SIG_END
+};
+
+static const uint16 sq4CdPatchWalkInFromBelowRoom45[] = {
+	PATCH_ADDTOOFFSET(+2),
+	0x38, PATCH_UINT16(0x00bc),         // pushi 00BCh
+	PATCH_ADDTOOFFSET(+15),
+	0x38, PATCH_UINT16(0x00bb),         // pushi 00BBh
+	PATCH_END
+};
+
+// It seems that Sierra forgot to set a script flag, when cleaning out the bank account
+// in Space Quest 4 CD. This was probably caused by the whole bank account interaction
+// getting a rewrite and polish in the CD version.
+//
+// Because of this bug, points for changing back clothes will not get awarded, which
+// makes it impossible to get a perfect point score in the CD version of the game.
+// The points are awarded by rm371::doit in script 371.
+//
+// We fix this. Bug also happened, when using the original interpreter.
+// Bug does not happen for PC floppy.
+//
+// Attention: Some Let's Plays on youtube show that points are in fact awarded. Which is true.
+//            But those Let's Plays were actually created by playing a hacked Space Quest 4 version
+//            (which is part Floppy, part CD version - we consider it to be effectively pirated)
+//            and not the actual CD version of Space Quest 4.
+//            It's easy to identify - talkie + store called "Radio Shack" -> is hacked version.
+//
+// Applies to at least: English PC CD
+// Responsible method: but2Script::changeState(2)
+// Fixes bug: #6866
+static const uint16 sq4CdSignatureGetPointsForChangingBackClothes[] = {
+	0x35, 0x02,                         // ldi 02
+	SIG_MAGICDWORD,
+	0x1a,                               // eq?
+	0x30, SIG_UINT16(0x006a),           // bnt [state 3]
+	0x76,
+	SIG_ADDTOOFFSET(+46),               // jump over "withdraw funds" code
+	0x33, 0x33,                         // jmp [end of state 2, set cycles code]
+	SIG_ADDTOOFFSET(+51),               // jump over "clean bank account" code
+	0x35, 0x02,                         // ldi 02
+	0x65, 0x1a,                         // aTop cycles
+	0x33, 0x0b,                         // jmp [toss/ret]
+	0x3c,                               // dup
+	0x35, 0x03,                         // ldi 03
+	0x1a,                               // eq?
+	0x31, 0x05,                         // bnt [toss/ret]
+	SIG_END
+};
+
+static const uint16 sq4CdPatchGetPointsForChangingBackClothes[] = {
+	PATCH_ADDTOOFFSET(+3),
+	0x30, PATCH_UINT16(0x0070),         // bnt [state 3]
+	PATCH_ADDTOOFFSET(+47),             // "withdraw funds" code
+	0x33, 0x39,                         // jmp [end of state 2, set cycles code]
+	PATCH_ADDTOOFFSET(+51),
+	0x78,                               // push1
+	0x39, 0x1d,                         // ldi 1Dh
+	0x45, 0x07, 0x02,                   // call export 7 of script 0 (set flag) -> effectively sets global 73h, bit 2
+	0x35, 0x02,                         // ldi 02
+	0x65, 0x1c,                         // aTop cycles
+	0x33, 0x05,                         // jmp [toss/ret]
+	// check for state 3 code removed to save 6 bytes
+	PATCH_END
+};
+
 // The scripts in SQ4CD support simultaneous playing of speech and subtitles,
 // but this was not available as an option. The following two patches enable
 // this functionality in the game's GUI options dialog.
@@ -2439,8 +2930,10 @@ static const uint16 sq4CdPatchTextOptions[] = {
 static const SciScriptPatcherEntry sq4Signatures[] = {
 	{  true,   298, "Floppy: endless flight",                      1, sq4FloppySignatureEndlessFlight,               sq4FloppyPatchEndlessFlight },
 	{  true,   700, "Floppy: throw stuff at sequel police bug",    1, sq4FloppySignatureThrowStuffAtSequelPoliceBug, sq4FloppyPatchThrowStuffAtSequelPoliceBug },
-	{  true,   818, "CD: Speech and subtitles option",             1, sq4CdSignatureTextOptions,                     sq4CdPatchTextOptions },
+	{  true,    45, "CD: walk in from below for room 45 fix",      1, sq4CdSignatureWalkInFromBelowRoom45,           sq4CdPatchWalkInFromBelowRoom45 },
+	{  true,   396, "CD: get points for changing back clothes fix",1, sq4CdSignatureGetPointsForChangingBackClothes, sq4CdPatchGetPointsForChangingBackClothes },
 	{  true,     0, "CD: Babble icon speech and subtitles fix",    1, sq4CdSignatureBabbleIcon,                      sq4CdPatchBabbleIcon },
+	{  true,   818, "CD: Speech and subtitles option",             1, sq4CdSignatureTextOptions,                     sq4CdPatchTextOptions },
 	{  true,   818, "CD: Speech and subtitles option button",      1, sq4CdSignatureTextOptionsButton,               sq4CdPatchTextOptionsButton },
 	SCI_SIGNATUREENTRY_TERMINATOR
 };
@@ -2471,6 +2964,29 @@ static const uint16 sq1vgaPatchUlenceFlatsTimepodGfxGlitch[] = {
 	PATCH_END
 };
 
+// In Ulence Flats, there is a space ship, that you will use at some point.
+//  Near that space ship are 2 force field generators.
+//  When you look at the top of those generators, the game will crash.
+//  This happens also in Sierra SCI. It's caused by a jump, that goes out of bounds.
+//  We currently do not know if this was caused by a compiler glitch or if it was a developer error.
+//  Anyway we patch this glitchy code, so that the game won't crash anymore.
+//
+// Applies to at least: English Floppy
+// Responsible method: radar1::doVerb
+// Fixes bug: #6816
+static const uint16 sq1vgaSignatureUlenceFlatsGeneratorGlitch[] = {
+	SIG_MAGICDWORD, 0x1a,               // eq?
+	0x30, SIG_UINT16(0xcdf4),           // bnt absolute 0xf000
+	SIG_END
+};
+
+static const uint16 sq1vgaPatchUlenceFlatsGeneratorGlitch[] = {
+	PATCH_ADDTOOFFSET(+1),
+	0x32, PATCH_UINT16(0x0000),         // jmp 0x0000 (waste bytes)
+	PATCH_END
+};
+
+// No documentation for this patch (TODO)
 static const uint16 sq1vgaSignatureEgoShowsCard[] = {
 	SIG_MAGICDWORD,
 	0x38, SIG_SELECTOR16(timesShownID), // push "timesShownID"
@@ -2595,6 +3111,7 @@ static const uint16 sq1vgaPatchSpiderDroidTiming[] = {
 //          script, description,                                      signature                                   patch
 static const SciScriptPatcherEntry sq1vgaSignatures[] = {
 	{  true,    45, "Ulence Flats: timepod graphic glitch",        1, sq1vgaSignatureUlenceFlatsTimepodGfxGlitch, sq1vgaPatchUlenceFlatsTimepodGfxGlitch },
+	{  true,    45, "Ulence Flats: force field generator glitch",  1, sq1vgaSignatureUlenceFlatsGeneratorGlitch,  sq1vgaPatchUlenceFlatsGeneratorGlitch },
 	{  true,    58, "Sarien armory droid zapping ego first time",  1, sq1vgaSignatureEgoShowsCard,                sq1vgaPatchEgoShowsCard },
 	{  true,   704, "spider droid timing issue",                   1, sq1vgaSignatureSpiderDroidTiming,           sq1vgaPatchSpiderDroidTiming },
 	SCI_SIGNATUREENTRY_TERMINATOR
@@ -2670,6 +3187,7 @@ ScriptPatcher::ScriptPatcher() {
 		_selectorIdTable[selectorNr] = -1;
 
 	_runtimeTable = NULL;
+	_isMacSci11 = false;
 }
 
 ScriptPatcher::~ScriptPatcher() {
@@ -2678,7 +3196,7 @@ ScriptPatcher::~ScriptPatcher() {
 }
 
 // will actually patch previously found signature area
-void ScriptPatcher::applyPatch(const SciScriptPatcherEntry *patchEntry, byte *scriptData, const uint32 scriptSize, int32 signatureOffset, const bool isMacSci11) {
+void ScriptPatcher::applyPatch(const SciScriptPatcherEntry *patchEntry, byte *scriptData, const uint32 scriptSize, int32 signatureOffset) {
 	const uint16 *patchData = patchEntry->patchData;
 	byte orgData[PATCH_VALUELIMIT];
 	int32 offset = signatureOffset;
@@ -2742,7 +3260,7 @@ void ScriptPatcher::applyPatch(const SciScriptPatcherEntry *patchEntry, byte *sc
 			default:
 				byte1 = 0; byte2 = 0;
 			}
-			if (!isMacSci11) {
+			if (!_isMacSci11) {
 				scriptData[offset++] = byte1;
 				scriptData[offset++] = byte2;
 			} else {
@@ -2769,8 +3287,94 @@ void ScriptPatcher::applyPatch(const SciScriptPatcherEntry *patchEntry, byte *sc
 	}
 }
 
+bool ScriptPatcher::verifySignature(uint32 byteOffset, const uint16 *signatureData, const char *signatureDescription, const byte *scriptData, const uint32 scriptSize) {
+	uint16 sigSelector = 0;
+
+	uint16 sigWord = *signatureData;
+	while (sigWord != SIG_END) {
+		uint16 sigCommand = sigWord & SIG_COMMANDMASK;
+		uint16 sigValue = sigWord & SIG_VALUEMASK;
+		switch (sigCommand) {
+		case SIG_CODE_ADDTOOFFSET: {
+			// add value to offset
+			byteOffset += sigValue;
+			break;
+		}
+		case SIG_CODE_UINT16:
+		case SIG_CODE_SELECTOR16: {
+			if ((byteOffset + 1) < scriptSize) {
+				byte byte1;
+				byte byte2;
+
+				switch (sigCommand) {
+				case SIG_CODE_UINT16: {
+					byte1 = sigValue & SIG_BYTEMASK;
+					signatureData++; sigWord = *signatureData;
+					if (sigWord & SIG_COMMANDMASK)
+						error("Script-Patcher: signature inconsistent\nFaulty signature: '%s'", signatureDescription);
+					byte2 = sigWord & SIG_BYTEMASK;
+					break;
+				}
+				case SIG_CODE_SELECTOR16: {
+					sigSelector = _selectorIdTable[sigValue];
+					byte1 = sigSelector & 0xFF;
+					byte2 = sigSelector >> 8;
+					break;
+				}
+				default:
+					byte1 = 0; byte2 = 0;
+				}
+				if (!_isMacSci11) {
+					if ((scriptData[byteOffset] != byte1) || (scriptData[byteOffset + 1] != byte2))
+						sigWord = SIG_MISMATCH;
+				} else {
+					// SCI1.1+ on macintosh had uint16s in script in BE-order
+					if ((scriptData[byteOffset] != byte2) || (scriptData[byteOffset + 1] != byte1))
+						sigWord = SIG_MISMATCH;
+				}
+				byteOffset += 2;
+			} else {
+				sigWord = SIG_MISMATCH;
+			}
+			break;
+		}
+		case SIG_CODE_SELECTOR8: {
+			if (byteOffset < scriptSize) {
+				sigSelector = _selectorIdTable[sigValue];
+				if (sigSelector & 0xFF00)
+					error("Script-Patcher: 8 bit selector required, game uses 16 bit selector\nFaulty signature: '%s'", signatureDescription);
+				if (scriptData[byteOffset] != (sigSelector & 0xFF))
+					sigWord = SIG_MISMATCH;
+				byteOffset++;
+			} else {
+				sigWord = SIG_MISMATCH; // out of bounds
+			}
+			break;
+		}
+		case SIG_CODE_BYTE:
+			if (byteOffset < scriptSize) {
+				if (scriptData[byteOffset] != sigWord)
+					sigWord = SIG_MISMATCH;
+				byteOffset++;
+			} else {
+				sigWord = SIG_MISMATCH; // out of bounds
+			}
+		}
+
+		if (sigWord == SIG_MISMATCH)
+			break;
+
+		signatureData++;
+		sigWord = *signatureData;
+	}
+
+	if (sigWord == SIG_END) // signature fully matched?
+		return true;
+	return false;
+}
+
 // will return -1 if no match was found, otherwise an offset to the start of the signature match
-int32 ScriptPatcher::findSignature(const SciScriptPatcherEntry *patchEntry, SciScriptPatcherRuntimeEntry *runtimeEntry, const byte *scriptData, const uint32 scriptSize, const bool isMacSci11) {
+int32 ScriptPatcher::findSignature(const SciScriptPatcherEntry *patchEntry, SciScriptPatcherRuntimeEntry *runtimeEntry, const byte *scriptData, const uint32 scriptSize) {
 	if (scriptSize < 4) // we need to find a DWORD, so less than 4 bytes is not okay
 		return -1;
 
@@ -2782,89 +3386,8 @@ int32 ScriptPatcher::findSignature(const SciScriptPatcherEntry *patchEntry, SciS
 		if (magicDWord == READ_UINT32(scriptData + DWordOffset)) {
 			// magic DWORD found, check if actual signature matches
 			uint32 offset = DWordOffset + runtimeEntry->magicOffset;
-			uint32 byteOffset = offset;
-			const uint16 *signatureData = patchEntry->signatureData;
-			uint16 sigSelector = 0;
-
-			uint16 sigWord = *signatureData;
-			while (sigWord != SIG_END) {
-				uint16 sigCommand = sigWord & SIG_COMMANDMASK;
-				uint16 sigValue = sigWord & SIG_VALUEMASK;
-				switch (sigCommand) {
-				case SIG_CODE_ADDTOOFFSET: {
-					// add value to offset
-					byteOffset += sigValue;
-					break;
-				}
-				case SIG_CODE_UINT16:
-				case SIG_CODE_SELECTOR16: {
-					if ((byteOffset + 1) < scriptSize) {
-						byte byte1;
-						byte byte2;
-
-						switch (sigCommand) {
-						case SIG_CODE_UINT16: {
-							byte1 = sigValue & SIG_BYTEMASK;
-							signatureData++; sigWord = *signatureData;
-							if (sigWord & SIG_COMMANDMASK)
-								error("Script-Patcher: signature inconsistent\nFaulty patch: '%s'", patchEntry->description);
-							byte2 = sigWord & SIG_BYTEMASK;
-							break;
-						}
-						case SIG_CODE_SELECTOR16: {
-							sigSelector = _selectorIdTable[sigValue];
-							byte1 = sigSelector & 0xFF;
-							byte2 = sigSelector >> 8;
-							break;
-						}
-						default:
-							byte1 = 0; byte2 = 0;
-						}
-						if (!isMacSci11) {
-							if ((scriptData[byteOffset] != byte1) || (scriptData[byteOffset + 1] != byte2))
-								sigWord = SIG_MISMATCH;
-						} else {
-							// SCI1.1+ on macintosh had uint16s in script in BE-order
-							if ((scriptData[byteOffset] != byte2) || (scriptData[byteOffset + 1] != byte1))
-								sigWord = SIG_MISMATCH;
-						}
-						byteOffset += 2;
-					} else {
-						sigWord = SIG_MISMATCH;
-					}
-					break;
-				}
-				case SIG_CODE_SELECTOR8: {
-					if (byteOffset < scriptSize) {
-						sigSelector = _selectorIdTable[sigValue];
-						if (sigSelector & 0xFF00)
-							error("Script-Patcher: 8 bit selector required, game uses 16 bit selector\nFaulty patch: '%s'", patchEntry->description);
-						if (scriptData[byteOffset] != (sigSelector & 0xFF))
-							sigWord = SIG_MISMATCH;
-						byteOffset++;
-					} else {
-						sigWord = SIG_MISMATCH; // out of bounds
-					}
-					break;
-				}
-				case SIG_CODE_BYTE:
-					if (byteOffset < scriptSize) {
-						if (scriptData[byteOffset] != sigWord)
-							sigWord = SIG_MISMATCH;
-						byteOffset++;
-					} else {
-						sigWord = SIG_MISMATCH; // out of bounds
-					}
-				}
-
-				if (sigWord == SIG_MISMATCH)
-					break;
-
-				signatureData++;
-				sigWord = *signatureData;
-			}
 
-			if (sigWord == SIG_END) // signature fully matched?
+			if (verifySignature(offset, patchEntry->signatureData, patchEntry->description, scriptData, scriptSize))
 				return offset;
 		}
 		DWordOffset++;
@@ -2875,7 +3398,7 @@ int32 ScriptPatcher::findSignature(const SciScriptPatcherEntry *patchEntry, SciS
 
 // This method calculates the magic DWORD for each entry in the signature table
 //  and it also initializes the selector table for selectors used in the signatures/patches of the current game
-void ScriptPatcher::initSignature(const SciScriptPatcherEntry *patchTable, bool isMacSci11) {
+void ScriptPatcher::initSignature(const SciScriptPatcherEntry *patchTable) {
 	const SciScriptPatcherEntry *curEntry = patchTable;
 	SciScriptPatcherRuntimeEntry *curRuntimeEntry;
 	Selector curSelector = -1;
@@ -2943,7 +3466,7 @@ void ScriptPatcher::initSignature(const SciScriptPatcherEntry *patchTable, bool
 						curData++; curWord = *curData;
 						if (curWord & SIG_COMMANDMASK)
 							error("Script-Patcher: signature entry inconsistent\nFaulty patch: '%s'", curEntry->description);
-						if (!isMacSci11) {
+						if (!_isMacSci11) {
 							byte1 = curValue;
 							byte2 = curWord & SIG_BYTEMASK;
 						} else {
@@ -2958,7 +3481,7 @@ void ScriptPatcher::initSignature(const SciScriptPatcherEntry *patchTable, bool
 							curSelector = g_sci->getKernel()->findSelector(selectorNameTable[curValue]);
 							_selectorIdTable[curValue] = curSelector;
 						}
-						if (!isMacSci11) {
+						if (!_isMacSci11) {
 							byte1 = curSelector & 0x00FF;
 							byte2 = curSelector >> 8;
 						} else {
@@ -3120,7 +3643,7 @@ void ScriptPatcher::processScript(uint16 scriptNr, byte *scriptData, const uint3
 	}
 
 	if (signatureTable) {
-		bool isMacSci11 = (g_sci->getPlatform() == Common::kPlatformMacintosh && getSciVersion() >= SCI_VERSION_1_1);
+		_isMacSci11 = (g_sci->getPlatform() == Common::kPlatformMacintosh && getSciVersion() >= SCI_VERSION_1_1);
 
 		if (!_runtimeTable) {
 			// Abort, in case selectors are not yet initialized (happens for games w/o selector-dictionary)
@@ -3128,7 +3651,7 @@ void ScriptPatcher::processScript(uint16 scriptNr, byte *scriptData, const uint3
 				return;
 
 			// signature table needs to get initialized (Magic DWORD set, selector table set)
-			initSignature(signatureTable, isMacSci11);
+			initSignature(signatureTable);
 
 			// Do additional game-specific initialization
 			switch (gameId) {
@@ -3163,11 +3686,11 @@ void ScriptPatcher::processScript(uint16 scriptNr, byte *scriptData, const uint3
 				int32 foundOffset = 0;
 				int16 applyCount = curEntry->applyCount;
 				do {
-					foundOffset = findSignature(curEntry, curRuntimeEntry, scriptData, scriptSize, isMacSci11);
+					foundOffset = findSignature(curEntry, curRuntimeEntry, scriptData, scriptSize);
 					if (foundOffset != -1) {
 						// found, so apply the patch
 						debugC(kDebugLevelScriptPatcher, "Script-Patcher: '%s' on script %d offset %d", curEntry->description, scriptNr, foundOffset);
-						applyPatch(curEntry, scriptData, scriptSize, foundOffset, isMacSci11);
+						applyPatch(curEntry, scriptData, scriptSize, foundOffset);
 					}
 					applyCount--;
 				} while ((foundOffset != -1) && (applyCount));
diff --git a/engines/sci/engine/script_patches.h b/engines/sci/engine/script_patches.h
index 7023ef327e..d15fce321b 100644
--- a/engines/sci/engine/script_patches.h
+++ b/engines/sci/engine/script_patches.h
@@ -74,7 +74,6 @@ struct SciScriptPatcherEntry {
 	const uint16 *patchData;
 };
 
-//#define SCI_SIGNATUREENTRY_TERMINATOR { false, 0, NULL, 0, 0, 0, NULL, NULL }
 #define SCI_SIGNATUREENTRY_TERMINATOR { false, 0, NULL, 0, NULL, NULL }
 
 struct SciScriptPatcherRuntimeEntry {
@@ -92,15 +91,17 @@ public:
 	~ScriptPatcher();
 
 	void processScript(uint16 scriptNr, byte *scriptData, const uint32 scriptSize);
+	bool verifySignature(uint32 byteOffset, const uint16 *signatureData, const char *signatureDescription, const byte *scriptData, const uint32 scriptSize);
 
 private:
-	void initSignature(const SciScriptPatcherEntry *patchTable, bool isMacSci11);
+	void initSignature(const SciScriptPatcherEntry *patchTable);
 	void enablePatch(const SciScriptPatcherEntry *patchTable, const char *searchDescription);
-	int32 findSignature(const SciScriptPatcherEntry *patchEntry, SciScriptPatcherRuntimeEntry *runtimeEntry, const byte *scriptData, const uint32 scriptSize, bool isMacSci11);
-	void applyPatch(const SciScriptPatcherEntry *patchEntry, byte *scriptData, const uint32 scriptSize, int32 signatureOffset, bool isMacSci11);
+	int32 findSignature(const SciScriptPatcherEntry *patchEntry, SciScriptPatcherRuntimeEntry *runtimeEntry, const byte *scriptData, const uint32 scriptSize);
+	void applyPatch(const SciScriptPatcherEntry *patchEntry, byte *scriptData, const uint32 scriptSize, int32 signatureOffset);
 
 	Selector *_selectorIdTable;
 	SciScriptPatcherRuntimeEntry *_runtimeTable;
+	bool _isMacSci11;
 };
 
 } // End of namespace Sci
diff --git a/engines/sci/engine/state.cpp b/engines/sci/engine/state.cpp
index 527c8f0ae0..417d98e2e2 100644
--- a/engines/sci/engine/state.cpp
+++ b/engines/sci/engine/state.cpp
@@ -92,6 +92,10 @@ void EngineState::reset(bool isRestoring) {
 		abortScriptProcessing = kAbortNone;
 	}
 
+	// reset delayed restore game functionality
+	_delayedRestoreGame = false;
+	_delayedRestoreGameId = 0;
+
 	executionStackBase = 0;
 	_executionStackPosChanged = false;
 	stack_base = 0;
diff --git a/engines/sci/engine/state.h b/engines/sci/engine/state.h
index ecc8cb7dfe..e7499e66c9 100644
--- a/engines/sci/engine/state.h
+++ b/engines/sci/engine/state.h
@@ -131,6 +131,10 @@ public:
 	VirtualIndexFile *_virtualIndexFile;
 #endif
 
+	// see detection.cpp / SciEngine::loadGameState()
+	bool _delayedRestoreGame;  // boolean, that triggers delayed restore (triggered by ScummVM menu)
+	int _delayedRestoreGameId; // the saved game id, that it supposed to get restored (triggered by ScummVM menu)
+
 	uint _chosenQfGImportItem; // Remembers the item selected in QfG import rooms
 
 	bool _cursorWorkaroundActive; // Refer to GfxCursor::setPosition()
diff --git a/engines/sci/engine/vm.cpp b/engines/sci/engine/vm.cpp
index 06858540ec..6f02c96de8 100644
--- a/engines/sci/engine/vm.cpp
+++ b/engines/sci/engine/vm.cpp
@@ -358,12 +358,15 @@ static void callKernelFunc(EngineState *s, int kernelCallNr, int argc) {
 		SciTrackOriginReply originReply;
 		SciWorkaroundSolution solution = trackOriginAndFindWorkaround(0, kernelCall.workarounds, &originReply);
 		switch (solution.type) {
-		case WORKAROUND_NONE:
-			kernel->signatureDebug(kernelCall.signature, argc, argv);
-			error("[VM] k%s[%x]: signature mismatch via method %s::%s (room %d, script %d, localCall 0x%x)",
+		case WORKAROUND_NONE: {
+			Common::String signatureDetailsStr;
+			kernel->signatureDebug(signatureDetailsStr, kernelCall.signature, argc, argv);
+			error("\n%s[VM] k%s[%x]: signature mismatch in method %s::%s (room %d, script %d, localCall 0x%x)",
+				signatureDetailsStr.c_str(),
 				kernelCall.name, kernelCallNr, originReply.objectName.c_str(), originReply.methodName.c_str(),
 				s->currentRoomNumber(), originReply.scriptNr, originReply.localCallOffset);
 			break;
+			}
 		case WORKAROUND_IGNORE: // don't do kernel call, leave acc alone
 			return;
 		case WORKAROUND_STILLCALL: // call kernel anyway
@@ -408,15 +411,18 @@ static void callKernelFunc(EngineState *s, int kernelCallNr, int argc) {
 			SciWorkaroundSolution solution = trackOriginAndFindWorkaround(0, kernelSubCall.workarounds, &originReply);
 			switch (solution.type) {
 			case WORKAROUND_NONE: {
-				kernel->signatureDebug(kernelSubCall.signature, argc, argv);
+				Common::String signatureDetailsStr;
+				kernel->signatureDebug(signatureDetailsStr, kernelSubCall.signature, argc, argv);
 				int callNameLen = strlen(kernelCall.name);
 				if (strncmp(kernelCall.name, kernelSubCall.name, callNameLen) == 0) {
 					const char *subCallName = kernelSubCall.name + callNameLen;
-					error("[VM] k%s(%s): signature mismatch via method %s::%s (room %d, script %d, localCall %x)",
+					error("\n%s[VM] k%s(%s): signature mismatch in method %s::%s (room %d, script %d, localCall %x)",
+						signatureDetailsStr.c_str(),
 						kernelCall.name, subCallName, originReply.objectName.c_str(), originReply.methodName.c_str(),
 						s->currentRoomNumber(), originReply.scriptNr, originReply.localCallOffset);
 				}
-				error("[VM] k%s: signature mismatch via method %s::%s (room %d, script %d, localCall %x)",
+				error("\n%s[VM] k%s: signature mismatch in method %s::%s (room %d, script %d, localCall %x)",
+					signatureDetailsStr.c_str(),
 					kernelSubCall.name, originReply.objectName.c_str(), originReply.methodName.c_str(),
 					s->currentRoomNumber(), originReply.scriptNr, originReply.localCallOffset);
 				break;
diff --git a/engines/sci/engine/workarounds.cpp b/engines/sci/engine/workarounds.cpp
index c5730b5345..aab32032f7 100644
--- a/engines/sci/engine/workarounds.cpp
+++ b/engines/sci/engine/workarounds.cpp
@@ -24,426 +24,716 @@
 #include "sci/engine/object.h"
 #include "sci/engine/state.h"
 #include "sci/engine/vm.h"
+#include "sci/engine/script_patches.h"
 #include "sci/engine/workarounds.h"
 
-#define SCI_WORKAROUNDENTRY_TERMINATOR { (SciGameId)0, -1, -1, 0, NULL, NULL, -1, 0, { WORKAROUND_NONE, 0 } }
+#define SCI_WORKAROUNDENTRY_TERMINATOR { (SciGameId)0, -1, -1, 0, NULL, NULL, NULL, 0, { WORKAROUND_NONE, 0 } }
 
 namespace Sci {
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,             workaround
+// Attention:
+//  To identify local-call-subroutines code signatures are used.
+//   Offsets change a lot between different versions of games, especially between different language releases.
+//   That's why it isn't good to hardcode the offsets of those subroutines.
+//
+//  Those signatures are just like the script patcher signatures (for further study: engine\script_patches.cpp)
+//   However you may NOT use command SIG_SELECTOR8 nor SIG_SELECTOR16 atm. Proper support for those may be added later.
+
+//                Game: Conquests of Camelot
+//      Calling method: endingCartoon2::changeState
+//   Subroutine offset: English 0x020d (script 92)
+// Applies to at least: English PC floppy
+static const uint16 sig_arithmetic_camelot_1[] = {
+	0x83, 0x32,                      // lal local[32h]
+	0x30, SIG_UINT16(0x001d),        // bnt [...]
+	0x7a,                            // push2
+	0x39, 0x08,                      // pushi 08
+	0x36,                            // push
+	0x43,                            // callk Graph
+	SIG_END
+};
+
+//                Game: Eco Quest 2
+//      Calling method: Rain::points
+//   Subroutine offset: English 0x0cc6, French/Spanish 0x0ce0 (script 0)
+// Applies to at least: English/French/Spanish PC floppy
+static const uint16 sig_arithmetic_ecoq2_1[] = {
+	0x8f, 0x01,                      // lsp param[1]
+	0x35, 0x10,                      // ldi 10h
+	0x08,                            // div
+	0x99, 0x6e,                      // lsgi global[6Eh]
+	0x38, SIG_UINT16(0x8000),        // pushi 8000h
+	0x8f, 0x01,                      // lsp param[1]
+	0x35, 0x10,                      // ldi 10h
+	0x0a,                            // mod
+	0x0c,                            // shr
+	0x14,                            // or
+	0x36,                            // push
+	SIG_END
+};
+
+//    gameID,           room,script,lvl,          object-name, method-name,       local-call-signature, index,             workaround
 const SciWorkaroundEntry arithmeticWorkarounds[] = {
-	{ GID_CAMELOT,         92,   92,  0,     "endingCartoon2", "changeState", 0x20d,    0, { WORKAROUND_FAKE,   0 } }, // op_lai: during the ending, sub gets called with no parameters, uses parameter 1 which is theGrail in this case - bug #5237
-	{ GID_ECOQUEST2,      100,    0,  0,               "Rain", "points",      0xcc6,    0, { WORKAROUND_FAKE,   0 } }, // op_or: when giving the papers to the customs officer, gets called against a pointer instead of a number - bug #4939
-	{ GID_ECOQUEST2,      100,    0,  0,               "Rain", "points",      0xce0,    0, { WORKAROUND_FAKE,   0 } }, // Same as above, for the Spanish version - bug #5750
-	{ GID_FANMADE,        516,  983,  0,             "Wander", "setTarget",      -1,    0, { WORKAROUND_FAKE,   0 } }, // op_mul: The Legend of the Lost Jewel Demo (fan made): called with object as second parameter when attacked by insects - bug #5124
-	{ GID_GK1,            800,64992,  0,                "Fwd", "doit",           -1,    0, { WORKAROUND_FAKE,   1 } }, // op_gt: when Mosely finds Gabriel and Grace near the end of the game, compares the Grooper object with 7
-	{ GID_HOYLE4,         700,   -1,  1,               "Code", "doit",           -1,    0, { WORKAROUND_FAKE,   1 } }, // op_add: while bidding in Bridge, an object ("Bid") is added to an object in another segment ("hand3")
-	{ GID_ICEMAN,         199,  977,  0,            "Grooper", "doit",           -1,    0, { WORKAROUND_FAKE,   0 } }, // op_add: While dancing with the girl
-	{ GID_MOTHERGOOSE256,  -1,  999,  0,              "Event", "new",            -1,    0, { WORKAROUND_FAKE,   0 } }, // op_and: constantly during the game (SCI1 version)
-	{ GID_MOTHERGOOSE256,  -1,    4,  0,              "rm004", "doit",           -1,    0, { WORKAROUND_FAKE,   0 } }, // op_or: when going north and reaching the castle (rooms 4 and 37) - bug #5101
-	{ GID_MOTHERGOOSEHIRES,90,   90,  0,      "newGameButton", "select",         -1,    0, { WORKAROUND_FAKE,   0 } }, // op_ge: MUMG Deluxe, when selecting "New Game" in the main menu. It tries to compare an integer with a list. Needs to return false for the game to continue.
-	{ GID_PHANTASMAGORIA, 902,    0,  0,                   "", "export 7",       -1,    0, { WORKAROUND_FAKE,   0 } }, // op_shr: when starting a chapter in Phantasmagoria
-	{ GID_QFG1VGA,        301,  928,  0,              "Blink", "init",           -1,    0, { WORKAROUND_FAKE,   0 } }, // op_div: when entering the inn, gets called with 1 parameter, but 2nd parameter is used for div which happens to be an object
-	{ GID_QFG2,           200,  200,  0,              "astro", "messages",       -1,    0, { WORKAROUND_FAKE,   0 } }, // op_lsi: when getting asked for your name by the astrologer - bug #5152
-	{ GID_QFG3,           780,  999,  0,                   "", "export 6",       -1,    0, { WORKAROUND_FAKE,   0 } }, // op_add: trying to talk to yourself at the top of the giant tree - bug #6692
-	{ GID_QFG4,           710,64941,  0,          "RandCycle", "doit",           -1,    0, { WORKAROUND_FAKE,   1 } }, // op_gt: when the tentacle appears in the third room of the caves
-	SCI_WORKAROUNDENTRY_TERMINATOR
-};
-
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,  workaround
+	{ GID_CAMELOT,         92,   92,  0,     "endingCartoon2", "changeState", sig_arithmetic_camelot_1,     0, { WORKAROUND_FAKE,   0 } }, // op_lai: during the ending, sub gets called with no parameters, uses parameter 1 which is theGrail in this case - bug #5237
+	{ GID_ECOQUEST2,      100,    0,  0,               "Rain", "points",        sig_arithmetic_ecoq2_1,     0, { WORKAROUND_FAKE,   0 } }, // op_or: when giving the papers to the customs officer, gets called against a pointer instead of a number - bug #4939, Spanish version - bug #5750
+	{ GID_FANMADE,        516,  983,  0,             "Wander", "setTarget",                       NULL,     0, { WORKAROUND_FAKE,   0 } }, // op_mul: The Legend of the Lost Jewel Demo (fan made): called with object as second parameter when attacked by insects - bug #5124
+	{ GID_GK1,            800,64992,  0,                "Fwd", "doit",                            NULL,     0, { WORKAROUND_FAKE,   1 } }, // op_gt: when Mosely finds Gabriel and Grace near the end of the game, compares the Grooper object with 7
+	{ GID_HOYLE4,         700,   -1,  1,               "Code", "doit",                            NULL,     0, { WORKAROUND_FAKE,   1 } }, // op_add: while bidding in Bridge, an object ("Bid") is added to an object in another segment ("hand3")
+	{ GID_ICEMAN,         199,  977,  0,            "Grooper", "doit",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // op_add: While dancing with the girl
+	{ GID_MOTHERGOOSE256,  -1,  999,  0,              "Event", "new",                             NULL,     0, { WORKAROUND_FAKE,   0 } }, // op_and: constantly during the game (SCI1 version)
+	{ GID_MOTHERGOOSE256,  -1,    4,  0,              "rm004", "doit",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // op_or: when going north and reaching the castle (rooms 4 and 37) - bug #5101
+	{ GID_MOTHERGOOSEHIRES,90,   90,  0,      "newGameButton", "select",                          NULL,     0, { WORKAROUND_FAKE,   0 } }, // op_ge: MUMG Deluxe, when selecting "New Game" in the main menu. It tries to compare an integer with a list. Needs to return false for the game to continue.
+	{ GID_PHANTASMAGORIA, 902,    0,  0,                   "", "export 7",                        NULL,     0, { WORKAROUND_FAKE,   0 } }, // op_shr: when starting a chapter in Phantasmagoria
+	{ GID_QFG1VGA,        301,  928,  0,              "Blink", "init",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // op_div: when entering the inn, gets called with 1 parameter, but 2nd parameter is used for div which happens to be an object
+	{ GID_QFG2,           200,  200,  0,              "astro", "messages",                        NULL,     0, { WORKAROUND_FAKE,   0 } }, // op_lsi: when getting asked for your name by the astrologer - bug #5152
+	{ GID_QFG3,           780,  999,  0,                   "", "export 6",                        NULL,     0, { WORKAROUND_FAKE,   0 } }, // op_add: trying to talk to yourself at the top of the giant tree - bug #6692
+	{ GID_QFG4,           710,64941,  0,          "RandCycle", "doit",                            NULL,     0, { WORKAROUND_FAKE,   1 } }, // op_gt: when the tentacle appears in the third room of the caves
+	SCI_WORKAROUNDENTRY_TERMINATOR
+};
+
+//                Game: Fan-Made "Ocean Battle"
+//      Calling method: RoomScript::doit
+//   Subroutine offset: 0x1f17
+// Applies to at least: Ocean Battle
+static const uint16 sig_uninitread_fanmade_1[] = {
+	0x3f, 0x04,                      // link 04
+	0x88, SIG_UINT16(0x023b),        // lsg global[23Bh]
+	SIG_END
+};
+
+//                Game: Hoyle 1
+//      Calling method: export 0
+//   Subroutine offset: 0x037c (script 16)
+// Applies to at least: English PC floppy
+static const uint16 sig_uninitread_hoyle1_1[] = {
+	0x3f, 0x05,                      // link 05
+	0x78,                            // push1
+	0x76,                            // push0
+	0x40,                            // call [...]
+	SIG_END
+};
+
+//                Game: Hoyle 4
+//      Calling method: export 2
+//   Subroutine offset: 0x1d4d (script 300)
+// Applies to at least: English PC floppy
+static const uint16 sig_uninitread_hoyle4_1[] = {
+	0x3f, 0x01,                      // link 01
+	0x39, 0x40,                      // pushi 40h
+	0x78,                            // push1
+	SIG_END
+};
+
+//                Game: Jones in the fast lane
+//      Calling method: weekendText::draw
+//   Subroutine offset: 0x03d3 (script 232)
+// Applies to at least: English PC CD
+static const uint16 sig_uninitread_jones_1[] = {
+	0x3f, 0x02,                      // link 02
+	0x8d, 0x00,                      // lst temp[0]
+	0x35, 0x01,                      // ldi 01
+	0x22,                            // lt?
+	SIG_END
+};
+
+//                Game: Conquests of the Longbow
+//      Calling method: letter::handleEvent
+//   Subroutine offset: English PC/Amiga 0x00a8 (script 213)
+// Applies to at least: English PC floppy, English Amiga floppy
+static const uint16 sig_uninitread_longbow_1[] = {
+	0x3f, 0x02,                      // link 02
+	0x35, 0x00,                      // ldi 00
+	0xa5, 0x00,                      // sat temp[0]
+	0x8d, 0x00,                      // lst temp[0]
+	SIG_END
+};
+
+//                Game: Quest for Glory 1 / Hero's Quest 1
+//      Calling method: Encounter::init
+//   Subroutine offset: English Hero's Quest 0x0bd0, English Quest for Glory 1 0x0be4 (script 210)
+// Applies to at least: English PC floppy (Hero's Quest, Quest For Glory 1), Japanese PC-9801 floppy
+static const uint16 sig_uninitread_qfg1_1[] = {
+	0x3f, 0x02,                      // link 02
+	0x87, 0x00,                      // lap param[0]
+	0x30, SIG_UINT16(0x000c),        // bnt [...]
+	0x87, 0x01,                      // lap param[1]
+	0x30, SIG_UINT16(0x0007),        // bnt [...]
+	0x87, 0x01,                      // lap param[1]
+	0xa5, 0x01,                      // sat temp[1]
+	SIG_END
+};
+
+//                Game: Quest for Glory 1 VGA
+//      Calling method: Encounter::init
+//   Subroutine offset: English w/o patch 0x0cee, w/ patch 0x0ce7 (script 210)
+// Applies to at least: English PC floppy
+static const uint16 sig_uninitread_qfg1vga_1[] = {
+	0x3f, 0x02,                      // link 02
+	0x87, 0x00,                      // lap param[0]
+	0x31, 0x0b,                      // bnt [...]
+	0x87, 0x01,                      // lap param[1]
+	0x31, 0x07,                      // bnt [...]
+	0x87, 0x01,                      // lap param[1]
+	0xa5, 0x01,                      // sat temp[1]
+	// following jump is different for patched and unpatched game
+	SIG_END
+};
+
+//                Game: Quest for Glory 2
+//      Calling method: abdulS::changeState, jabbarS::changeState
+//   Subroutine offset: English 0x2d22 (script 260)
+// Applies to at least: English PC floppy
+static const uint16 sig_uninitread_qfg2_1[] = {
+	0x3f, 0x03,                      // link 03
+	0x39, 0x3b,                      // pushi 3Bh
+	0x76,                            // push0
+	0x81, 0x00,                      // lag global[0]
+	0x4a, 0x04,                      // send 04
+	SIG_END
+};
+
+//                Game: Quest for Glory 3
+//      Calling method: rm140::init
+//   Subroutine offset: English 0x1008 (script 140)
+// Applies to at least: English, French, German, Italian, Spanish PC floppy
+static const uint16 sig_uninitread_qfg3_1[] = {
+	0x3f, 0x01,                      // link 01
+	0x89, 0x7d,                      // lsg global[7Dh]
+	0x35, 0x03,                      // ldi 03
+	SIG_END
+};
+
+//                Game: Quest for Glory 3
+//      Calling method: computersMove::changeState
+//   Subroutine offset: English/etc. 0x0f53 (script 490)
+// Applies to at least: English, French, German, Italian, Spanish PC floppy
+static const uint16 sig_uninitread_qfg3_2[] = {
+	0x3f, 0x1d,                      // link 1Dh
+	0x35, 0x01,                      // ldi 01
+	0xa5, 0x18,                      // sat temp[18h]
+	0x35, 0xce,                      // ldi CEh
+	0xa5, 0x19,                      // sat temp[19h]
+	0x35, 0x00,                      // ldi 00
+	0xa5, 0x00,                      // sat temp[0]
+	SIG_END
+};
+
+//                Game: Space Quest 1
+//      Calling method: firePulsar::changeState
+//   Subroutine offset: English 0x018a (script 703)
+// Applies to at least: English PC floppy, English Amiga floppy
+static const uint16 sig_uninitread_sq1_1[] = {
+	0x3f, 0x01,                      // link 01
+	0x38, SIG_ADDTOOFFSET(+2),       // pushi 0242 (selector egoStatus)
+	0x76,                            // push0
+	0x72, SIG_ADDTOOFFSET(+2),       // lofsa DeltaurRegion
+	0x4a, 0x04,                      // send 04
+	SIG_END
+};
+
+//    gameID,           room,script,lvl,          object-name, method-name,       local-call-signature, index,  workaround
 const SciWorkaroundEntry uninitializedReadWorkarounds[] = {
-	{ GID_CAMELOT,        40,    40,  0,               "Rm40", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // when looking at the ground at the pool of Siloam - bug #6401
-	{ GID_CASTLEBRAIN,   280,   280,  0,         "programmer", "dispatchEvent",  -1,    0, { WORKAROUND_FAKE, 0xf } }, // pressing 'q' on the computer screen in the robot room, and closing the help dialog that pops up (bug #5143). Moves the cursor to the view with the ID returned (in this case, the robot hand)
-	{ GID_CNICK_KQ,       -1,     0,  1,          "Character", "say",            -1,   -1, { WORKAROUND_FAKE,   0 } }, // checkers/backgammon, like in hoyle 3 - temps 504 and 505 - bug #6255
-	{ GID_CNICK_KQ,       -1,   700,  0,           "gcWindow", "open",           -1,   -1, { WORKAROUND_FAKE,   0 } }, // when entering the control menu, like in hoyle 3
-	{ GID_CNICK_KQ,      300,   303,  0,      "theDoubleCube", "<noname520>",    -1,    5, { WORKAROUND_FAKE,   0 } }, // while playing backgammon with doubling enabled - bug #6426 (same as the theDoubleCube::make workaround for Hoyle 3)
-	{ GID_CNICK_KQ,      300,   303,  0,      "theDoubleCube", "<noname519>",    -1,    9, { WORKAROUND_FAKE,   0 } }, // when accepting a double, while playing backgammon with doubling enabled (same as the theDoubleCube::accept workaround for Hoyle 3)
-	{ GID_CNICK_LAURABOW, -1,     0,  1,          "Character", "say",            -1,   -1, { WORKAROUND_FAKE,   0 } }, // Yatch, like in hoyle 3 - temps 504 and 505 - bug #6424
-	{ GID_CNICK_LAURABOW, -1,   700,  0,                 NULL, "open",           -1,   -1, { WORKAROUND_FAKE,   0 } }, // when entering control menu - bug #6423 (same as the gcWindow workaround for Hoyle 3)
-	{ GID_CNICK_LAURABOW,100,   100,  0,                 NULL, "<noname144>",    -1,    1, { WORKAROUND_FAKE,   0 } }, // while playing domino - bug #6429 (same as the dominoHand2 workaround for Hoyle 3)
-	{ GID_CNICK_LAURABOW,100,   110,  0,                 NULL, "doit",           -1,   -1, { WORKAROUND_FAKE,   0 } }, // when changing the "Dominoes per hand" setting - bug #6430
-	{ GID_CNICK_LONGBOW,   0,     0,  0,          "RH Budget", "init",           -1,    1, { WORKAROUND_FAKE,   0 } }, // when starting the game
-	{ GID_ECOQUEST,       -1,    -1,  0,                 NULL, "doVerb",         -1,    0, { WORKAROUND_FAKE,   0 } }, // almost clicking anywhere triggers this in almost all rooms
-	{ GID_FANMADE,       516,   979,  0,                   "", "export 0",       -1,   20, { WORKAROUND_FAKE,   0 } }, // Happens in Grotesteing after the logos
-	{ GID_FANMADE,       528,   990,  0,            "GDialog", "doit",           -1,    4, { WORKAROUND_FAKE,   0 } }, // Happens in Cascade Quest when closing the glossary - bug #5116
-	{ GID_FANMADE,       488,     1,  0,         "RoomScript", "doit",       0x1f17,    1, { WORKAROUND_FAKE,   0 } }, // Happens in Ocean Battle while playing - bug #5335
-	{ GID_FREDDYPHARKAS,  -1,    24,  0,              "gcWin", "open",           -1,    5, { WORKAROUND_FAKE, 0xf } }, // is used as priority for game menu
-	{ GID_FREDDYPHARKAS,  -1,    31,  0,            "quitWin", "open",           -1,    5, { WORKAROUND_FAKE, 0xf } }, // is used as priority for game menu
-	{ GID_FREDDYPHARKAS, 540,   540,  0,          "WaverCode", "init",           -1,   -1, { WORKAROUND_FAKE,   0 } }, // Gun pratice mini-game - bug #5232
-	{ GID_GK1,            -1, 64950, -1,            "Feature", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // sometimes when walk-clicking
-	{ GID_GK2,            -1,    11,  0,                   "", "export 10",      -1,    3, { WORKAROUND_FAKE,   0 } }, // called when the game starts
-	{ GID_GK2,            -1,    11,  0,                   "", "export 10",      -1,    4, { WORKAROUND_FAKE,   0 } }, // called during the game
-	{ GID_HOYLE1,          4,   104,  0,   "GinRummyCardList", "calcRuns",       -1,    4, { WORKAROUND_FAKE,   0 } }, // Gin Rummy / right when the game starts
-	{ GID_HOYLE1,          5,   204,  0,            "tableau", "checkRuns",      -1,    2, { WORKAROUND_FAKE,   0 } }, // Cribbage / during the game
-	{ GID_HOYLE1,          3,    16,  0,                   "", "export 0",    0x37c,    3, { WORKAROUND_FAKE,   0 } }, // Hearts / during the game - bug #5299
-	{ GID_HOYLE1,         -1,   997,  0,            "MenuBar", "doit",           -1,    0, { WORKAROUND_FAKE,   0 } }, // When changing game speed settings - bug #5512
-	{ GID_HOYLE3,         -1,     0,  1,          "Character", "say",            -1,   -1, { WORKAROUND_FAKE,   0 } }, // when starting checkers or dominoes, first time a character says something - temps 504 and 505
-	{ GID_HOYLE3,         -1,   700,  0,           "gcWindow", "open",           -1,   -1, { WORKAROUND_FAKE,   0 } }, // when entering control menu
-	{ GID_HOYLE3,        100,   100,  0,        "dominoHand2", "cue",            -1,    1, { WORKAROUND_FAKE,   0 } }, // while playing domino - bug #5042
-	{ GID_HOYLE3,        100,   110,  0,           "OKButton", "doit",           -1,   -1, { WORKAROUND_FAKE,   0 } }, // when changing the "Dominoes per hand" setting - bug #6430
-	{ GID_HOYLE3,        300,   303,  0,      "theDoubleCube", "make",           -1,    5, { WORKAROUND_FAKE,   0 } }, // while playing backgammon with doubling enabled
-	{ GID_HOYLE3,        300,   303,  0,      "theDoubleCube", "accept",         -1,    9, { WORKAROUND_FAKE,   0 } }, // when accepting a double, while playing backgammon with doubling enabled
-	{ GID_HOYLE4,         -1,     0,  0,                 NULL, "open",           -1,   -1, { WORKAROUND_FAKE,   0 } }, // when selecting "Control" from the menu (temp vars 0-3) - bug #5132
-	{ GID_HOYLE4,        910,    18,  0,                 NULL, "init",           -1,    0, { WORKAROUND_FAKE,   0 } }, // during tutorial - bug #5213
-	{ GID_HOYLE4,        910,   910,  0,                 NULL, "setup",          -1,    3, { WORKAROUND_FAKE,   0 } }, // when selecting "Tutorial" from the main menu - bug #5132
-	{ GID_HOYLE4,        700,   700,  1,         "BridgeHand", "calcQTS",        -1,    3, { WORKAROUND_FAKE,   0 } }, // when placing a bid in bridge (always)
-	{ GID_HOYLE4,        700,   710,  1, "BridgeStrategyPlay", "checkSplitTops", -1,   10, { WORKAROUND_FAKE,   0 } }, // while playing bridge, objects LeadReturn_Trump, SecondSeat_Trump, ThirdSeat_Trump and others - bug #5794
-	{ GID_HOYLE4,        700,    -1,  1,      "BridgeDefense", "think",          -1,   -1, { WORKAROUND_FAKE,   0 } }, // sometimes while playing bridge, temp var 3, 17 and others, objects LeadReturn_Trump, ThirdSeat_Trump and others
-	{ GID_HOYLE4,        700,   730,  1,      "BridgeDefense", "beatTheirBest",  -1,    3, { WORKAROUND_FAKE,   0 } }, // rarely while playing bridge
-	{ GID_HOYLE4,        700,    -1,  1,               "Code", "doit",           -1,   -1, { WORKAROUND_FAKE,   0 } }, // when placing a bid in bridge (always), temp var 11, 24, 27, 46, 75, objects compete_tree, compwe_tree, other1_tree, b1 - bugs #5663 and #5794
-	{ GID_HOYLE4,        700,   921,  0,              "Print", "addEdit",        -1,    0, { WORKAROUND_FAKE, 118 } }, // when saving the game (may also occur in other situations) - bug #6601, bug #6614
-	{ GID_HOYLE4,        700,   921,  0,              "Print", "addEdit",        -1,    1, { WORKAROUND_FAKE,   1 } }, // see above, Text-control saves its coordinates to temp[0] and temp[1], Edit-control adjusts to those uninitialized temps, who by accident were left over from the Text-control
-	{ GID_HOYLE4,        300,   300,  0,                   "", "export 2",   0x1d4d,    0, { WORKAROUND_FAKE,   0 } }, // after passing around cards in hearts
-	{ GID_HOYLE4,        400,   400,  1,            "GinHand", "calcRuns",       -1,    4, { WORKAROUND_FAKE,   0 } }, // sometimes while playing Gin Rummy (e.g. when knocking and placing a card) - bug #5665
-	{ GID_HOYLE4,        500,    17,  1,          "Character", "say",            -1,  504, { WORKAROUND_FAKE,   0 } }, // sometimes while playing Cribbage (e.g. when the opponent says "Last Card") - bug #5662
-	{ GID_HOYLE4,         -1,   937,  0,            "IconBar", "dispatchEvent",  -1,  408, { WORKAROUND_FAKE,   0 } }, // pressing ENTER on scoreboard while mouse is not on OK button, may not happen all the time - bug #6603
-	{ GID_ISLANDBRAIN,   100,   937,  0,            "IconBar", "dispatchEvent",  -1,   58, { WORKAROUND_FAKE,   0 } }, // when using ENTER at the startup menu - bug #5241
-	{ GID_ISLANDBRAIN,   140,   140,  0,              "piece", "init",           -1,    3, { WORKAROUND_FAKE,   1 } }, // first puzzle right at the start, some initialization variable. bnt is done on it, and it should be non-0
-	{ GID_ISLANDBRAIN,   200,   268,  0,          "anElement", "select",         -1,    0, { WORKAROUND_FAKE,   0 } }, // elements puzzle, gets used before super TextIcon
-	{ GID_JONES,           1,   232,  0,        "weekendText", "draw",        0x3d3,    0, { WORKAROUND_FAKE,   0 } }, // jones/cd only - gets called during the game
-	{ GID_JONES,           1,   255,  0,                   "", "export 0",       -1,   -1, { WORKAROUND_FAKE,   0 } }, // jones/cd only - called when a game ends, temps 13 and 14
-	{ GID_JONES,         764,   255,  0,                   "", "export 0",       -1,   -1, { WORKAROUND_FAKE,   0 } }, // jones/ega&vga only - called when the game starts, temps 13 and 14
-	//{ GID_KQ5,            -1,     0,  0,                   "", "export 29",      -1,    3, { WORKAROUND_FAKE,   0xf } }, // called when playing harp for the harpies or when aborting dialog in toy shop, is used for kDoAudio - bug #4961
+	{ GID_CAMELOT,        40,    40,  0,               "Rm40", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // when looking at the ground at the pool of Siloam - bug #6401
+	{ GID_CASTLEBRAIN,   280,   280,  0,         "programmer", "dispatchEvent",                   NULL,     0, { WORKAROUND_FAKE, 0xf } }, // pressing 'q' on the computer screen in the robot room, and closing the help dialog that pops up (bug #5143). Moves the cursor to the view with the ID returned (in this case, the robot hand)
+	{ GID_CNICK_KQ,       -1,     0,  1,          "Character", "say",                             NULL,    -1, { WORKAROUND_FAKE,   0 } }, // checkers/backgammon, like in hoyle 3 - temps 504 and 505 - bug #6255
+	{ GID_CNICK_KQ,       -1,   700,  0,           "gcWindow", "open",                            NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when entering the control menu, like in hoyle 3
+	{ GID_CNICK_KQ,      300,   303,  0,      "theDoubleCube", "<noname520>",                     NULL,     5, { WORKAROUND_FAKE,   0 } }, // while playing backgammon with doubling enabled - bug #6426 (same as the theDoubleCube::make workaround for Hoyle 3)
+	{ GID_CNICK_KQ,      300,   303,  0,      "theDoubleCube", "<noname519>",                     NULL,     9, { WORKAROUND_FAKE,   0 } }, // when accepting a double, while playing backgammon with doubling enabled (same as the theDoubleCube::accept workaround for Hoyle 3)
+	{ GID_CNICK_LAURABOW, -1,     0,  1,          "Character", "say",                             NULL,    -1, { WORKAROUND_FAKE,   0 } }, // Yatch, like in hoyle 3 - temps 504 and 505 - bug #6424
+	{ GID_CNICK_LAURABOW, -1,   700,  0,                 NULL, "open",                            NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when entering control menu - bug #6423 (same as the gcWindow workaround for Hoyle 3)
+	{ GID_CNICK_LAURABOW,100,   100,  0,                 NULL, "<noname144>",                     NULL,     1, { WORKAROUND_FAKE,   0 } }, // while playing domino - bug #6429 (same as the dominoHand2 workaround for Hoyle 3)
+	{ GID_CNICK_LAURABOW,100,   110,  0,                 NULL, "doit",                            NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when changing the "Dominoes per hand" setting - bug #6430
+	{ GID_CNICK_LONGBOW,   0,     0,  0,          "RH Budget", "init",                            NULL,     1, { WORKAROUND_FAKE,   0 } }, // when starting the game
+	{ GID_ECOQUEST,       -1,    -1,  0,                 NULL, "doVerb",                          NULL,     0, { WORKAROUND_FAKE,   0 } }, // almost clicking anywhere triggers this in almost all rooms
+	{ GID_FANMADE,       516,   979,  0,                   "", "export 0",                        NULL,    20, { WORKAROUND_FAKE,   0 } }, // Happens in Grotesteing after the logos
+	{ GID_FANMADE,       528,   990,  0,            "GDialog", "doit",                            NULL,     4, { WORKAROUND_FAKE,   0 } }, // Happens in Cascade Quest when closing the glossary - bug #5116
+	{ GID_FANMADE,       488,     1,  0,         "RoomScript", "doit",        sig_uninitread_fanmade_1,     1, { WORKAROUND_FAKE,   0 } }, // Happens in Ocean Battle while playing - bug #5335
+	{ GID_FREDDYPHARKAS,  -1,    24,  0,              "gcWin", "open",                            NULL,     5, { WORKAROUND_FAKE, 0xf } }, // is used as priority for game menu
+	{ GID_FREDDYPHARKAS,  -1,    31,  0,            "quitWin", "open",                            NULL,     5, { WORKAROUND_FAKE, 0xf } }, // is used as priority for game menu
+	{ GID_FREDDYPHARKAS, 540,   540,  0,          "WaverCode", "init",                            NULL,    -1, { WORKAROUND_FAKE,   0 } }, // Gun pratice mini-game - bug #5232
+	{ GID_GK1,            -1, 64950, -1,            "Feature", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // sometimes when walk-clicking
+	{ GID_GK2,            -1,    11,  0,                   "", "export 10",                       NULL,     3, { WORKAROUND_FAKE,   0 } }, // called when the game starts
+	{ GID_GK2,            -1,    11,  0,                   "", "export 10",                       NULL,     4, { WORKAROUND_FAKE,   0 } }, // called during the game
+	{ GID_HOYLE1,          4,   104,  0,   "GinRummyCardList", "calcRuns",                        NULL,     4, { WORKAROUND_FAKE,   0 } }, // Gin Rummy / right when the game starts
+	{ GID_HOYLE1,          5,   204,  0,            "tableau", "checkRuns",                       NULL,     2, { WORKAROUND_FAKE,   0 } }, // Cribbage / during the game
+	{ GID_HOYLE1,          3,    16,  0,                   "", "export 0",     sig_uninitread_hoyle1_1,     3, { WORKAROUND_FAKE,   0 } }, // Hearts / during the game - bug #5299
+	{ GID_HOYLE1,         -1,   997,  0,            "MenuBar", "doit",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // When changing game speed settings - bug #5512
+	{ GID_HOYLE3,         -1,     0,  1,          "Character", "say",                             NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when starting checkers or dominoes, first time a character says something - temps 504 and 505
+	{ GID_HOYLE3,         -1,   700,  0,           "gcWindow", "open",                            NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when entering control menu
+	{ GID_HOYLE3,        100,   100,  0,        "dominoHand2", "cue",                             NULL,     1, { WORKAROUND_FAKE,   0 } }, // while playing domino - bug #5042
+	{ GID_HOYLE3,        100,   110,  0,           "OKButton", "doit",                            NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when changing the "Dominoes per hand" setting - bug #6430
+	{ GID_HOYLE3,        300,   303,  0,      "theDoubleCube", "make",                            NULL,     5, { WORKAROUND_FAKE,   0 } }, // while playing backgammon with doubling enabled
+	{ GID_HOYLE3,        300,   303,  0,      "theDoubleCube", "accept",                          NULL,     9, { WORKAROUND_FAKE,   0 } }, // when accepting a double, while playing backgammon with doubling enabled
+	{ GID_HOYLE4,         -1,     0,  0,                 NULL, "open",                            NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when selecting "Control" from the menu (temp vars 0-3) - bug #5132
+	{ GID_HOYLE4,        910,    18,  0,                 NULL, "init",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // during tutorial - bug #5213
+	{ GID_HOYLE4,        910,   910,  0,                 NULL, "setup",                           NULL,     3, { WORKAROUND_FAKE,   0 } }, // when selecting "Tutorial" from the main menu - bug #5132
+	{ GID_HOYLE4,        700,   700,  1,         "BridgeHand", "calcQTS",                         NULL,     3, { WORKAROUND_FAKE,   0 } }, // when placing a bid in bridge (always)
+	{ GID_HOYLE4,        700,   710,  1, "BridgeStrategyPlay", "checkSplitTops",                  NULL,    10, { WORKAROUND_FAKE,   0 } }, // while playing bridge, objects LeadReturn_Trump, SecondSeat_Trump, ThirdSeat_Trump and others - bug #5794
+	{ GID_HOYLE4,        700,    -1,  1,      "BridgeDefense", "think",                           NULL,    -1, { WORKAROUND_FAKE,   0 } }, // sometimes while playing bridge, temp var 3, 17 and others, objects LeadReturn_Trump, ThirdSeat_Trump and others
+	{ GID_HOYLE4,        700,   730,  1,      "BridgeDefense", "beatTheirBest",                   NULL,     3, { WORKAROUND_FAKE,   0 } }, // rarely while playing bridge
+	{ GID_HOYLE4,        700,    -1,  1,               "Code", "doit",                            NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when placing a bid in bridge (always), temp var 11, 24, 27, 46, 75, objects compete_tree, compwe_tree, other1_tree, b1 - bugs #5663 and #5794
+	{ GID_HOYLE4,        700,   921,  0,              "Print", "addEdit",                         NULL,     0, { WORKAROUND_FAKE, 118 } }, // when saving the game (may also occur in other situations) - bug #6601, bug #6614
+	{ GID_HOYLE4,        700,   921,  0,              "Print", "addEdit",                         NULL,     1, { WORKAROUND_FAKE,   1 } }, // see above, Text-control saves its coordinates to temp[0] and temp[1], Edit-control adjusts to those uninitialized temps, who by accident were left over from the Text-control
+	{ GID_HOYLE4,        300,   300,  0,                   "", "export 2",     sig_uninitread_hoyle4_1,     0, { WORKAROUND_FAKE,   0 } }, // after passing around cards in hearts
+	{ GID_HOYLE4,        400,   400,  1,            "GinHand", "calcRuns",                        NULL,     4, { WORKAROUND_FAKE,   0 } }, // sometimes while playing Gin Rummy (e.g. when knocking and placing a card) - bug #5665
+	{ GID_HOYLE4,        500,    17,  1,          "Character", "say",                             NULL,   504, { WORKAROUND_FAKE,   0 } }, // sometimes while playing Cribbage (e.g. when the opponent says "Last Card") - bug #5662
+	{ GID_HOYLE4,        800,   870,  0,     "EuchreStrategy", "thinkLead",                       NULL,     0, { WORKAROUND_FAKE,   0 } }, // while playing Euchre, happens at least on 2nd or 3rd turn - bug #6602
+	{ GID_HOYLE4,         -1,   937,  0,            "IconBar", "dispatchEvent",                   NULL,   408, { WORKAROUND_FAKE,   0 } }, // pressing ENTER on scoreboard while mouse is not on OK button, may not happen all the time - bug #6603
+	{ GID_ISLANDBRAIN,   100,   937,  0,            "IconBar", "dispatchEvent",                   NULL,    58, { WORKAROUND_FAKE,   0 } }, // when using ENTER at the startup menu - bug #5241
+	{ GID_ISLANDBRAIN,   140,   140,  0,              "piece", "init",                            NULL,     3, { WORKAROUND_FAKE,   1 } }, // first puzzle right at the start, some initialization variable. bnt is done on it, and it should be non-0
+	{ GID_ISLANDBRAIN,   200,   268,  0,          "anElement", "select",                          NULL,     0, { WORKAROUND_FAKE,   0 } }, // elements puzzle, gets used before super TextIcon
+	{ GID_JONES,           1,   232,  0,        "weekendText", "draw",          sig_uninitread_jones_1,     0, { WORKAROUND_FAKE,   0 } }, // jones/cd only - gets called during the game
+	{ GID_JONES,           1,   255,  0,                   "", "export 0",                        NULL,    -1, { WORKAROUND_FAKE,   0 } }, // jones/cd only - called when a game ends, temps 13 and 14
+	{ GID_JONES,         764,   255,  0,                   "", "export 0",                        NULL,    -1, { WORKAROUND_FAKE,   0 } }, // jones/ega&vga only - called when the game starts, temps 13 and 14
+	//{ GID_KQ5,            -1,     0,  0,                   "", "export 29",                       NULL,     3, { WORKAROUND_FAKE,   0xf } }, // called when playing harp for the harpies or when aborting dialog in toy shop, is used for kDoAudio - bug #4961
 	// ^^ shouldn't be needed anymore, we got a script patch instead (kq5PatchCdHarpyVolume)
-	{ GID_KQ5,            25,    25,  0,              "rm025", "doit",           -1,    0, { WORKAROUND_FAKE,   0 } }, // inside witch forest, when going to the room where the walking rock is
-	{ GID_KQ5,            55,    55,  0,         "helpScript", "doit",           -1,    0, { WORKAROUND_FAKE,   0 } }, // when giving the tambourine to the monster in the labyrinth (only happens at one of the locations) - bug #5198
-	{ GID_KQ5,            -1,   755,  0,              "gcWin", "open",           -1,   -1, { WORKAROUND_FAKE,   0 } }, // when entering control menu in the FM-Towns version
-	{ GID_KQ6,            -1,    30,  0,               "rats", "changeState",    -1,   -1, { WORKAROUND_FAKE,   0 } }, // rats in the catacombs (temps 1 - 5) - bugs #4958, #4998, #5017
-	{ GID_KQ6,           210,   210,  0,              "rm210", "scriptCheck",    -1,    0, { WORKAROUND_FAKE,   1 } }, // using inventory in that room - bug #4953
-	{ GID_KQ6,           500,   500,  0,              "rm500", "init",           -1,    0, { WORKAROUND_FAKE,   0 } }, // going to island of the beast
-	{ GID_KQ6,           520,   520,  0,              "rm520", "init",           -1,    0, { WORKAROUND_FAKE,   0 } }, // going to boiling water trap on beast isle
-	{ GID_KQ6,            -1,   903,  0,         "controlWin", "open",           -1,    4, { WORKAROUND_FAKE,   0 } }, // when opening the controls window (save, load etc)
-	{ GID_KQ6,            -1,   907,  0,             "tomato", "doVerb",         -1,    2, { WORKAROUND_FAKE,   0 } }, // when looking at the rotten tomato in the inventory - bug #5331
-	{ GID_KQ6,            -1,   928,  0,                 NULL, "startText",      -1,    0, { WORKAROUND_FAKE,   0 } }, // gets caused by Text+Audio support (see script patcher)
-	{ GID_KQ7,            -1, 64996,  0,               "User", "handleEvent",    -1,    1, { WORKAROUND_FAKE,   0 } }, // called when pushing a keyboard key
-	{ GID_LAURABOW,       37,     0,  0,                "CB1", "doit",           -1,    1, { WORKAROUND_FAKE,   0 } }, // when going up the stairs - bug #5084
-	{ GID_LAURABOW,       -1,   967,  0,             "myIcon", "cycle",          -1,    1, { WORKAROUND_FAKE,   0 } }, // having any portrait conversation coming up - initial bug #4971
-	{ GID_LAURABOW2,      -1,    24,  0,              "gcWin", "open",           -1,    5, { WORKAROUND_FAKE, 0xf } }, // is used as priority for game menu
-	{ GID_LAURABOW2,      -1,    21,  0,      "dropCluesCode", "doit",           -1,    1, { WORKAROUND_FAKE, 0x7fff } }, // when asking some questions (e.g. the reporter about the burglary, or the policeman about Ziggy). Must be big, as the game scripts perform lt on it and start deleting journal entries - bugs #4979, #5026
-	{ GID_LAURABOW2,      -1,    90,  1,        "MuseumActor", "init",           -1,    6, { WORKAROUND_FAKE,   0 } }, // Random actors in museum - bug #5197
-	{ GID_LAURABOW2,     240,   240,  0,     "sSteveAnimates", "changeState",    -1,    0, { WORKAROUND_FAKE,   0 } }, // Steve Dorian's idle animation at the docks - bug #5028
-	{ GID_LAURABOW2,      -1,   928,  0,                 NULL, "startText",      -1,    0, { WORKAROUND_FAKE,   0 } }, // gets caused by Text+Audio support (see script patcher)
-	{ GID_LONGBOW,        -1,     0,  0,            "Longbow", "restart",        -1,    0, { WORKAROUND_FAKE,   0 } }, // When canceling a restart game - bug #5244
-	{ GID_LONGBOW,        -1,   213,  0,              "clear", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // When giving an answer using the druid hand sign code in any room
-	{ GID_LONGBOW,        -1,   213,  0,             "letter", "handleEvent",  0xa8,    1, { WORKAROUND_FAKE,   0 } }, // When using the druid hand sign code in any room - bug #5035
-	{ GID_LSL1,          250,   250,  0,           "increase", "handleEvent",    -1,    2, { WORKAROUND_FAKE,   0 } }, // casino, playing game, increasing bet
-	{ GID_LSL1,          720,   720,  0,              "rm720", "init",           -1,    0, { WORKAROUND_FAKE,   0 } }, // age check room
-	{ GID_LSL2,           38,    38,  0,        "cloudScript", "changeState",    -1,    1, { WORKAROUND_FAKE,   0 } }, // entering the room in the middle deck of the ship - bug #5034
-	{ GID_LSL3,          340,   340,  0,        "ComicScript", "changeState",    -1,   -1, { WORKAROUND_FAKE,   0 } }, // right after entering the 3 ethnic groups inside comedy club (temps 200, 201, 202, 203)
-	{ GID_LSL3,           -1,   997,  0,         "TheMenuBar", "handleEvent",    -1,    1, { WORKAROUND_FAKE, 0xf } }, // when setting volume the first time, this temp is used to set volume on entry (normally it would have been initialized to 's')
-	{ GID_LSL6,          820,    82,  0,                   "", "export 0",       -1,   -1, { WORKAROUND_FAKE,   0 } }, // when touching the electric fence - bug #5103
-	{ GID_LSL6,           -1,    85,  0,          "washcloth", "doVerb",         -1,    0, { WORKAROUND_FAKE,   0 } }, // washcloth in inventory
-	{ GID_LSL6,           -1,   928, -1,           "Narrator", "startText",      -1,    0, { WORKAROUND_FAKE,   0 } }, // used by various objects that are even translated in foreign versions, that's why we use the base-class
-	{ GID_LSL6HIRES,       0,    85,  0,             "LL6Inv", "init",           -1,    0, { WORKAROUND_FAKE,   0 } }, // on startup
-	{ GID_LSL6HIRES,      -1, 64950,  1,            "Feature", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // at least when entering swimming pool area
-	{ GID_LSL6HIRES,      -1, 64964,  0,              "DPath", "init",           -1,    1, { WORKAROUND_FAKE,   0 } }, // during the game
-	{ GID_MOTHERGOOSE256, -1,     0,  0,                 "MG", "doit",           -1,    5, { WORKAROUND_FAKE,   0 } }, // SCI1.1: When moving the cursor all the way to the left during the game - bug #5224
-	{ GID_MOTHERGOOSE256, -1,   992,  0,             "AIPath", "init",           -1,    0, { WORKAROUND_FAKE,   0 } }, // Happens in the demo and full version. In the demo, it happens when walking two screens from mother goose's house to the north. In the full version, it happens in rooms 7 and 23 - bug #5269
-	{ GID_MOTHERGOOSE256, 90,    90,  0,        "introScript", "changeState",    -1,   65, { WORKAROUND_FAKE,   0 } }, // SCI1(CD): At the very end, after the game is completed and restarted - bug #5626
-	{ GID_MOTHERGOOSE256, 94,    94,  0,            "sunrise", "changeState",    -1,  367, { WORKAROUND_FAKE,   0 } }, // At the very end, after the game is completed - bug #5294
-	{ GID_MOTHERGOOSEHIRES,-1,64950,  1,            "Feature", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // right when clicking on a child at the start and probably also later
-	{ GID_MOTHERGOOSEHIRES,-1,64950,  1,               "View", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // see above
-	{ GID_PEPPER,         -1,   894,  0,            "Package", "doVerb",         -1,    3, { WORKAROUND_FAKE,   0 } }, // using the hand on the book in the inventory - bug #5154
-	{ GID_PEPPER,        150,   928,  0,           "Narrator", "startText",      -1,    0, { WORKAROUND_FAKE,   0 } }, // happens during the non-interactive demo of Pepper
-	{ GID_PQ4,            -1,    25,  0,         "iconToggle", "select",         -1,    1, { WORKAROUND_FAKE,   0 } }, // when toggling the icon bar to auto-hide or not
-	{ GID_PQSWAT,         -1, 64950,  0,               "View", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // Using the menu in the beginning
-	{ GID_QFG1,           -1,   210,  0,          "Encounter", "init",        0xbd0,    0, { WORKAROUND_FAKE,   0 } }, // hq1: going to the brigands hideout
-	{ GID_QFG1,           -1,   210,  0,          "Encounter", "init",        0xbe4,    0, { WORKAROUND_FAKE,   0 } }, // qfg1: going to the brigands hideout
-	{ GID_QFG1VGA,        16,    16,  0,        "lassoFailed", "changeState",    -1,   -1, { WORKAROUND_FAKE,   0 } }, // qfg1vga: casting the "fetch" spell in the screen with the flowers, temps 0 and 1 - bug #5309
-	{ GID_QFG1VGA,        -1,   210,  0,          "Encounter", "init",        0xcee,    0, { WORKAROUND_FAKE,   0 } }, // qfg1vga: going to the brigands hideout - bug #5515
-	{ GID_QFG1VGA,        -1,   210,  0,          "Encounter", "init",        0xce7,    0, { WORKAROUND_FAKE,   0 } }, // qfg1vga: going to room 92
-	{ GID_QFG2,           -1,    71,  0,        "theInvSheet", "doit",           -1,    1, { WORKAROUND_FAKE,   0 } }, // accessing the inventory
-	{ GID_QFG2,           -1,   701, -1,              "Alley", "at",             -1,    0, { WORKAROUND_FAKE,   0 } }, // when walking inside the alleys in the town - bug #5019 & #5106
-	{ GID_QFG2,           -1,   990,  0,            "Restore", "doit",           -1,  364, { WORKAROUND_FAKE,   0 } }, // when pressing enter in restore dialog w/o any saved games present
-	{ GID_QFG2,          260,   260,  0,             "abdulS", "changeState",0x2d22,   -1, { WORKAROUND_FAKE,   0 } }, // During the thief's first mission (in the house), just before Abdul is about to enter the house (where you have to hide in the wardrobe), bug #5153, temps 1 and 2
-	{ GID_QFG2,          260,   260,  0,            "jabbarS", "changeState",0x2d22,   -1, { WORKAROUND_FAKE,   0 } }, // During the thief's first mission (in the house), just before Jabbar is about to enter the house (where you have to hide in the wardrobe), bug #5164, temps 1 and 2
-	{ GID_QFG2,          500,   500,  0,   "lightNextCandleS", "changeState",    -1,   -1, { WORKAROUND_FAKE,   0 } }, // Inside the last room, while Ad Avis performs the ritual to summon the genie - bug #5566
-	{ GID_QFG2,           -1,   700,  0,                 NULL, "showSign",       -1,   10, { WORKAROUND_FAKE,   0 } }, // Occurs sometimes when reading a sign in Raseir, Shapeir et al - bugs #5627, #5635
-	{ GID_QFG3,          510,   510,  0,         "awardPrize", "changeState",    -1,    0, { WORKAROUND_FAKE,   1 } }, // Simbani warrior challenge, after throwing the spears and retrieving the ring - bug #5277. Must be non-zero, otherwise the prize is awarded twice - bug #6160
-	{ GID_QFG3,          140,   140,  0,              "rm140", "init",       0x1008,    0, { WORKAROUND_FAKE,   0 } }, // when importing a character and selecting the previous profession - bug #5163
-	{ GID_QFG3,          330,   330, -1,             "Teller", "doChild",        -1,   -1, { WORKAROUND_FAKE,   0 } }, // when talking to King Rajah about "Rajah" (bug #5033, temp 1) or "Tarna" (temp 0), or when clicking on yourself and saying "Greet" (bug #5148, temp 1)
-	{ GID_QFG3,          700,   700, -1,      "monsterIsDead", "changeState",    -1,    0, { WORKAROUND_FAKE,   0 } }, // in the jungle, after winning any fight, bug #5169
-	{ GID_QFG3,          470,   470, -1,              "rm470", "notify",         -1,    0, { WORKAROUND_FAKE,   0 } }, // closing the character screen in the Simbani village in the room with the bridge, bug #5165
-	{ GID_QFG3,          490,   490, -1,      "computersMove", "changeState",    -1,    0, { WORKAROUND_FAKE,   0 } }, // when finishing awari game, bug #5167
-	{ GID_QFG3,          490,   490, -1,      "computersMove", "changeState", 0xf53,    4, { WORKAROUND_FAKE,   0 } }, // also when finishing awari game
-	{ GID_QFG3,          851,    32, -1,            "ProjObj", "doit",           -1,    1, { WORKAROUND_FAKE,   0 } }, // near the end, when throwing the spear of death, bug #5282
-	{ GID_QFG4,           -1,    15, -1,     "charInitScreen", "dispatchEvent",  -1,    5, { WORKAROUND_FAKE,   0 } }, // floppy version, when viewing the character screen
-	{ GID_QFG4,           -1, 64917, -1,       "controlPlane", "setBitmap",      -1,    3, { WORKAROUND_FAKE,   0 } }, // floppy version, when entering the game menu
-	{ GID_QFG4,           -1, 64917, -1,              "Plane", "setBitmap",      -1,    3, { WORKAROUND_FAKE,   0 } }, // floppy version, happens sometimes in fight scenes
-	{ GID_QFG4,          520, 64950,  0,             "fLake2", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // CD version, at the lake, when meeting the Rusalka and attempting to leave
-	{ GID_QFG4,          800, 64950,  0,               "View", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // CD version, in the room with the spider pillar, when climbing on the pillar
-	{ GID_RAMA,           12, 64950, -1,   "InterfaceFeature", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // Demo, right when it starts
-	{ GID_RAMA,           12, 64950, -1,      "hiliteOptText", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // Demo, right when it starts
-	{ GID_RAMA,           12, 64950, -1,               "View", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // Demo, right when it starts
-	{ GID_SHIVERS,        -1,   952,  0,       "SoundManager", "stop",           -1,    2, { WORKAROUND_FAKE,   0 } }, // Just after Sierra logo
-	{ GID_SHIVERS,        -1, 64950,  0,            "Feature", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // When clicking on the locked door at the beginning
-	{ GID_SHIVERS,        -1, 64950,  0,               "View", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // When clicking on the gargoyle eye at the beginning
-	{ GID_SHIVERS,     20311, 64964,  0,              "DPath", "init",           -1,    1, { WORKAROUND_FAKE,   0 } }, // Just after door puzzle is solved and the metal balls start to roll
-	{ GID_SHIVERS,     29260, 29260,  0,             "spMars", "handleEvent",    -1,    4, { WORKAROUND_FAKE,   0 } }, // When clicking mars after seeing fortune to align earth etc...
-	{ GID_SHIVERS,     29260, 29260,  0,            "spVenus", "handleEvent",    -1,    4, { WORKAROUND_FAKE,   0 } }, // When clicking venus after seeing fortune to align earth etc...
-	{ GID_SQ1,           103,   103,  0,               "hand", "internalEvent",  -1,   -1, { WORKAROUND_FAKE,   0 } }, // Spanish (and maybe early versions?) only: when moving cursor over input pad, temps 1 and 2
-	{ GID_SQ1,            -1,   703,  0,                   "", "export 1",       -1,    0, { WORKAROUND_FAKE,   0 } }, // sub that's called from several objects while on sarien battle cruiser
-	{ GID_SQ1,            -1,   703,  0,         "firePulsar", "changeState", 0x18a,    0, { WORKAROUND_FAKE,   0 } }, // export 1, but called locally (when shooting at aliens)
-	{ GID_SQ4,            -1,   398,  0,            "showBox", "changeState",    -1,    0, { WORKAROUND_FAKE,   0 } }, // CD: called when rummaging in Software Excess bargain bin
-	{ GID_SQ4,            -1,   928, -1,           "Narrator", "startText",      -1, 1000, { WORKAROUND_FAKE,   1 } }, // CD: happens in the options dialog and in-game when speech and subtitles are used simultaneously
-	{ GID_SQ4,            -1,   708, -1,            "exitBut", "doVerb",         -1,    0, { WORKAROUND_FAKE,   0 } }, // Floppy: happens, when looking at the "close" button in the sq4 hintbook - bug #6447
-	{ GID_SQ4,            -1,   708, -1,            "prevBut", "doVerb",         -1,    0, { WORKAROUND_FAKE,   0 } }, // Floppy: happens, when looking at the "previous" button in the sq4 hintbook - bug #6447
-	{ GID_SQ4,            -1,   708, -1,            "nextBut", "doVerb",         -1,    0, { WORKAROUND_FAKE,   0 } }, // Floppy: happens, when looking at the "next" button in the sq4 hintbook - bug #6447
-	{ GID_SQ5,           201,   201,  0,        "buttonPanel", "doVerb",         -1,    0, { WORKAROUND_FAKE,   1 } }, // when looking at the orange or red button - bug #5112
-	{ GID_SQ6,            -1,     0,  0,                "SQ6", "init",           -1,    2, { WORKAROUND_FAKE,   0 } }, // Demo and full version: called when the game starts (demo: room 0, full: room 100)
-	{ GID_SQ6,            -1, 64950, -1,            "Feature", "handleEvent",    -1,    0, { WORKAROUND_FAKE,   0 } }, // called when pressing "Start game" in the main menu, when entering the Orion's Belt bar (room 300), and perhaps other places
-	{ GID_SQ6,            -1, 64964,  0,              "DPath", "init",           -1,    1, { WORKAROUND_FAKE,   0 } }, // during the game
-	{ GID_TORIN,          -1, 64017,  0,             "oFlags", "clear",          -1,    0, { WORKAROUND_FAKE,   0 } }, // entering Torin's home in the French version
-	SCI_WORKAROUNDENTRY_TERMINATOR
-};
-
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+	{ GID_KQ5,            25,    25,  0,              "rm025", "doit",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // inside witch forest, when going to the room where the walking rock is
+	{ GID_KQ5,            55,    55,  0,         "helpScript", "doit",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // when giving the tambourine to the monster in the labyrinth (only happens at one of the locations) - bug #5198
+	{ GID_KQ5,            -1,   755,  0,              "gcWin", "open",                            NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when entering control menu in the FM-Towns version
+	{ GID_KQ6,            -1,    30,  0,               "rats", "changeState",                     NULL,    -1, { WORKAROUND_FAKE,   0 } }, // rats in the catacombs (temps 1 - 5) - bugs #4958, #4998, #5017
+	{ GID_KQ6,           210,   210,  0,              "rm210", "scriptCheck",                     NULL,     0, { WORKAROUND_FAKE,   1 } }, // using inventory in that room - bug #4953
+	{ GID_KQ6,           500,   500,  0,              "rm500", "init",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // going to island of the beast
+	{ GID_KQ6,           520,   520,  0,              "rm520", "init",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // going to boiling water trap on beast isle
+	{ GID_KQ6,            -1,   903,  0,         "controlWin", "open",                            NULL,     4, { WORKAROUND_FAKE,   0 } }, // when opening the controls window (save, load etc)
+	{ GID_KQ6,            -1,   907,  0,             "tomato", "doVerb",                          NULL,     2, { WORKAROUND_FAKE,   0 } }, // when looking at the rotten tomato in the inventory - bug #5331
+	{ GID_KQ6,            -1,   928,  0,                 NULL, "startText",                       NULL,     0, { WORKAROUND_FAKE,   0 } }, // gets caused by Text+Audio support (see script patcher)
+	{ GID_KQ7,            -1, 64996,  0,               "User", "handleEvent",                     NULL,     1, { WORKAROUND_FAKE,   0 } }, // called when pushing a keyboard key
+	{ GID_LAURABOW,       37,     0,  0,                "CB1", "doit",                            NULL,     1, { WORKAROUND_FAKE,   0 } }, // when going up the stairs - bug #5084
+	{ GID_LAURABOW,       -1,   967,  0,             "myIcon", "cycle",                           NULL,     1, { WORKAROUND_FAKE,   0 } }, // having any portrait conversation coming up - initial bug #4971
+	{ GID_LAURABOW2,      -1,    24,  0,              "gcWin", "open",                            NULL,     5, { WORKAROUND_FAKE, 0xf } }, // is used as priority for game menu
+	{ GID_LAURABOW2,      -1,    21,  0,      "dropCluesCode", "doit",                            NULL,     1, { WORKAROUND_FAKE, 0x7fff } }, // when asking some questions (e.g. the reporter about the burglary, or the policeman about Ziggy). Must be big, as the game scripts perform lt on it and start deleting journal entries - bugs #4979, #5026
+	{ GID_LAURABOW2,      -1,    90,  1,        "MuseumActor", "init",                            NULL,     6, { WORKAROUND_FAKE,   0 } }, // Random actors in museum - bug #5197
+	{ GID_LAURABOW2,     240,   240,  0,     "sSteveAnimates", "changeState",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // Steve Dorian's idle animation at the docks - bug #5028
+	{ GID_LAURABOW2,      -1,   928,  0,                 NULL, "startText",                       NULL,     0, { WORKAROUND_FAKE,   0 } }, // gets caused by Text+Audio support (see script patcher)
+	{ GID_LONGBOW,        -1,     0,  0,            "Longbow", "restart",                         NULL,     0, { WORKAROUND_FAKE,   0 } }, // When canceling a restart game - bug #5244
+	{ GID_LONGBOW,        -1,   213,  0,              "clear", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // When giving an answer using the druid hand sign code in any room
+	{ GID_LONGBOW,        -1,   213,  0,             "letter", "handleEvent", sig_uninitread_longbow_1,   1, { WORKAROUND_FAKE,   0 } }, // When using the druid hand sign code in any room - bug #5035
+	{ GID_LSL1,          250,   250,  0,           "increase", "handleEvent",                     NULL,     2, { WORKAROUND_FAKE,   0 } }, // casino, playing game, increasing bet
+	{ GID_LSL1,          720,   720,  0,              "rm720", "init",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // age check room
+	{ GID_LSL2,           38,    38,  0,        "cloudScript", "changeState",                     NULL,     1, { WORKAROUND_FAKE,   0 } }, // entering the room in the middle deck of the ship - bug #5034
+	{ GID_LSL3,          340,   340,  0,        "ComicScript", "changeState",                     NULL,    -1, { WORKAROUND_FAKE,   0 } }, // right after entering the 3 ethnic groups inside comedy club (temps 200, 201, 202, 203)
+	{ GID_LSL3,           -1,   997,  0,         "TheMenuBar", "handleEvent",                     NULL,     1, { WORKAROUND_FAKE, 0xf } }, // when setting volume the first time, this temp is used to set volume on entry (normally it would have been initialized to 's')
+	{ GID_LSL6,          820,    82,  0,                   "", "export 0",                        NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when touching the electric fence - bug #5103
+	{ GID_LSL6,           -1,    85,  0,          "washcloth", "doVerb",                          NULL,     0, { WORKAROUND_FAKE,   0 } }, // washcloth in inventory
+	{ GID_LSL6,           -1,   928, -1,           "Narrator", "startText",                       NULL,     0, { WORKAROUND_FAKE,   0 } }, // used by various objects that are even translated in foreign versions, that's why we use the base-class
+	{ GID_LSL6HIRES,       0,    85,  0,             "LL6Inv", "init",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // on startup
+	{ GID_LSL6HIRES,      -1, 64950,  1,            "Feature", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // at least when entering swimming pool area
+	{ GID_LSL6HIRES,      -1, 64964,  0,              "DPath", "init",                            NULL,     1, { WORKAROUND_FAKE,   0 } }, // during the game
+	{ GID_MOTHERGOOSE256, -1,     0,  0,                 "MG", "doit",                            NULL,     5, { WORKAROUND_FAKE,   0 } }, // SCI1.1: When moving the cursor all the way to the left during the game - bug #5224
+	{ GID_MOTHERGOOSE256, -1,   992,  0,             "AIPath", "init",                            NULL,     0, { WORKAROUND_FAKE,   0 } }, // Happens in the demo and full version. In the demo, it happens when walking two screens from mother goose's house to the north. In the full version, it happens in rooms 7 and 23 - bug #5269
+	{ GID_MOTHERGOOSE256, 90,    90,  0,        "introScript", "changeState",                     NULL,    65, { WORKAROUND_FAKE,   0 } }, // SCI1(CD): At the very end, after the game is completed and restarted - bug #5626
+	{ GID_MOTHERGOOSE256, 94,    94,  0,            "sunrise", "changeState",                     NULL,   367, { WORKAROUND_FAKE,   0 } }, // At the very end, after the game is completed - bug #5294
+	{ GID_MOTHERGOOSEHIRES,-1,64950,  1,            "Feature", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // right when clicking on a child at the start and probably also later
+	{ GID_MOTHERGOOSEHIRES,-1,64950,  1,               "View", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // see above
+	{ GID_PEPPER,         -1,   894,  0,            "Package", "doVerb",                          NULL,     3, { WORKAROUND_FAKE,   0 } }, // using the hand on the book in the inventory - bug #5154
+	{ GID_PEPPER,        150,   928,  0,           "Narrator", "startText",                       NULL,     0, { WORKAROUND_FAKE,   0 } }, // happens during the non-interactive demo of Pepper
+	{ GID_PQ4,            -1,    25,  0,         "iconToggle", "select",                          NULL,     1, { WORKAROUND_FAKE,   0 } }, // when toggling the icon bar to auto-hide or not
+	{ GID_PQSWAT,         -1, 64950,  0,               "View", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // Using the menu in the beginning
+	{ GID_QFG1,           -1,   210,  0,          "Encounter", "init",           sig_uninitread_qfg1_1,     0, { WORKAROUND_FAKE,   0 } }, // qfg1/hq1: going to the brigands hideout
+	{ GID_QFG1VGA,        16,    16,  0,        "lassoFailed", "changeState",                     NULL,    -1, { WORKAROUND_FAKE,   0 } }, // qfg1vga: casting the "fetch" spell in the screen with the flowers, temps 0 and 1 - bug #5309
+	{ GID_QFG1VGA,        -1,   210,  0,          "Encounter", "init",        sig_uninitread_qfg1vga_1,     0, { WORKAROUND_FAKE,   0 } }, // qfg1vga: going to the brigands hideout - bug #5515
+	{ GID_QFG2,           -1,    71,  0,        "theInvSheet", "doit",                            NULL,     1, { WORKAROUND_FAKE,   0 } }, // accessing the inventory
+	{ GID_QFG2,           -1,    79,  0,        "TryToMoveTo", "onTarget",                        NULL,     0, { WORKAROUND_FAKE,   0 } }, // when throwing pot at air elemental, happens when client coordinates are the same as airElemental coordinates. happened to me right after room change - bug #6859
+	{ GID_QFG2,           -1,   701, -1,              "Alley", "at",                              NULL,     0, { WORKAROUND_FAKE,   0 } }, // when walking inside the alleys in the town - bug #5019 & #5106
+	{ GID_QFG2,           -1,   990,  0,            "Restore", "doit",                            NULL,   364, { WORKAROUND_FAKE,   0 } }, // when pressing enter in restore dialog w/o any saved games present
+	{ GID_QFG2,          260,   260,  0,             "abdulS", "changeState",    sig_uninitread_qfg2_1,    -1, { WORKAROUND_FAKE,   0 } }, // During the thief's first mission (in the house), just before Abdul is about to enter the house (where you have to hide in the wardrobe), bug #5153, temps 1 and 2
+	{ GID_QFG2,          260,   260,  0,            "jabbarS", "changeState",    sig_uninitread_qfg2_1,    -1, { WORKAROUND_FAKE,   0 } }, // During the thief's first mission (in the house), just before Jabbar is about to enter the house (where you have to hide in the wardrobe), bug #5164, temps 1 and 2
+	{ GID_QFG2,          500,   500,  0,   "lightNextCandleS", "changeState",                     NULL,    -1, { WORKAROUND_FAKE,   0 } }, // Inside the last room, while Ad Avis performs the ritual to summon the genie - bug #5566
+	{ GID_QFG2,           -1,   700,  0,                 NULL, "showSign",                        NULL,    10, { WORKAROUND_FAKE,   0 } }, // Occurs sometimes when reading a sign in Raseir, Shapeir et al - bugs #5627, #5635
+	{ GID_QFG3,          510,   510,  0,         "awardPrize", "changeState",                     NULL,     0, { WORKAROUND_FAKE,   1 } }, // Simbani warrior challenge, after throwing the spears and retrieving the ring - bug #5277. Must be non-zero, otherwise the prize is awarded twice - bug #6160
+	{ GID_QFG3,          140,   140,  0,              "rm140", "init",           sig_uninitread_qfg3_1,     0, { WORKAROUND_FAKE,   0 } }, // when importing a character and selecting the previous profession - bug #5163
+	{ GID_QFG3,          330,   330, -1,             "Teller", "doChild",                         NULL,    -1, { WORKAROUND_FAKE,   0 } }, // when talking to King Rajah about "Rajah" (bug #5033, temp 1) or "Tarna" (temp 0), or when clicking on yourself and saying "Greet" (bug #5148, temp 1)
+	{ GID_QFG3,          700,   700, -1,      "monsterIsDead", "changeState",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // in the jungle, after winning any fight, bug #5169
+	{ GID_QFG3,          470,   470, -1,              "rm470", "notify",                          NULL,     0, { WORKAROUND_FAKE,   0 } }, // closing the character screen in the Simbani village in the room with the bridge, bug #5165
+	{ GID_QFG3,          490,   490, -1,      "computersMove", "changeState",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // when finishing awari game, bug #5167
+	{ GID_QFG3,          490,   490, -1,      "computersMove", "changeState",    sig_uninitread_qfg3_2,     4, { WORKAROUND_FAKE,   0 } }, // also when finishing awari game
+	{ GID_QFG3,          851,    32, -1,            "ProjObj", "doit",                            NULL,     1, { WORKAROUND_FAKE,   0 } }, // near the end, when throwing the spear of death, bug #5282
+	{ GID_QFG4,           -1,    15, -1,     "charInitScreen", "dispatchEvent",                   NULL,     5, { WORKAROUND_FAKE,   0 } }, // floppy version, when viewing the character screen
+	{ GID_QFG4,           -1, 64917, -1,       "controlPlane", "setBitmap",                       NULL,     3, { WORKAROUND_FAKE,   0 } }, // floppy version, when entering the game menu
+	{ GID_QFG4,           -1, 64917, -1,              "Plane", "setBitmap",                       NULL,     3, { WORKAROUND_FAKE,   0 } }, // floppy version, happens sometimes in fight scenes
+	{ GID_QFG4,          520, 64950,  0,             "fLake2", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // CD version, at the lake, when meeting the Rusalka and attempting to leave
+	{ GID_QFG4,          800, 64950,  0,               "View", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // CD version, in the room with the spider pillar, when climbing on the pillar
+	{ GID_RAMA,           12, 64950, -1,   "InterfaceFeature", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // Demo, right when it starts
+	{ GID_RAMA,           12, 64950, -1,      "hiliteOptText", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // Demo, right when it starts
+	{ GID_RAMA,           12, 64950, -1,               "View", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // Demo, right when it starts
+	{ GID_SHIVERS,        -1,   952,  0,       "SoundManager", "stop",                            NULL,     2, { WORKAROUND_FAKE,   0 } }, // Just after Sierra logo
+	{ GID_SHIVERS,        -1, 64950,  0,            "Feature", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // When clicking on the locked door at the beginning
+	{ GID_SHIVERS,        -1, 64950,  0,               "View", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // When clicking on the gargoyle eye at the beginning
+	{ GID_SHIVERS,     20311, 64964,  0,              "DPath", "init",                            NULL,     1, { WORKAROUND_FAKE,   0 } }, // Just after door puzzle is solved and the metal balls start to roll
+	{ GID_SHIVERS,     29260, 29260,  0,             "spMars", "handleEvent",                     NULL,     4, { WORKAROUND_FAKE,   0 } }, // When clicking mars after seeing fortune to align earth etc...
+	{ GID_SHIVERS,     29260, 29260,  0,            "spVenus", "handleEvent",                     NULL,     4, { WORKAROUND_FAKE,   0 } }, // When clicking venus after seeing fortune to align earth etc...
+	{ GID_SQ1,           103,   103,  0,               "hand", "internalEvent",                   NULL,    -1, { WORKAROUND_FAKE,   0 } }, // Spanish (and maybe early versions?) only: when moving cursor over input pad, temps 1 and 2
+	{ GID_SQ1,            -1,   703,  0,                   "", "export 1",                        NULL,     0, { WORKAROUND_FAKE,   0 } }, // sub that's called from several objects while on sarien battle cruiser
+	{ GID_SQ1,            -1,   703,  0,         "firePulsar", "changeState",     sig_uninitread_sq1_1,     0, { WORKAROUND_FAKE,   0 } }, // export 1, but called locally (when shooting at aliens)
+	{ GID_SQ4,            -1,   398,  0,            "showBox", "changeState",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // CD: called when rummaging in Software Excess bargain bin
+	{ GID_SQ4,            -1,   928, -1,           "Narrator", "startText",                       NULL,  1000, { WORKAROUND_FAKE,   1 } }, // CD: happens in the options dialog and in-game when speech and subtitles are used simultaneously
+	{ GID_SQ4,            -1,   708, -1,            "exitBut", "doVerb",                          NULL,     0, { WORKAROUND_FAKE,   0 } }, // Floppy: happens, when looking at the "close" button in the sq4 hintbook - bug #6447
+	{ GID_SQ4,            -1,   708, -1,                   "", "doVerb",                          NULL,     0, { WORKAROUND_FAKE,   0 } }, // Floppy: happens, when looking at the "close" button... in Russian version - bug #5573
+	{ GID_SQ4,            -1,   708, -1,            "prevBut", "doVerb",                          NULL,     0, { WORKAROUND_FAKE,   0 } }, // Floppy: happens, when looking at the "previous" button in the sq4 hintbook - bug #6447
+	{ GID_SQ4,            -1,   708, -1, "\xA8\xE6\xE3 \xAD\xA0\xA7\xA0\xA4.", "doVerb",          NULL,     0, { WORKAROUND_FAKE,   0 } }, // Floppy: happens, when looking at the "previous" button... in Russian version - bug #5573
+	{ GID_SQ4,            -1,   708, -1,            "nextBut", "doVerb",                          NULL,     0, { WORKAROUND_FAKE,   0 } }, // Floppy: happens, when looking at the "next" button in the sq4 hintbook - bug #6447
+	{ GID_SQ4,            -1,   708, -1,                  ".", "doVerb",                          NULL,     0, { WORKAROUND_FAKE,   0 } }, // Floppy: happens, when looking at the "next" button... in Russian version - bug #5573
+	{ GID_SQ5,           201,   201,  0,        "buttonPanel", "doVerb",                          NULL,     0, { WORKAROUND_FAKE,   1 } }, // when looking at the orange or red button - bug #5112
+	{ GID_SQ6,            -1,     0,  0,                "SQ6", "init",                            NULL,     2, { WORKAROUND_FAKE,   0 } }, // Demo and full version: called when the game starts (demo: room 0, full: room 100)
+	{ GID_SQ6,            -1, 64950, -1,            "Feature", "handleEvent",                     NULL,     0, { WORKAROUND_FAKE,   0 } }, // called when pressing "Start game" in the main menu, when entering the Orion's Belt bar (room 300), and perhaps other places
+	{ GID_SQ6,            -1, 64964,  0,              "DPath", "init",                            NULL,     1, { WORKAROUND_FAKE,   0 } }, // during the game
+	{ GID_TORIN,          -1, 64017,  0,             "oFlags", "clear",                           NULL,     0, { WORKAROUND_FAKE,   0 } }, // entering Torin's home in the French version
+	SCI_WORKAROUNDENTRY_TERMINATOR
+};
+
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kAbs_workarounds[] = {
-	{ GID_HOYLE1,          1,     1,  0,              "room1", "doit",           -1,    0, { WORKAROUND_FAKE,  0x3e9 } }, // crazy eights - called with objects instead of integers
-	{ GID_HOYLE1,          2,     2,  0,              "room2", "doit",           -1,    0, { WORKAROUND_FAKE,  0x3e9 } }, // old maid - called with objects instead of integers
-	{ GID_HOYLE1,          3,     3,  0,              "room3", "doit",           -1,    0, { WORKAROUND_FAKE,  0x3e9 } }, // hearts - called with objects instead of integers
-	{ GID_QFG1VGA,        -1,    -1,  0,                 NULL, "doit",           -1,    0, { WORKAROUND_FAKE,  0x3e9 } }, // when the game is patched with the NRS patch
-	{ GID_QFG3   ,        -1,    -1,  0,                 NULL, "doit",           -1,    0, { WORKAROUND_FAKE,  0x3e9 } }, // when the game is patched with the NRS patch - bugs #6042, #6043
+	{ GID_HOYLE1,          1,     1,  0,              "room1", "doit",                      NULL,     0, { WORKAROUND_FAKE,  0x3e9 } }, // crazy eights - called with objects instead of integers
+	{ GID_HOYLE1,          2,     2,  0,              "room2", "doit",                      NULL,     0, { WORKAROUND_FAKE,  0x3e9 } }, // old maid - called with objects instead of integers
+	{ GID_HOYLE1,          3,     3,  0,              "room3", "doit",                      NULL,     0, { WORKAROUND_FAKE,  0x3e9 } }, // hearts - called with objects instead of integers
+	{ GID_QFG1VGA,        -1,    -1,  0,                 NULL, "doit",                      NULL,     0, { WORKAROUND_FAKE,  0x3e9 } }, // when the game is patched with the NRS patch
+	{ GID_QFG3   ,        -1,    -1,  0,                 NULL, "doit",                      NULL,     0, { WORKAROUND_FAKE,  0x3e9 } }, // when the game is patched with the NRS patch - bugs #6042, #6043
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kCelHigh_workarounds[] = {
-	{ GID_KQ5,            -1,   255,  0,          "deathIcon", "setSize",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // english floppy: when getting beaten up in the inn and probably more, called with 2nd parameter as object - bug #5049
-	{ GID_PQ2,            -1,   255,  0,              "DIcon", "setSize",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when showing picture within windows, called with 2nd/3rd parameters as objects
-	{ GID_SQ1,             1,   255,  0,              "DIcon", "setSize",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // DEMO: Called with 2nd/3rd parameters as objects when clicking on the menu - bug #5012
-	{ GID_FANMADE,        -1,   979,  0,              "DIcon", "setSize",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // In The Gem Scenario and perhaps other fanmade games, this is called with 2nd/3rd parameters as objects - bug #5144
+	{ GID_KQ5,            -1,   255,  0,          "deathIcon", "setSize",                   NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // english floppy: when getting beaten up in the inn and probably more, called with 2nd parameter as object - bug #5049
+	{ GID_PQ2,            -1,   255,  0,              "DIcon", "setSize",                   NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when showing picture within windows, called with 2nd/3rd parameters as objects
+	{ GID_SQ1,             1,   255,  0,              "DIcon", "setSize",                   NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // DEMO: Called with 2nd/3rd parameters as objects when clicking on the menu - bug #5012
+	{ GID_FANMADE,        -1,   979,  0,              "DIcon", "setSize",                   NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // In The Gem Scenario and perhaps other fanmade games, this is called with 2nd/3rd parameters as objects - bug #5144
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kCelWide_workarounds[] = {
-	{ GID_KQ5,            -1,   255,  0,          "deathIcon", "setSize",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // english floppy: when getting beaten up in the inn and probably more, called with 2nd parameter as object - bug #5049
-	{ GID_PQ2,            -1,   255,  0,              "DIcon", "setSize",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when showing picture within windows, called with 2nd/3rd parameters as objects
-	{ GID_SQ1,             1,   255,  0,              "DIcon", "setSize",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // DEMO: Called with 2nd/3rd parameters as objects when clicking on the menu - bug #5012
-	{ GID_FANMADE,        -1,   979,  0,              "DIcon", "setSize",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // In The Gem Scenario and perhaps other fanmade games, this is called with 2nd/3rd parameters as objects - bug #5144
+	{ GID_KQ5,            -1,   255,  0,          "deathIcon", "setSize",                   NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // english floppy: when getting beaten up in the inn and probably more, called with 2nd parameter as object - bug #5049
+	{ GID_PQ2,            -1,   255,  0,              "DIcon", "setSize",                   NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when showing picture within windows, called with 2nd/3rd parameters as objects
+	{ GID_SQ1,             1,   255,  0,              "DIcon", "setSize",                   NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // DEMO: Called with 2nd/3rd parameters as objects when clicking on the menu - bug #5012
+	{ GID_FANMADE,        -1,   979,  0,              "DIcon", "setSize",                   NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // In The Gem Scenario and perhaps other fanmade games, this is called with 2nd/3rd parameters as objects - bug #5144
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kDeleteKey_workarounds[] = {
-	{    GID_HOYLE4,     300,   999,  0,     "handleEventList", "delete",        -1,    0, { WORKAROUND_IGNORE, 0 } }, // restarting hearts, while tray is shown - bug #6604
-	{    GID_HOYLE4,     500,   999,  0,     "handleEventList", "delete",        -1,    0, { WORKAROUND_IGNORE, 0 } }, // restarting cribbage, while tray is shown - bug #6604
-	{    GID_HOYLE4,     975,   999,  0,     "handleEventList", "delete",        -1,    0, { WORKAROUND_IGNORE, 0 } }, // going back to gamelist from hearts/cribbage, while tray is shown - bug #6604
-	SCI_WORKAROUNDENTRY_TERMINATOR
-};
-
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+	{ GID_HOYLE4,        300,   999,  0,     "handleEventList", "delete",                   NULL,     0, { WORKAROUND_IGNORE, 0 } }, // restarting hearts, while tray is shown - bug #6604
+	{ GID_HOYLE4,        500,   999,  0,     "handleEventList", "delete",                   NULL,     0, { WORKAROUND_IGNORE, 0 } }, // restarting cribbage, while tray is shown - bug #6604
+	{ GID_HOYLE4,        975,   999,  0,     "handleEventList", "delete",                   NULL,     0, { WORKAROUND_IGNORE, 0 } }, // going back to gamelist from hearts/cribbage, while tray is shown - bug #6604
+	SCI_WORKAROUNDENTRY_TERMINATOR
+};
+
+//                Game: Fan-Made games (SCI Studio)
+//      Calling method: Game::save, Game::restore
+//   Subroutine offset: Al Pond 2:          0x0e5c (ldi 0001)
+//                      Black Cauldron:     0x000a (ldi 01)
+//                      Cascade Quest:      0x0d1c (ldi 0001)
+//                      Demo Quest:         0x0e55 (ldi 0001)
+//                      I want my C64 back: 0x0e57 (ldi 0001)
+// Applies to at least: games listed above
+static const uint16 sig_kDeviceInfo_Fanmade_1[] = {
+	0x3f, 0x79,                      // link 79h
+	0x34, SIG_UINT16(0x0001),        // ldi 0001
+	0xa5, 0x00,                      // sat temp[0]
+	SIG_END
+};
+static const uint16 sig_kDeviceInfo_Fanmade_2[] = {
+	0x3f, 0x79,                      // link 79h
+	0x35, 0x01,                      // ldi 01
+	0xa5, 0x00,                      // sat temp[0]
+	SIG_END
+};
+
+//    gameID,           room,script,lvl,          object-name, method-name,      local-call-signature, index,   workaround
 const SciWorkaroundEntry kDeviceInfo_workarounds[] = {
-	{ GID_FANMADE,        -1,   994,  1,               "Game", "save",        0xd1c,    0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games, this is called with one parameter for CurDevice (Cascade Quest)
-	{ GID_FANMADE,        -1,   994,  1,               "Game", "save",        0xe55,    0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games, this is called with one parameter for CurDevice (Demo Quest)
-	{ GID_FANMADE,        -1,   994,  1,               "Game", "save",        0xe57,    0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games, this is called with one parameter for CurDevice (I Want My C64 Back)
-	{ GID_FANMADE,        -1,   994,  0,              "Black", "save",          0xa,    0, { WORKAROUND_IGNORE,    0 } }, // In fanmade games, this is called with one parameter for CurDevice (Black Cauldron Remake)
-	{ GID_FANMADE,        -1,   994,  1,               "Game", "save",        0xe5c,    0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games, this is called with one parameter for CurDevice (Most of them)
-	{ GID_FANMADE,        -1,   994,  1,               "Game", "restore",     0xd1c,    0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games, this is called with one parameter for CurDevice (Cascade Quest)
-	{ GID_FANMADE,        -1,   994,  1,               "Game", "restore",     0xe55,    0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games, this is called with one parameter for CurDevice (Demo Quest)
-	{ GID_FANMADE,        -1,   994,  1,               "Game", "restore",     0xe57,    0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games, this is called with one parameter for CurDevice (I Want My C64 Back)
-	{ GID_FANMADE,        -1,   994,  1,               "Game", "restore",     0xe5c,    0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games, this is called with one parameter for CurDevice (Most of them)
-	SCI_WORKAROUNDENTRY_TERMINATOR
-};
-
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+	{ GID_FANMADE,        -1,   994,  1,               "Game", "save",      sig_kDeviceInfo_Fanmade_1,     0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games (SCI Studio), this is called with one parameter for CurDevice LDI 01 variant
+	{ GID_FANMADE,        -1,   994,  1,               "Game", "save",      sig_kDeviceInfo_Fanmade_2,     0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games (SCI Studio), this is called with one parameter for CurDevice LDI 0001 variant
+	{ GID_FANMADE,        -1,   994,  0,              "Black", "save",      sig_kDeviceInfo_Fanmade_1,     0, { WORKAROUND_IGNORE,    0 } }, // In fanmade games (SCI Studio), this is called with one parameter for CurDevice (Black Cauldron Remake)
+	{ GID_FANMADE,        -1,   994,  1,               "Game", "restore",   sig_kDeviceInfo_Fanmade_1,     0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games (SCI Studio), this is called with one parameter for CurDevice LDI 01 variant
+	{ GID_FANMADE,        -1,   994,  1,               "Game", "restore",   sig_kDeviceInfo_Fanmade_2,     0, { WORKAROUND_STILLCALL, 0 } }, // In fanmade games (SCI Studio), this is called with one parameter for CurDevice LDI 0001 variant
+	SCI_WORKAROUNDENTRY_TERMINATOR
+};
+
+//                Game: Police Quest 2
+//      Calling method: rm23Script::elements
+//   Subroutine offset: English 1.001.000: 0x04ae, English 1.002.011: 0x04ca, Japanese: 0x04eb (script 23)
+// Applies to at least: English PC floppy, Japanese PC-9801
+static const uint16 sig_kDisplay_pq2_1[] = {
+	0x35, 0x00,                      // ldi 00
+	0xa3, 0x09,                      // sal local[9]
+	0x35, 0x01,                      // ldi 01
+	0xa3, 0x0a,                      // sal local[0Ah]
+	0x38, SIG_ADDTOOFFSET(+2),       // pushi selector[drawPic] TODO: implement selectors
+	0x7a,                            // push2
+	0x39, 0x5a,                      // pushi 5Ah
+	0x7a,                            // push2
+	0x81, 0x02,                      // lag global[2]
+	0x4a, 0x08,                      // send 08
+	SIG_END
+};
+
+//                Game: Space Quest 4
+//      Calling method: doCatalog::mode
+//   Subroutine offset: English PC CD: 0x0084 (script 391)
+// Applies to at least: English PC CD
+static const uint16 sig_kDisplay_sq4_1[] = {
+	0x38, SIG_UINT16(0x0187),        // pushi 0187h (drawPic)
+	0x78,                            // push1
+	0x38, SIG_UINT16(0x0189),        // pushi 0189h (reflectPosn)
+	0x81, 0x02,                      // lag global[2]
+	0x4a, 0x06,                      // send 06
+	SIG_END
+};
+
+//    gameID,           room,script,lvl,          object-name, method-name,  local-call-signature, index,                workaround
 const SciWorkaroundEntry kDisplay_workarounds[] = {
-	{ GID_ISLANDBRAIN,   300,   300,  0,           "geneDude", "show",           -1,    0, { WORKAROUND_IGNORE,    0 } }, // when looking at the gene explanation chart - a parameter is an object
-	{ GID_PQ2,            23,    23,  0,         "rm23Script", "elements",    0x4ae,    0, { WORKAROUND_IGNORE,    0 } }, // when looking at the 2nd page of pate's file - 0x75 as id
-	{ GID_PQ2,            23,    23,  0,         "rm23Script", "elements",    0x4c1,    0, { WORKAROUND_IGNORE,    0 } }, // when looking at the 2nd page of pate's file - 0x75 as id (another pq2 version, bug #5223)
-	{ GID_QFG1,           11,    11,  0,             "battle", "<noname90>",     -1,    0, { WORKAROUND_IGNORE,    0 } }, // DEMO: When entering battle, 0x75 as id
-	{ GID_SQ4,           397,     0,  0,                   "", "export 12",      -1,    0, { WORKAROUND_IGNORE,    0 } }, // FLOPPY: when going into the computer store - bug #5227
-	{ GID_SQ4,           391,   391,  0,          "doCatalog", "mode",         0x84,    0, { WORKAROUND_IGNORE,    0 } }, // CD: clicking on catalog in roboter sale - a parameter is an object
-	{ GID_SQ4,           391,   391,  0,         "choosePlug", "changeState",    -1,    0, { WORKAROUND_IGNORE,    0 } }, // CD: ordering connector in roboter sale - a parameter is an object
+	{ GID_ISLANDBRAIN,   300,   300,  0,           "geneDude", "show",                       NULL,     0, { WORKAROUND_IGNORE,    0 } }, // when looking at the gene explanation chart - a parameter is an object
+	{ GID_LONGBOW,        95,    95,  0,          "countDown", "changeState",                NULL,     0, { WORKAROUND_IGNORE,    0 } }, // DEMO: during title screen "Robin Hood! Your bow is needed"
+	{ GID_LONGBOW,       220,   220,  0,             "moveOn", "changeState",                NULL,     0, { WORKAROUND_IGNORE,    0 } }, // DEMO: during second room "Outwit and outfight..."
+	{ GID_LONGBOW,       210,   210,  0,               "mama", "changeState",                NULL,     0, { WORKAROUND_IGNORE,    0 } }, // DEMO: during third room "Fall under the spell..."
+	{ GID_LONGBOW,       320,   320,  0,              "flyin", "changeState",                NULL,     0, { WORKAROUND_IGNORE,    0 } }, // DEMO: during fourth room "Conspiracies, love..."
+	{ GID_PQ2,            23,    23,  0,         "rm23Script", "elements",     sig_kDisplay_pq2_1,     0, { WORKAROUND_IGNORE,    0 } }, // when looking at the 2nd page of pate's file - 0x75 as id - bug #5223
+	{ GID_QFG1,           11,    11,  0,             "battle", "init",                       NULL,     0, { WORKAROUND_IGNORE,    0 } }, // DEMO: When entering battle, 0x75 as id
+	{ GID_SQ4,           397,     0,  0,                   "", "export 12",                  NULL,     0, { WORKAROUND_IGNORE,    0 } }, // FLOPPY: when going into the computer store - bug #5227
+	{ GID_SQ4,           391,   391,  0,          "doCatalog", "mode",         sig_kDisplay_sq4_1,     0, { WORKAROUND_IGNORE,    0 } }, // CD: clicking on catalog in roboter sale - a parameter is an object
+	{ GID_SQ4,           391,   391,  0,         "choosePlug", "changeState",                NULL,     0, { WORKAROUND_IGNORE,    0 } }, // CD: ordering connector in roboter sale - a parameter is an object
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kDirLoop_workarounds[] = {
-	{ GID_KQ4,             4,   992,  0,              "Avoid", "doit",           -1,    0, { WORKAROUND_IGNORE,    0 } }, // when the ogre catches you in front of his house, second parameter points to the same object as the first parameter, instead of being an integer (the angle) - bug #5217
+	{ GID_KQ4,             4,   992,  0,              "Avoid", "doit",                      NULL,     0, { WORKAROUND_IGNORE,    0 } }, // when the ogre catches you in front of his house, second parameter points to the same object as the first parameter, instead of being an integer (the angle) - bug #5217
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kDisposeScript_workarounds[] = {
-	{ GID_LAURABOW,      777,   777,  0,             "myStab", "changeState",    -1,    0, { WORKAROUND_IGNORE,    0 } }, // DEMO: after the will is signed, parameter 0 is an object - bug #4967
-	{ GID_QFG1,           -1,    64,  0,               "rm64", "dispose",        -1,    0, { WORKAROUND_IGNORE,    0 } }, // when leaving graveyard, parameter 0 is an object
-	{ GID_SQ4,           150,   151,  0,        "fightScript", "dispose",        -1,    0, { WORKAROUND_IGNORE,    0 } }, // during fight with Vohaul, parameter 0 is an object
-	{ GID_SQ4,           150,   152,  0,       "driveCloseUp", "dispose",        -1,    0, { WORKAROUND_IGNORE,    0 } }, // when choosing "beam download", parameter 0 is an object
+	{ GID_LAURABOW,      777,   777,  0,             "myStab", "changeState",               NULL,     0, { WORKAROUND_IGNORE,    0 } }, // DEMO: after the will is signed, parameter 0 is an object - bug #4967
+	{ GID_LSL2,           -1,    54,  0,               "rm54", "dispose",                   NULL,     0, { WORKAROUND_IGNORE,    0 } }, // Amiga: room 55, script tries to kDisposeScript an object (does not happen for DOS) - bug #6818
+	{ GID_QFG1,           -1,    64,  0,               "rm64", "dispose",                   NULL,     0, { WORKAROUND_IGNORE,    0 } }, // when leaving graveyard, parameter 0 is an object
+	{ GID_SQ4,           150,   151,  0,        "fightScript", "dispose",                   NULL,     0, { WORKAROUND_IGNORE,    0 } }, // during fight with Vohaul, parameter 0 is an object
+	{ GID_SQ4,           150,   152,  0,       "driveCloseUp", "dispose",                   NULL,     0, { WORKAROUND_IGNORE,    0 } }, // when choosing "beam download", parameter 0 is an object
+	{ GID_SQ4,           150,   152,  0,                   "", "dispose",                   NULL,     0, { WORKAROUND_IGNORE,    0 } }, // when choosing "beam download"... in Russian version - bug #5573
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kDoSoundFade_workarounds[] = {
-	{ GID_KQ5,           213,   989,  0,       "globalSound3", "fade",           -1,    0, { WORKAROUND_STILLCALL, 0 } }, // english floppy: when bandits leave the secret temple, parameter 4 is an object - bug #5078
-	{ GID_KQ6,           105,   989,  0,        "globalSound", "fade",           -1,    0, { WORKAROUND_STILLCALL, 0 } }, // floppy: during intro, parameter 4 is an object
-	{ GID_KQ6,           460,   989,  0,       "globalSound2", "fade",           -1,    0, { WORKAROUND_STILLCALL, 0 } }, // after pulling the black widow's web on the isle of wonder, parameter 4 is an object - bug #4954
-	{ GID_QFG4,           -1, 64989,  0,           "longSong", "fade",           -1,    0, { WORKAROUND_STILLCALL, 0 } }, // CD version: many places, parameter 4 is an object (longSong)
-	{ GID_SQ5,           800,   989,  0,          "sq5Music1", "fade",           -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when cutting the wrong part of Goliath with the laser - bug #6341
+	{ GID_KQ5,           213,   989,  0,       "globalSound3", "fade",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // english floppy: when bandits leave the secret temple, parameter 4 is an object - bug #5078
+	{ GID_KQ6,           105,   989,  0,        "globalSound", "fade",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // floppy: during intro, parameter 4 is an object
+	{ GID_KQ6,           460,   989,  0,       "globalSound2", "fade",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // after pulling the black widow's web on the isle of wonder, parameter 4 is an object - bug #4954
+	{ GID_QFG4,           -1, 64989,  0,           "longSong", "fade",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // CD version: many places, parameter 4 is an object (longSong)
+	{ GID_SQ5,           800,   989,  0,          "sq5Music1", "fade",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when cutting the wrong part of Goliath with the laser - bug #6341
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kGetAngle_workarounds[] = {
-	{ GID_FANMADE,       516,   992,  0,             "Motion", "init",           -1,    0, { WORKAROUND_FAKE,      0 } }, // The Legend of the Lost Jewel Demo (fan made): called with third/fourth parameters as objects
-	{ GID_KQ6,            -1,   752,  0,        "throwDazzle", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // room 740/790 after the Genie is exposed in the Palace (short and long ending), it starts shooting lightning bolts around. An extra 5th parameter is passed - bug #4959 & #5203
-	{ GID_SQ1,            -1,   927,  0,           "PAvoider", "doit",           -1,    0, { WORKAROUND_FAKE,      0 } }, // all rooms in Ulence Flats after getting the Pilot Droid: called with a single parameter when the droid is in Roger's path - bug #6016
+	{ GID_FANMADE,       516,   992,  0,             "Motion", "init",                      NULL,     0, { WORKAROUND_FAKE,      0 } }, // The Legend of the Lost Jewel Demo (fan made): called with third/fourth parameters as objects
+	{ GID_KQ6,            -1,   752,  0,        "throwDazzle", "changeState",               NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // room 740/790 after the Genie is exposed in the Palace (short and long ending), it starts shooting lightning bolts around. An extra 5th parameter is passed - bug #4959 & #5203
+	{ GID_SQ1,            -1,   927,  0,           "PAvoider", "doit",                      NULL,     0, { WORKAROUND_FAKE,      0 } }, // all rooms in Ulence Flats after getting the Pilot Droid: called with a single parameter when the droid is in Roger's path - bug #6016
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kFindKey_workarounds[] = {
-	{ GID_ECOQUEST2,     100,   999,  0,            "myList", "contains",        -1,    0, { WORKAROUND_FAKE, 0 } }, // When Noah Greene gives Adam the Ecorder, and just before the game gives a demonstration, a null reference to a list is passed - bug #4987
-	{    GID_HOYLE4,     300,   999,  0,             "Piles", "contains",        -1,    0, { WORKAROUND_FAKE, 0 } }, // When passing the three cards in Hearts, a null reference to a list is passed - bug #5664
+	{ GID_ECOQUEST2,     100,   999,  0,            "myList", "contains",                   NULL,     0, { WORKAROUND_FAKE, 0 } }, // When Noah Greene gives Adam the Ecorder, and just before the game gives a demonstration, a null reference to a list is passed - bug #4987
+	{ GID_HOYLE4,        300,   999,  0,             "Piles", "contains",                   NULL,     0, { WORKAROUND_FAKE, 0 } }, // When passing the three cards in Hearts, a null reference to a list is passed - bug #5664
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name,  local-call-signature, index,                workaround
 const SciWorkaroundEntry kGraphDrawLine_workarounds[] = {
-	{ GID_ISLANDBRAIN,   300,   300,  0,         "dudeViewer", "show",           -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when looking at the gene explanation chart, gets called with 1 extra parameter
-	{ GID_SQ1,            43,    43,  0,        "someoneDied", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when ordering beer, gets called with 1 extra parameter
-	{ GID_SQ1,            71,    71,  0,       "destroyXenon", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // during the Xenon destruction cutscene (which results in death), gets called with 1 extra parameter - bug #5176
-	{ GID_SQ1,            53,    53,  0,           "blastEgo", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when Roger is found and zapped by the cleaning robot, gets called with 1 extra parameter - bug #5177
+	{ GID_ISLANDBRAIN,   300,   300,  0,         "dudeViewer", "show",                       NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when looking at the gene explanation chart, gets called with 1 extra parameter
+	{ GID_SQ1,            43,    43,  0,        "someoneDied", "changeState",                NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when ordering beer, gets called with 1 extra parameter
+	{ GID_SQ1,            71,    71,  0,       "destroyXenon", "changeState",                NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // during the Xenon destruction cutscene (which results in death), gets called with 1 extra parameter - bug #5176
+	{ GID_SQ1,            53,    53,  0,           "blastEgo", "changeState",                NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when Roger is found and zapped by the cleaning robot, gets called with 1 extra parameter - bug #5177
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//                Game: Island of Dr. Brain
+//      Calling method: upElevator::changeState, downElevator::changeState, correctElevator::changeState
+//   Subroutine offset: 0x201f (script 291)
+// Applies to at least: English PC floppy
+static const uint16 sig_kGraphSaveBox_ibrain_1[] = {
+	0x3f, 0x01,                      // link 01
+	0x87, 0x01,                      // lap param[1]
+	0x30, SIG_UINT16(0x0043),        // bnt [...]
+	0x76,                            // push0
+	SIG_END
+};
+
+//    gameID,           room,script,lvl,          object-name, method-name,         local-call-signature, index,                workaround
 const SciWorkaroundEntry kGraphSaveBox_workarounds[] = {
-	{ GID_CASTLEBRAIN,   420,   427,  0,          "alienIcon", "select",         -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when selecting a card during the alien card game, gets called with 1 extra parameter
-	{ GID_ISLANDBRAIN,   290,   291,  0,         "upElevator", "changeState",0x201f,    0, { WORKAROUND_STILLCALL, 0 } }, // when testing in the elevator puzzle, gets called with 1 argument less - 15 is on stack - bug #4943
-	{ GID_ISLANDBRAIN,   290,   291,  0,       "downElevator", "changeState",0x201f,    0, { WORKAROUND_STILLCALL, 0 } }, // see above
-	{ GID_ISLANDBRAIN,   290,   291,  0,    "correctElevator", "changeState",0x201f,    0, { WORKAROUND_STILLCALL, 0 } }, // see above (when testing the correct solution)
-	{ GID_PQ3,           202,   202,  0,            "MapEdit", "movePt",         -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when plotting crimes, gets called with 2 extra parameters - bug #5099
+	{ GID_CASTLEBRAIN,   420,   427,  0,          "alienIcon", "select",                            NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when selecting a card during the alien card game, gets called with 1 extra parameter
+	{ GID_ISLANDBRAIN,   290,   291,  0,         "upElevator", "changeState", sig_kGraphSaveBox_ibrain_1,     0, { WORKAROUND_STILLCALL, 0 } }, // when testing in the elevator puzzle, gets called with 1 argument less - 15 is on stack - bug #4943
+	{ GID_ISLANDBRAIN,   290,   291,  0,       "downElevator", "changeState", sig_kGraphSaveBox_ibrain_1,     0, { WORKAROUND_STILLCALL, 0 } }, // see above
+	{ GID_ISLANDBRAIN,   290,   291,  0,    "correctElevator", "changeState", sig_kGraphSaveBox_ibrain_1,     0, { WORKAROUND_STILLCALL, 0 } }, // see above (when testing the correct solution)
+	{ GID_PQ3,           202,   202,  0,            "MapEdit", "movePt",                            NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when plotting crimes, gets called with 2 extra parameters - bug #5099
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kGraphRestoreBox_workarounds[] = {
-	{ GID_LSL6,           -1,    86,  0,             "LL6Inv", "hide",           -1,    0, { WORKAROUND_STILLCALL, 0 } }, // happens during the game, gets called with 1 extra parameter
+	{ GID_LSL6,           -1,    86,  0,             "LL6Inv", "hide",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // happens during the game, gets called with 1 extra parameter
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name,   local-call-signature, index,                workaround
 const SciWorkaroundEntry kGraphFillBoxForeground_workarounds[] = {
-	{ GID_LSL6,           -1,     0,  0,               "LSL6", "hideControls",   -1,    0, { WORKAROUND_STILLCALL, 0 } }, // happens when giving the bungee key to merrily (room 240) and at least in room 650 too - gets called with additional 5th parameter
+	{ GID_LSL6,           -1,     0,  0,               "LSL6", "hideControls",                NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // happens when giving the bungee key to merrily (room 240) and at least in room 650 too - gets called with additional 5th parameter
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name,  local-call-signature, index,                workaround
 const SciWorkaroundEntry kGraphFillBoxAny_workarounds[] = {
-	{ GID_ECOQUEST2,     100,   333,  0,        "showEcorder", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // necessary workaround for our ecorder script patch, because there isn't enough space to patch the function
-	{ GID_SQ4,            -1,   818,  0,     "iconTextSwitch", "show",           -1,    0, { WORKAROUND_STILLCALL, 0 } }, // CD: game menu "text/speech" display - parameter 5 is missing, but the right color number is on the stack
+	{ GID_ECOQUEST2,     100,   333,  0,        "showEcorder", "changeState",                NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // necessary workaround for our ecorder script patch, because there isn't enough space to patch the function
+	{ GID_SQ4,            -1,   818,  0,     "iconTextSwitch", "show",                       NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // CD: game menu "text/speech" display - parameter 5 is missing, but the right color number is on the stack
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//                Game: Space Quest 4
+//      Calling method: laserScript::changeState
+//   Subroutine offset: English/German/French/Russian PC floppy, Japanese PC-9801: 0x0016, English PC CD: 0x00b2 (script 150)
+// Applies to at least: English/German/French/Russian PC floppy, English PC CD, Japanese PC-9801
+static const uint16 sig_kGraphRedrawBox_sq4_1[] = {
+	0x3f, 0x07,                      // link 07
+	0x39, SIG_ADDTOOFFSET(+1),       // pushi 2Ah for PC floppy, pushi 27h for PC CD
+	0x76,                            // push0
+	0x72,                            // lofsa laserSound
+	SIG_END
+};
+
+//    gameID,           room,script,lvl,          object-name, method-name,        local-call-signature, index,                workaround
 const SciWorkaroundEntry kGraphRedrawBox_workarounds[] = {
-	{ GID_SQ4,           405,   405,  0,       "swimAfterEgo", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air - accidental additional parameter specified
-	{ GID_SQ4,           406,   406,  0,        "egoFollowed", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // FLOPPY: when getting shot by the police - accidental additional parameter specified
-	{ GID_SQ4,           406,   406,  0,       "swimAndShoot", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air - accidental additional parameter specified
-	{ GID_SQ4,           410,   410,  0,       "swimAfterEgo", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air - accidental additional parameter specified
-	{ GID_SQ4,           411,   411,  0,       "swimAndShoot", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air - accidental additional parameter specified
-	{ GID_SQ4,           150,   150,  0,        "laserScript", "changeState",  0xb2,    0, { WORKAROUND_STILLCALL, 0 } }, // when visiting the pedestral where Roger Jr. is trapped, before trashing the brain icon in the programming chapter, accidental additional parameter specified - bug #5479
-	{ GID_SQ4,           150,   150,  0,        "laserScript", "changeState",  0x16,    0, { WORKAROUND_STILLCALL, 0 } }, // same as above, for the German version - bug #5527
-	{ GID_SQ4,            -1,   704,  0,           "shootEgo", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // When shot by Droid in Super Computer Maze (Rooms 500, 505, 510...) - accidental additional parameter specified
-	{ GID_KQ5,            -1,   981,  0,           "myWindow",     "dispose",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // Happens in the floppy version, when closing any dialog box, accidental additional parameter specified - bug #5031
-	{ GID_KQ5,            -1,   995,  0,               "invW",        "doit",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // Happens in the floppy version, when closing the inventory window, accidental additional parameter specified
-	{ GID_KQ5,            -1,   995,  0,                   "",    "export 0",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // Happens in the floppy version, when opening the gem pouch, accidental additional parameter specified - bug #5138
-	{ GID_KQ5,            -1,   403,  0,          "KQ5Window",     "dispose",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // Happens in the FM Towns version when closing any dialog box, accidental additional parameter specified
-	SCI_WORKAROUNDENTRY_TERMINATOR
-};
-
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+	{ GID_SQ4,           405,   405,  0,       "swimAfterEgo", "changeState",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air - accidental additional parameter specified
+	{ GID_SQ4,           405,   405,  0,                   "", "changeState",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air... Russian version - bug #5573
+	{ GID_SQ4,           406,   406,  0,        "egoFollowed", "changeState",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // FLOPPY: when getting shot by the police - accidental additional parameter specified
+	{ GID_SQ4,            -1,   406,  0,       "swimAndShoot", "changeState",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air - accidental additional parameter specified
+	{ GID_SQ4,            -1,   406,  0,                   "", "changeState",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air... Russian version - bug #5573 (is for both egoFollowed and swimAndShoot)
+	{ GID_SQ4,           410,   410,  0,       "swimAfterEgo", "changeState",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air - accidental additional parameter specified
+	{ GID_SQ4,           410,   410,  0,                   "", "changeState",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air... Russian version - bug #5573
+	{ GID_SQ4,           411,   411,  0,       "swimAndShoot", "changeState",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air - accidental additional parameter specified
+	{ GID_SQ4,           411,   411,  0,                   "", "changeState",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // skateOrama when "swimming" in the air... Russian version - bug #5573
+	{ GID_SQ4,           150,   150,  0,        "laserScript", "changeState", sig_kGraphRedrawBox_sq4_1,     0, { WORKAROUND_STILLCALL, 0 } }, // when visiting the pedestral where Roger Jr. is trapped, before trashing the brain icon in the programming chapter, accidental additional parameter specified - bug #5479, German - bug #5527
+	{ GID_SQ4,           150,   150,  0,                   "", "changeState", sig_kGraphRedrawBox_sq4_1,     0, { WORKAROUND_STILLCALL, 0 } }, // same as above, for the Russian version - bug #5573
+	{ GID_SQ4,            -1,   704,  0,           "shootEgo", "changeState",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // When shot by Droid in Super Computer Maze (Rooms 500, 505, 510...) - accidental additional parameter specified
+	{ GID_KQ5,            -1,   981,  0,           "myWindow",     "dispose",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // Happens in the floppy version, when closing any dialog box, accidental additional parameter specified - bug #5031
+	{ GID_KQ5,            -1,   995,  0,               "invW",        "doit",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // Happens in the floppy version, when closing the inventory window, accidental additional parameter specified
+	{ GID_KQ5,            -1,   995,  0,                   "",    "export 0",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // Happens in the floppy version, when opening the gem pouch, accidental additional parameter specified - bug #5138
+	{ GID_KQ5,            -1,   403,  0,          "KQ5Window",     "dispose",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // Happens in the FM Towns version when closing any dialog box, accidental additional parameter specified
+	SCI_WORKAROUNDENTRY_TERMINATOR
+};
+
+//    gameID,           room,script,lvl,          object-name, method-name,  local-call-signature, index,                workaround
 const SciWorkaroundEntry kGraphUpdateBox_workarounds[] = {
-	{ GID_ECOQUEST2,     100,   333,  0,        "showEcorder", "changeState",    -1,    0, { WORKAROUND_STILLCALL, 0 } }, // necessary workaround for our ecorder script patch, because there isn't enough space to patch the function
-	{ GID_PQ3,           202,   202,  0,            "MapEdit", "addPt",          -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when plotting crimes, gets called with 2 extra parameters - bug #5099
-	{ GID_PQ3,           202,   202,  0,            "MapEdit", "movePt",         -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when plotting crimes, gets called with 2 extra parameters - bug #5099
-	{ GID_PQ3,           202,   202,  0,            "MapEdit", "dispose",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // when plotting crimes, gets called with 2 extra parameters
+	{ GID_ECOQUEST2,     100,   333,  0,        "showEcorder", "changeState",                NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // necessary workaround for our ecorder script patch, because there isn't enough space to patch the function
+	{ GID_PQ3,           202,   202,  0,            "MapEdit", "addPt",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when plotting crimes, gets called with 2 extra parameters - bug #5099
+	{ GID_PQ3,           202,   202,  0,            "MapEdit", "movePt",                     NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when plotting crimes, gets called with 2 extra parameters - bug #5099
+	{ GID_PQ3,           202,   202,  0,            "MapEdit", "dispose",                    NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // when plotting crimes, gets called with 2 extra parameters
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name,    local-call-signature, index,                workaround
 const SciWorkaroundEntry kIsObject_workarounds[] = {
-	{ GID_GK1,           50,   999,  0,                "List", "eachElementDo",  -1,    0, { WORKAROUND_FAKE, 0 } }, // GK1 demo, when asking Grace for messages it gets called with an invalid parameter (type "error") - bug #4950
-	{ GID_ISLANDBRAIN,   -1,   999,  0,                "List", "eachElementDo",  -1,    0, { WORKAROUND_FAKE, 0 } }, // when going to the game options, choosing "Info" and selecting anything from the list, gets called with an invalid parameter (type "error") - bug #4989
-	{ GID_QFG3,          -1,   999,  0,                "List", "eachElementDo",  -1,    0, { WORKAROUND_FAKE, 0 } }, // when asking for something, gets called with type error parameter
+	{ GID_GK1,           50,   999,  0,                "List", "eachElementDo",                NULL,     0, { WORKAROUND_FAKE, 0 } }, // GK1 demo, when asking Grace for messages it gets called with an invalid parameter (type "error") - bug #4950
+	{ GID_ISLANDBRAIN,   -1,   999,  0,                "List", "eachElementDo",                NULL,     0, { WORKAROUND_FAKE, 0 } }, // when going to the game options, choosing "Info" and selecting anything from the list, gets called with an invalid parameter (type "error") - bug #4989
+	{ GID_QFG3,          -1,   999,  0,                "List", "eachElementDo",                NULL,     0, { WORKAROUND_FAKE, 0 } }, // when asking for something, gets called with type error parameter
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kMemory_workarounds[] = {
-	{ GID_LAURABOW2,      -1,   999,  0,                   "", "export 6",       -1,    0, { WORKAROUND_FAKE,    0 } }, // during the intro, when exiting the train (room 160), talking to Mr. Augustini, etc. - bug #4944
-	{ GID_SQ1,            -1,   999,  0,                   "", "export 6",       -1,    0, { WORKAROUND_FAKE,    0 } }, // during walking Roger around Ulence Flats - bug #6017
+	{ GID_LAURABOW2,      -1,   999,  0,                   "", "export 6",                  NULL,     0, { WORKAROUND_FAKE,    0 } }, // during the intro, when exiting the train (room 160), talking to Mr. Augustini, etc. - bug #4944
+	{ GID_SQ1,            -1,   999,  0,                   "", "export 6",                  NULL,     0, { WORKAROUND_FAKE,    0 } }, // during walking Roger around Ulence Flats - bug #6017
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name,  local-call-signature, index,                workaround
 const SciWorkaroundEntry kMoveCursor_workarounds[] = {
-	{ GID_KQ5,            -1,   937,  0,            "IconBar", "handleEvent",    -1,    0, { WORKAROUND_IGNORE,  0 } }, // when pressing escape to open the menu, gets called with one parameter instead of 2 - bug #5575
+	{ GID_KQ5,            -1,   937,  0,            "IconBar", "handleEvent",                NULL,     0, { WORKAROUND_IGNORE,  0 } }, // when pressing escape to open the menu, gets called with one parameter instead of 2 - bug #5575
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kNewWindow_workarounds[] = {
-	{ GID_ECOQUEST,       -1,   981,  0,          "SysWindow", "open",           -1,    0, { WORKAROUND_STILLCALL, 0 } }, // EcoQuest 1 demo uses an in-between interpreter from SCI1 to SCI1.1. It's SCI1.1, but uses the SCI1 semantics for this call - bug #4976
+	{ GID_ECOQUEST,       -1,   981,  0,          "SysWindow", "open",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // EcoQuest 1 demo uses an in-between interpreter from SCI1 to SCI1.1. It's SCI1.1, but uses the SCI1 semantics for this call - bug #4976
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kReadNumber_workarounds[] = {
-	{ GID_CNICK_LAURABOW,100,   101,  0,          "dominoes.opt", "doit",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // When dominoes.opt is present, the game scripts call kReadNumber with an extra integer parameter - bug #6425
-	{ GID_HOYLE3,        100,   101,  0,          "dominoes.opt", "doit",        -1,    0, { WORKAROUND_STILLCALL, 0 } }, // When dominoes.opt is present, the game scripts call kReadNumber with an extra integer parameter - bug #6425
+	{ GID_CNICK_LAURABOW,100,   101,  0,          "dominoes.opt", "doit",                   NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // When dominoes.opt is present, the game scripts call kReadNumber with an extra integer parameter - bug #6425
+	{ GID_HOYLE3,        100,   101,  0,          "dominoes.opt", "doit",                   NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // When dominoes.opt is present, the game scripts call kReadNumber with an extra integer parameter - bug #6425
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name,  local-call-signature, index,                workaround
 const SciWorkaroundEntry kPaletteUnsetFlag_workarounds[] = {
-	{ GID_QFG4,          100,   100,  0,            "doMovie", "changeState",    -1,    0, { WORKAROUND_IGNORE,    0 } }, // after the Sierra logo, no flags are passed, thus the call is meaningless - bug #4947
+	{ GID_QFG4,          100,   100,  0,            "doMovie", "changeState",                NULL,     0, { WORKAROUND_IGNORE,    0 } }, // after the Sierra logo, no flags are passed, thus the call is meaningless - bug #4947
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kSetCursor_workarounds[] = {
-	{ GID_KQ5,            -1,   768,  0,           "KQCursor", "init",           -1,    0, { WORKAROUND_STILLCALL, 0 } }, // CD: gets called with 4 additional "900d" parameters
+	{ GID_KQ5,            -1,   768,  0,           "KQCursor", "init",                      NULL,     0, { WORKAROUND_STILLCALL, 0 } }, // CD: gets called with 4 additional "900d" parameters
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name,  local-call-signature, index,                workaround
 const SciWorkaroundEntry kSetPort_workarounds[] = {
-	{ GID_LSL6,          740,   740,  0,              "rm740", "drawPic",        -1,    0, { WORKAROUND_IGNORE,    0 } }, // ending scene, is called with additional 3 (!) parameters
-	{ GID_QFG3,          830,   830,  0,        "portalOpens", "changeState",    -1,    0, { WORKAROUND_IGNORE,    0 } }, // when the portal appears during the end, gets called with 4 parameters - bug #5174
+	{ GID_LSL6,          740,   740,  0,              "rm740", "drawPic",                    NULL,     0, { WORKAROUND_IGNORE,    0 } }, // ending scene, is called with additional 3 (!) parameters
+	{ GID_QFG3,          830,   830,  0,        "portalOpens", "changeState",                NULL,     0, { WORKAROUND_IGNORE,    0 } }, // when the portal appears during the end, gets called with 4 parameters - bug #5174
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//                Game: Island of Dr. Brain
+//      Calling method: childBreed::changeState
+//   Subroutine offset: 0x1c7c (script 310)
+// Applies to at least: English PC floppy
+static const uint16 sig_kStrAt_ibrain_1[] = {
+	0x3f, 0x16,                      // link 16
+	0x78,                            // push1
+	0x8f, 0x01,                      // lsp param[1]
+	0x43,                            // callk StrLen
+	SIG_END
+};
+
+//    gameID,           room,script,lvl,          object-name, method-name,  local-call-signature, index,                workaround
 const SciWorkaroundEntry kStrAt_workarounds[] = {
-	{ GID_CASTLEBRAIN,   220,   220,  0,         "robotJokes", "animateOnce",    -1,    0, { WORKAROUND_FAKE,      0 } }, // when trying to view the terminal at the end of the maze without having collected any robot jokes - bug #5127
-	{ GID_ISLANDBRAIN,   300,   310,  0,         "childBreed", "changeState",0x1c7c,    0, { WORKAROUND_FAKE,      0 } }, // when clicking Breed to get the second-generation cyborg hybrid (Standard difficulty), the two parameters are swapped - bug #5088
+	{ GID_CASTLEBRAIN,   220,   220,  0,         "robotJokes", "animateOnce",                NULL,     0, { WORKAROUND_FAKE,      0 } }, // when trying to view the terminal at the end of the maze without having collected any robot jokes - bug #5127
+	{ GID_ISLANDBRAIN,   300,   310,  0,         "childBreed", "changeState", sig_kStrAt_ibrain_1,     0, { WORKAROUND_FAKE,      0 } }, // when clicking Breed to get the second-generation cyborg hybrid (Standard difficulty), the two parameters are swapped - bug #5088
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
+//    gameID,           room,script,lvl,          object-name, method-name,   local-call-signature, index,                workaround
 const SciWorkaroundEntry kStrCpy_workarounds[] = {
-	{ GID_MOTHERGOOSE,   23,   23,  0,          "talkScript", "changeState",    -1,    0, { WORKAROUND_FAKE,      0 } }, // when talking to the girl in scene 23, there's no destination parameter (script bug - wrong instruction order). The original source is used directly afterwards in kDisplay, to show the girl's text - bug #6485
+	{ GID_MOTHERGOOSE,    23,    23,  0,          "talkScript", "changeState",                NULL,     0, { WORKAROUND_FAKE,      0 } }, // when talking to the girl in scene 23, there's no destination parameter (script bug - wrong instruction order). The original source is used directly afterwards in kDisplay, to show the girl's text - bug #6485
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//                Game: Quest for Glory 2
+//      Calling method: export 21 of script 2
+//   Subroutine offset: English 0x0deb (script 2)
+// Applies to at least: English PC floppy
+static const uint16 sig_kStrLen_qfg2_1[] = {
+	0x3f, 0x04,                      // link 04
+	0x78,                            // push1
+	0x8f, 0x02,                      // lsp param[2]
+	0x43,                            // callk StrLen
+	SIG_END
+};
+
+//    gameID,           room,script,lvl,          object-name, method-name, local-call-signature, index,                workaround
 const SciWorkaroundEntry kStrLen_workarounds[] = {
-	{ GID_QFG2,          210,     2,  0,                   "", "export 21",   0xdeb,    0, { WORKAROUND_FAKE,      0 } }, // When saying something incorrect at the WIT, an integer is passed instead of a reference - bug #5489
+	{ GID_QFG2,          210,     2,  0,                   "", "export 21",   sig_kStrLen_qfg2_1,     0, { WORKAROUND_FAKE,      0 } }, // When saying something incorrect at the WIT, an integer is passed instead of a reference - bug #5489
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
-//    gameID,           room,script,lvl,          object-name, method-name,    call,index,                workaround
+//    gameID,           room,script,lvl,          object-name, method-name,  local-call-signature, index,                workaround
 const SciWorkaroundEntry kUnLoad_workarounds[] = {
-	{ GID_ECOQUEST,      380,    61,  0,              "gotIt", "changeState",    -1,    0, { WORKAROUND_IGNORE, 0 } }, // CD version: after talking to the dolphin the first time, a 3rd parameter is passed by accident
-	{ GID_ECOQUEST,      380,    69,  0,   "lookAtBlackBoard", "changeState",    -1,    0, { WORKAROUND_IGNORE, 0 } }, // German version, when closing the blackboard closeup in the dolphin room, a 3rd parameter is passed by accident - bug #5483
-	{ GID_LAURABOW2,      -1,    -1,  0,           "sCartoon", "changeState",    -1,    0, { WORKAROUND_IGNORE, 0 } }, // DEMO: during the intro, a 3rd parameter is passed by accident - bug #4966
-	{ GID_LSL6,          130,   130,  0,    "recruitLarryScr", "changeState",    -1,    0, { WORKAROUND_IGNORE, 0 } }, // during intro, a 3rd parameter is passed by accident
-	{ GID_LSL6,          740,   740,  0,        "showCartoon", "changeState",    -1,    0, { WORKAROUND_IGNORE, 0 } }, // during ending, 4 additional parameters are passed by accident
-	{ GID_LSL6HIRES,     130,   130,  0,    "recruitLarryScr", "changeState",    -1,    0, { WORKAROUND_IGNORE, 0 } }, // during intro, a 3rd parameter is passed by accident
-	{ GID_SQ1,            43,   303,  0,            "slotGuy", "dispose",        -1,    0, { WORKAROUND_IGNORE, 0 } }, // when leaving ulence flats bar, parameter 1 is not passed - script error
-	{ GID_QFG4,           -1,   110,  0,            "dreamer", "dispose",        -1,    0, { WORKAROUND_IGNORE, 0 } }, // during the dream sequence, a 3rd parameter is passed by accident
+	{ GID_ECOQUEST,      380,    61,  0,              "gotIt", "changeState",                NULL,     0, { WORKAROUND_IGNORE, 0 } }, // CD version: after talking to the dolphin the first time, a 3rd parameter is passed by accident
+	{ GID_ECOQUEST,      380,    69,  0,   "lookAtBlackBoard", "changeState",                NULL,     0, { WORKAROUND_IGNORE, 0 } }, // German version, when closing the blackboard closeup in the dolphin room, a 3rd parameter is passed by accident - bug #5483
+	{ GID_LAURABOW2,      -1,    -1,  0,           "sCartoon", "changeState",                NULL,     0, { WORKAROUND_IGNORE, 0 } }, // DEMO: during the intro, a 3rd parameter is passed by accident - bug #4966
+	{ GID_LSL6,          130,   130,  0,    "recruitLarryScr", "changeState",                NULL,     0, { WORKAROUND_IGNORE, 0 } }, // during intro, a 3rd parameter is passed by accident
+	{ GID_LSL6,          740,   740,  0,        "showCartoon", "changeState",                NULL,     0, { WORKAROUND_IGNORE, 0 } }, // during ending, 4 additional parameters are passed by accident
+	{ GID_LSL6HIRES,     130,   130,  0,    "recruitLarryScr", "changeState",                NULL,     0, { WORKAROUND_IGNORE, 0 } }, // during intro, a 3rd parameter is passed by accident
+	{ GID_SQ1,            43,   303,  0,            "slotGuy", "dispose",                    NULL,     0, { WORKAROUND_IGNORE, 0 } }, // when leaving ulence flats bar, parameter 1 is not passed - script error
+	{ GID_QFG4,           -1,   110,  0,            "dreamer", "dispose",                    NULL,     0, { WORKAROUND_IGNORE, 0 } }, // during the dream sequence, a 3rd parameter is passed by accident
 	SCI_WORKAROUNDENTRY_TERMINATOR
 };
 
@@ -461,8 +751,9 @@ SciWorkaroundSolution trackOriginAndFindWorkaround(int index, const SciWorkaroun
 	ExecStack *lastCall = state->xs;
 	const Script *localScript = state->_segMan->getScriptIfLoaded(lastCall->local_segment);
 	int curScriptNr = localScript->getScriptNumber();
+	int curLocalCallOffset = lastCall->debugLocalCallOffset;
 
-	if (lastCall->debugLocalCallOffset != -1) {
+	if (curLocalCallOffset != -1) {
 		// if lastcall was actually a local call search back for a real call
 		Common::List<ExecStack>::const_iterator callIterator = state->_executionStack.end();
 		while (callIterator != state->_executionStack.begin()) {
@@ -494,19 +785,17 @@ SciWorkaroundSolution trackOriginAndFindWorkaround(int index, const SciWorkaroun
 		// Search if there is a workaround for this one
 		const SciWorkaroundEntry *workaround;
 		int16 inheritanceLevel = 0;
-		Common::String searchObjectName = curObjectName;
+		Common::String searchObjectName = g_sci->getSciLanguageString(curObjectName, K_LANG_ENGLISH);
 		reg_t searchObject = lastCall->sendp;
+		const byte *curScriptPtr = NULL;
+		uint32 curScriptSize = 0;
+		bool matched = false;
+
 		do {
 			workaround = workaroundList;
 			while (workaround->methodName) {
 				bool objectNameMatches = (workaround->objectName == NULL) ||
-										 (workaround->objectName == g_sci->getSciLanguageString(searchObjectName, K_LANG_ENGLISH));
-
-				// Special case: in the fanmade Russian translation of SQ4, all
-				// of the object names have been deleted or renamed to Russian,
-				// thus we disable checking of the object name. Fixes bug #5573.
-				if (g_sci->getLanguage() == Common::RU_RUS && g_sci->getGameId() == GID_SQ4)
-					objectNameMatches = true;
+										 (workaround->objectName == searchObjectName);
 
 				if (workaround->gameId == gameId
 						&& ((workaround->scriptNr == -1) || (workaround->scriptNr == curScriptNr))
@@ -514,10 +803,46 @@ SciWorkaroundSolution trackOriginAndFindWorkaround(int index, const SciWorkaroun
 						&& ((workaround->inheritanceLevel == -1) || (workaround->inheritanceLevel == inheritanceLevel))
 						&& objectNameMatches
 						&& workaround->methodName == g_sci->getSciLanguageString(curMethodName, K_LANG_ENGLISH)
-						&& workaround->localCallOffset == lastCall->debugLocalCallOffset
 						&& ((workaround->index == -1) || (workaround->index == index))) {
 					// Workaround found
-					return workaround->newValue;
+					if ((workaround->localCallSignature) || (curLocalCallOffset >= 0)) {
+						// local call signature found and/or subcall was made
+						if ((workaround->localCallSignature) && (curLocalCallOffset >= 0)) {
+							// local call signature found and subcall was made -> check signature accordingly
+							if (!curScriptPtr) {
+								// get script data
+								int segmentId = g_sci->getEngineState()->_segMan->getScriptSegment(curScriptNr);
+								SegmentObj *segmentObj = NULL;
+								if (segmentId) {
+									segmentObj = g_sci->getEngineState()->_segMan->getScriptIfLoaded(segmentId);
+								}
+								if (!segmentObj) {
+									workaround++;
+									continue;
+								}
+								Script *scriptObj = (Script *)segmentObj;
+								curScriptPtr = scriptObj->getBuf();
+								curScriptSize = scriptObj->getScriptSize();
+							}
+
+							// now actually check for signature match
+							if (g_sci->getScriptPatcher()->verifySignature(curLocalCallOffset, workaround->localCallSignature, "workaround signature", curScriptPtr, curScriptSize)) {
+								matched = true;
+							}
+
+						} else {
+							// mismatch, so workaround doesn't match
+							workaround++;
+							continue;
+						}
+					} else {
+						// no localcalls involved -> workaround matches
+						matched = true;
+					}
+					if (matched) {
+						debugC(kDebugLevelWorkarounds, "Workaround: '%s:%s' in script %d, localcall %x", workaround->objectName, workaround->methodName, curScriptNr, curLocalCallOffset);
+						return workaround->newValue;
+					}
 				}
 				workaround++;
 			}
diff --git a/engines/sci/engine/workarounds.h b/engines/sci/engine/workarounds.h
index 9cad618481..46059a175c 100644
--- a/engines/sci/engine/workarounds.h
+++ b/engines/sci/engine/workarounds.h
@@ -60,7 +60,7 @@ struct SciWorkaroundEntry {
 	int16 inheritanceLevel;
 	const char *objectName;
 	const char *methodName;
-	int localCallOffset;
+	const uint16 *localCallSignature;
 	int index;
 	SciWorkaroundSolution newValue;
 };
diff --git a/engines/sci/graphics/paint16.cpp b/engines/sci/graphics/paint16.cpp
index f80703e14d..6004e9ce7a 100644
--- a/engines/sci/graphics/paint16.cpp
+++ b/engines/sci/graphics/paint16.cpp
@@ -471,9 +471,6 @@ void GfxPaint16::kernelGraphRedrawBox(Common::Rect rect) {
 #define SCI_DISPLAY_WIDTH				106
 #define SCI_DISPLAY_SAVEUNDER			107
 #define SCI_DISPLAY_RESTOREUNDER		108
-#define SCI_DISPLAY_DUMMY1				114
-#define SCI_DISPLAY_DUMMY2				115
-#define SCI_DISPLAY_DUMMY3				117
 #define SCI_DISPLAY_DONTSHOWBITS		121
 
 reg_t GfxPaint16::kernelDisplay(const char *text, uint16 languageSplitter, int argc, reg_t *argv) {
@@ -543,22 +540,6 @@ reg_t GfxPaint16::kernelDisplay(const char *text, uint16 languageSplitter, int a
 			bRedraw = 0;
 			break;
 
-		// The following three dummy calls are not supported by the Sierra SCI
-		// interpreter, but are erroneously called in some game scripts.
-		case SCI_DISPLAY_DUMMY1:	// Longbow demo (all rooms) and QFG1 EGA demo (room 11)
-		case SCI_DISPLAY_DUMMY2:	// Longbow demo (all rooms)
-		case SCI_DISPLAY_DUMMY3:	// QFG1 EGA demo (room 11) and PQ2 (room 23)
-			if (!(g_sci->getGameId() == GID_LONGBOW && g_sci->isDemo()) &&
-				!(g_sci->getGameId() == GID_QFG1    && g_sci->isDemo()) &&
-				!(g_sci->getGameId() == GID_PQ2))
-				error("Unknown kDisplay argument %d", displayArg.getOffset());
-
-			if (displayArg.getOffset() == SCI_DISPLAY_DUMMY2) {
-				if (!argc)
-					error("No parameter left for kDisplay(115)");
-				argc--; argv++;
-			}
-			break;
 		default:
 			SciTrackOriginReply originReply;
 			SciWorkaroundSolution solution = trackOriginAndFindWorkaround(0, kDisplay_workarounds, &originReply);
diff --git a/engines/sci/graphics/portrait.cpp b/engines/sci/graphics/portrait.cpp
index 3311f47022..cb425f3be9 100644
--- a/engines/sci/graphics/portrait.cpp
+++ b/engines/sci/graphics/portrait.cpp
@@ -317,7 +317,8 @@ void Portrait::doit(Common::Point position, uint16 resourceId, uint16 noun, uint
 				curEvent = _event->getSciEvent(SCI_EVENT_ANY);
 				if (curEvent.type == SCI_EVENT_MOUSE_PRESS ||
 					(curEvent.type == SCI_EVENT_KEYBOARD && curEvent.data == SCI_KEY_ESC) ||
-					g_sci->getEngineState()->abortScriptProcessing == kAbortQuitGame)
+					g_sci->getEngineState()->abortScriptProcessing == kAbortQuitGame ||
+					g_sci->getEngineState()->_delayedRestoreGame)
 					userAbort = true;
 				curPosition = _audio->getAudioPosition();
 			} while ((curPosition != -1) && (curPosition < timerPosition) && (!userAbort));
diff --git a/engines/sci/graphics/screen.cpp b/engines/sci/graphics/screen.cpp
index 5a3b30f7ef..ca5b5b3b8c 100644
--- a/engines/sci/graphics/screen.cpp
+++ b/engines/sci/graphics/screen.cpp
@@ -251,6 +251,18 @@ GfxScreen::~GfxScreen() {
 	free(_displayScreen);
 }
 
+// should not be used regularly; only meant for restore game
+void GfxScreen::clearForRestoreGame() {
+	// reset all screen data
+	memset(_visualScreen, 0, _pixels);
+	memset(_priorityScreen, 0, _pixels);
+	memset(_controlScreen, 0, _pixels);
+	memset(_displayScreen, 0, _displayPixels);
+	memset(&_ditheredPicColors, 0, sizeof(_ditheredPicColors));
+	_fontIsUpscaled = false;
+	copyToScreen();
+}
+
 void GfxScreen::copyToScreen() {
 	g_system->copyRectToScreen(_activeScreen, _displayWidth, 0, 0, _displayWidth, _displayHeight);
 }
diff --git a/engines/sci/graphics/screen.h b/engines/sci/graphics/screen.h
index 766e32614a..1c946ef02f 100644
--- a/engines/sci/graphics/screen.h
+++ b/engines/sci/graphics/screen.h
@@ -76,6 +76,7 @@ public:
 	byte getColorWhite() { return _colorWhite; }
 	byte getColorDefaultVectorData() { return _colorDefaultVectorData; }
 
+	void clearForRestoreGame();
 	void copyToScreen();
 	void copyFromScreen(byte *buffer);
 	void kernelSyncWithFramebuffer();
diff --git a/engines/sci/graphics/transitions.cpp b/engines/sci/graphics/transitions.cpp
index ccc7a4389a..c75580a077 100644
--- a/engines/sci/graphics/transitions.cpp
+++ b/engines/sci/graphics/transitions.cpp
@@ -124,6 +124,10 @@ void GfxTransitions::setup(int16 number, bool blackoutFlag) {
 	}
 }
 
+// Checks, if current time is lower than expected time of the current frame
+// If current time is higher, then we have to assume that the current system isn't capable
+// of either rendering frames that fast or has 60hz V'Sync enabled, which is why we drop frames
+// in those cases, so that transitions work as fast as expected.
 bool GfxTransitions::doCreateFrame(uint32 shouldBeAtMsec) {
 	uint32 msecPos = g_system->getMillis() - _transitionStartTime;
 
@@ -132,12 +136,16 @@ bool GfxTransitions::doCreateFrame(uint32 shouldBeAtMsec) {
 	return false;
 }
 
-void GfxTransitions::updateScreenAndWait(uint32 shouldBeAtMsec) {
+void GfxTransitions::updateScreen() {
 	Common::Event ev;
 
 	while (g_system->getEventManager()->pollEvent(ev)) {}	// discard all events
 
 	g_system->updateScreen();
+}
+
+void GfxTransitions::updateScreenAndWait(uint32 shouldBeAtMsec) {
+	updateScreen();
 	// if we have still some time left, delay accordingly
 	uint32 msecPos = g_system->getMillis() - _transitionStartTime;
 	if (shouldBeAtMsec > msecPos)
@@ -257,6 +265,9 @@ void GfxTransitions::doTransition(int16 number, bool blackoutFlag) {
 		warning("Transitions: ID %d not implemented", number);
 		setNewScreen(blackoutFlag);
 	}
+	// Just to make sure that the current frame is shown in case we skipped the last update-call b/c of timing
+	updateScreen();
+	debugC(kDebugLevelGraphics, "Transition took %d milliseconds", g_system->getMillis() - _transitionStartTime);
 }
 
 void GfxTransitions::setNewPalette(bool blackoutFlag) {
@@ -348,7 +359,9 @@ void GfxTransitions::pixelation(bool blackoutFlag) {
 			copyRectToScreen(pixelRect, blackoutFlag);
 		if ((stepNr & 0x3FF) == 0) {
 			msecCount += 9;
-			updateScreenAndWait(msecCount);
+			if (doCreateFrame(msecCount)) {
+				updateScreenAndWait(msecCount);
+			}
 		}
 		stepNr++;
 	} while (mask != 0x40);
@@ -372,7 +385,9 @@ void GfxTransitions::blocks(bool blackoutFlag) {
 			copyRectToScreen(blockRect, blackoutFlag);
 		if ((stepNr & 7) == 0) {
 			msecCount += 5;
-			updateScreenAndWait(msecCount);
+			if (doCreateFrame(msecCount)) {
+				updateScreenAndWait(msecCount);
+			}
 		}
 		stepNr++;
 	} while (mask != 0x40);
@@ -392,7 +407,9 @@ void GfxTransitions::straight(int16 number, bool blackoutFlag) {
 			copyRectToScreen(newScreenRect, blackoutFlag);
 			if ((stepNr & 1) == 0) {
 				msecCount += 2;
-				updateScreenAndWait(msecCount);
+				if (doCreateFrame(msecCount)) {
+					updateScreenAndWait(msecCount);
+				}
 			}
 			stepNr++;
 			newScreenRect.translate(-1, 0);
@@ -405,7 +422,9 @@ void GfxTransitions::straight(int16 number, bool blackoutFlag) {
 			copyRectToScreen(newScreenRect, blackoutFlag);
 			if ((stepNr & 1) == 0) {
 				msecCount += 2;
-				updateScreenAndWait(msecCount);
+				if (doCreateFrame(msecCount)) {
+					updateScreenAndWait(msecCount);
+				}
 			}
 			stepNr++;
 			newScreenRect.translate(1, 0);
@@ -417,7 +436,9 @@ void GfxTransitions::straight(int16 number, bool blackoutFlag) {
 		while (newScreenRect.top >= _picRect.top) {
 			copyRectToScreen(newScreenRect, blackoutFlag);
 			msecCount += 4;
-			updateScreenAndWait(msecCount);
+			if (doCreateFrame(msecCount)) {
+				updateScreenAndWait(msecCount);
+			}
 			stepNr++;
 			newScreenRect.translate(0, -1);
 		}
@@ -428,7 +449,9 @@ void GfxTransitions::straight(int16 number, bool blackoutFlag) {
 		while (newScreenRect.bottom <= _picRect.bottom) {
 			copyRectToScreen(newScreenRect, blackoutFlag);
 			msecCount += 4;
-			updateScreenAndWait(msecCount);
+			if (doCreateFrame(msecCount)) {
+				updateScreenAndWait(msecCount);
+			}
 			stepNr++;
 			newScreenRect.translate(0, 1);
 		}
@@ -534,7 +557,6 @@ void GfxTransitions::scroll(int16 number) {
 
 	// Copy over final position just in case
 	_screen->copyRectToScreen(newScreenRect);
-	g_system->updateScreen();
 }
 
 // Vertically displays new screen starting from center - works on _picRect area
@@ -552,7 +574,9 @@ void GfxTransitions::verticalRollFromCenter(bool blackoutFlag) {
 		copyRectToScreen(leftRect, blackoutFlag); leftRect.translate(-1, 0);
 		copyRectToScreen(rightRect, blackoutFlag); rightRect.translate(1, 0);
 		msecCount += 3;
-		updateScreenAndWait(msecCount);
+		if (doCreateFrame(msecCount)) {
+			updateScreenAndWait(msecCount);
+		}
 	}
 }
 
@@ -567,7 +591,9 @@ void GfxTransitions::verticalRollToCenter(bool blackoutFlag) {
 		copyRectToScreen(leftRect, blackoutFlag); leftRect.translate(1, 0);
 		copyRectToScreen(rightRect, blackoutFlag); rightRect.translate(-1, 0);
 		msecCount += 3;
-		updateScreenAndWait(msecCount);
+		if (doCreateFrame(msecCount)) {
+			updateScreenAndWait(msecCount);
+		}
 	}
 }
 
@@ -586,7 +612,9 @@ void GfxTransitions::horizontalRollFromCenter(bool blackoutFlag) {
 		copyRectToScreen(upperRect, blackoutFlag); upperRect.translate(0, -1);
 		copyRectToScreen(lowerRect, blackoutFlag); lowerRect.translate(0, 1);
 		msecCount += 4;
-		updateScreenAndWait(msecCount);
+		if (doCreateFrame(msecCount)) {
+			updateScreenAndWait(msecCount);
+		}
 	}
 }
 
@@ -601,7 +629,9 @@ void GfxTransitions::horizontalRollToCenter(bool blackoutFlag) {
 		copyRectToScreen(upperRect, blackoutFlag); upperRect.translate(0, 1);
 		copyRectToScreen(lowerRect, blackoutFlag); lowerRect.translate(0, -1);
 		msecCount += 4;
-		updateScreenAndWait(msecCount);
+		if (doCreateFrame(msecCount)) {
+			updateScreenAndWait(msecCount);
+		}
 	}
 }
 
@@ -633,7 +663,9 @@ void GfxTransitions::diagonalRollFromCenter(bool blackoutFlag) {
 		copyRectToScreen(leftRect, blackoutFlag); leftRect.translate(-1, 0);	leftRect.top--; leftRect.bottom++;
 		copyRectToScreen(rightRect, blackoutFlag); rightRect.translate(1, 0); rightRect.top--; rightRect.bottom++;
 		msecCount += 4;
-		updateScreenAndWait(msecCount);
+		if (doCreateFrame(msecCount)) {
+			updateScreenAndWait(msecCount);
+		}
 	}
 }
 
@@ -652,7 +684,9 @@ void GfxTransitions::diagonalRollToCenter(bool blackoutFlag) {
 		copyRectToScreen(leftRect, blackoutFlag); leftRect.translate(1, 0);
 		copyRectToScreen(rightRect, blackoutFlag); rightRect.translate(-1, 0);
 		msecCount += 4;
-		updateScreenAndWait(msecCount);
+		if (doCreateFrame(msecCount)) {
+			updateScreenAndWait(msecCount);
+		}
 	}
 }
 
diff --git a/engines/sci/graphics/transitions.h b/engines/sci/graphics/transitions.h
index ae9ca4b48a..05842a4d2a 100644
--- a/engines/sci/graphics/transitions.h
+++ b/engines/sci/graphics/transitions.h
@@ -89,6 +89,7 @@ private:
 	void diagonalRollFromCenter(bool blackoutFlag);
 	void diagonalRollToCenter(bool blackoutFlag);
 	bool doCreateFrame(uint32 shouldBeAtMsec);
+	void updateScreen();
 	void updateScreenAndWait(uint32 shouldBeAtMsec);
 
 	GfxScreen *_screen;
diff --git a/engines/sci/parser/vocabulary.cpp b/engines/sci/parser/vocabulary.cpp
index 000b037b44..828a57abeb 100644
--- a/engines/sci/parser/vocabulary.cpp
+++ b/engines/sci/parser/vocabulary.cpp
@@ -74,6 +74,8 @@ Vocabulary::Vocabulary(ResourceManager *resMan, bool foreign) : _resMan(resMan),
 
 	parser_event = NULL_REG;
 	parserIsValid = false;
+
+	_pronounReference = 0x1000; // Non-existent word
 }
 
 Vocabulary::~Vocabulary() {
@@ -738,4 +740,79 @@ int Vocabulary::parseNodes(int *i, int *pos, int type, int nr, int argc, const c
 	return oldPos;
 }
 
+
+// FIXME: Duplicated from said.cpp
+static int node_major(ParseTreeNode* node) {
+	assert(node->type == kParseTreeBranchNode);
+	assert(node->left->type == kParseTreeLeafNode);
+	return node->left->value;
+}
+static bool node_is_terminal(ParseTreeNode* node) {
+	return (node->right->right &&
+            node->right->right->type != kParseTreeBranchNode);
+}
+static int node_terminal_value(ParseTreeNode* node) {
+	assert(node_is_terminal(node));
+	return node->right->right->value;
+}
+
+static ParseTreeNode* scanForMajor(ParseTreeNode *tree, int major) {
+	assert(tree);
+
+	if (node_is_terminal(tree)) {
+		if (node_major(tree) == major)
+			return tree;
+		else
+			return 0;
+	}
+
+	ParseTreeNode* ptr = tree->right;
+
+	// Scan children
+	while (ptr->right) {
+		ptr = ptr->right;
+
+		if (node_major(ptr->left) == major)
+			return ptr->left;
+	}
+
+	if (major == 0x141)
+		return 0;
+
+	// If not found, go into a 0x141 and try again
+	tree = scanForMajor(tree, 0x141);
+	if (!tree)
+		return 0;
+	return scanForMajor(tree, major);
+}
+
+bool Vocabulary::storePronounReference() {
+	assert(parserIsValid);
+
+	ParseTreeNode *ptr = scanForMajor(_parserNodes, 0x142); // 0x142 = object?
+
+	while (ptr && !node_is_terminal(ptr))
+		ptr = scanForMajor(ptr, 0x141);
+
+	if (!ptr)
+		return false;
+
+	_pronounReference = node_terminal_value(ptr);
+
+	debugC(kDebugLevelParser, "Stored pronoun reference: %x", _pronounReference);
+	return true;
+}
+
+void Vocabulary::replacePronouns(ResultWordListList &words) {
+	if (_pronounReference == 0x1000)
+		return;
+
+	for (ResultWordListList::iterator i = words.begin(); i != words.end(); ++i)
+		for (ResultWordList::iterator j = i->begin(); j != i->end(); ++j)
+			if (j->_class & (VOCAB_CLASS_PRONOUN << 4)) {
+				j->_class = VOCAB_CLASS_NOUN << 4;
+				j->_group = _pronounReference;
+			}
+}
+
 } // End of namespace Sci
diff --git a/engines/sci/parser/vocabulary.h b/engines/sci/parser/vocabulary.h
index 09499946cb..f4adee6e55 100644
--- a/engines/sci/parser/vocabulary.h
+++ b/engines/sci/parser/vocabulary.h
@@ -233,6 +233,16 @@ public:
 	int parseGNF(const ResultWordListList &words, bool verbose = false);
 
 	/**
+	 * Find and store reference for future pronouns
+	 */
+	bool storePronounReference();
+
+	/**
+	 * Replace pronouns by stored reference
+	 */
+	void replacePronouns(ResultWordListList &words);
+
+	/**
 	 * Constructs the Greibach Normal Form of the grammar supplied in 'branches'.
 	 * @param verbose	Set to true for debugging. If true, the list is
 	 *					freed before the function ends
@@ -360,6 +370,8 @@ private:
 	SynonymList _synonyms; /**< The list of synonyms */
 	Common::Array<Common::List<AltInput> > _altInputs;
 
+	int _pronounReference;
+
 public:
 	// Accessed by said()
 	ParseTreeNode _parserNodes[VOCAB_TREE_NODES]; /**< The parse tree */
diff --git a/engines/sci/resource.h b/engines/sci/resource.h
index 62f3c584ac..ef48998b04 100644
--- a/engines/sci/resource.h
+++ b/engines/sci/resource.h
@@ -596,6 +596,7 @@ public:
 	Track *getDigitalTrack();
 	int getChannelFilterMask(int hardwareMask, bool wantsRhythm);
 	byte getInitialVoiceCount(byte channel);
+	byte getSoundPriority() const { return _soundPriority; }
 
 private:
 	SciVersion _soundVersion;
@@ -603,6 +604,7 @@ private:
 	Track *_tracks;
 	Resource *_innerResource;
 	ResourceManager *_resMan;
+	byte _soundPriority;
 };
 
 } // End of namespace Sci
diff --git a/engines/sci/resource_audio.cpp b/engines/sci/resource_audio.cpp
index c775f502c5..3a43774492 100644
--- a/engines/sci/resource_audio.cpp
+++ b/engines/sci/resource_audio.cpp
@@ -579,6 +579,7 @@ SoundResource::SoundResource(uint32 resourceNr, ResourceManager *resMan, SciVers
 		return;
 
 	_innerResource = resource;
+	_soundPriority = 0xFF;
 
 	byte *data, *data2;
 	byte *dataEnd;
@@ -725,6 +726,9 @@ SoundResource::SoundResource(uint32 resourceNr, ResourceManager *resMan, SciVers
 					data += 6;
 				}
 			} else {
+				// The first byte of the 0xF0 track's channel list is priority
+				_soundPriority = *data;
+
 				// Skip over digital track
 				data += 6;
 			}
diff --git a/engines/sci/sci.cpp b/engines/sci/sci.cpp
index 60a1271b89..668ad053cc 100644
--- a/engines/sci/sci.cpp
+++ b/engines/sci/sci.cpp
@@ -114,6 +114,7 @@ SciEngine::SciEngine(OSystem *syst, const ADGameDescription *desc, SciGameId gam
 	DebugMan.addDebugChannel(kDebugLevelVM, "VM", "VM debugging");
 	DebugMan.addDebugChannel(kDebugLevelScripts, "Scripts", "Notifies when scripts are unloaded");
 	DebugMan.addDebugChannel(kDebugLevelScriptPatcher, "ScriptPatcher", "Notifies when scripts are patched");
+	DebugMan.addDebugChannel(kDebugLevelWorkarounds, "Workarounds", "Notifies when workarounds are triggered");
 	DebugMan.addDebugChannel(kDebugLevelGC, "GC", "Garbage Collector debugging");
 	DebugMan.addDebugChannel(kDebugLevelResMan, "ResMan", "Resource manager debugging");
 	DebugMan.addDebugChannel(kDebugLevelOnStartup, "OnStartup", "Enter debugger at start of game");
@@ -281,25 +282,13 @@ Common::Error SciEngine::run() {
 	// Check whether loading a savestate was requested
 	int directSaveSlotLoading = ConfMan.getInt("save_slot");
 	if (directSaveSlotLoading >= 0) {
-		// call GameObject::play (like normally)
-		initStackBaseWithSelector(SELECTOR(play));
-		// We set this, so that the game automatically quit right after init
-		_gamestate->variables[VAR_GLOBAL][4] = TRUE_REG;
+		_gamestate->_delayedRestoreGame = true;
+		_gamestate->_delayedRestoreGameId = directSaveSlotLoading;
 
 		// Jones only initializes its menus when restarting/restoring, thus set
 		// the gameIsRestarting flag here before initializing. Fixes bug #6536.
 		if (g_sci->getGameId() == GID_JONES)
 			_gamestate->gameIsRestarting = GAMEISRESTARTING_RESTORE;
-
-		_gamestate->_executionStackPosChanged = false;
-		run_vm(_gamestate);
-
-		// As soon as we get control again, actually restore the game
-		reg_t restoreArgv[2] = { NULL_REG, make_reg(0, directSaveSlotLoading) };	// special call (argv[0] is NULL)
-		kRestoreGame(_gamestate, 2, restoreArgv);
-
-		// this indirectly calls GameObject::init, which will setup menu, text font/color codes etc.
-		//  without this games would be pretty badly broken
 	}
 
 	// Show any special warnings for buggy scripts with severe game bugs,
diff --git a/engines/sci/sci.h b/engines/sci/sci.h
index 4928fd1b4e..c6813aa07c 100644
--- a/engines/sci/sci.h
+++ b/engines/sci/sci.h
@@ -105,7 +105,8 @@ enum kDebugLevels {
 	kDebugLevelResMan        = 1 << 19,
 	kDebugLevelOnStartup     = 1 << 20,
 	kDebugLevelDebugMode     = 1 << 21,
-	kDebugLevelScriptPatcher = 1 << 22
+	kDebugLevelScriptPatcher = 1 << 22,
+	kDebugLevelWorkarounds   = 1 << 23
 };
 
 enum SciGameId {
diff --git a/engines/sci/sound/audio.cpp b/engines/sci/sound/audio.cpp
index 8e35d6b055..fb9a3f17b9 100644
--- a/engines/sci/sound/audio.cpp
+++ b/engines/sci/sound/audio.cpp
@@ -391,18 +391,13 @@ Audio::RewindableAudioStream *AudioPlayer::getAudioStream(uint32 number, uint32
 		} else if (audioRes->size > 4 && READ_BE_UINT32(audioRes->data) == MKTAG('F','O','R','M')) {
 			// AIFF detected
 			Common::SeekableReadStream *waveStream = new Common::MemoryReadStream(audioRes->data, audioRes->size, DisposeAfterUse::NO);
+			Audio::RewindableAudioStream *rewindStream = Audio::makeAIFFStream(waveStream, DisposeAfterUse::YES);
+			audioSeekStream = dynamic_cast<Audio::SeekableAudioStream *>(rewindStream);
 
-			// Calculate samplelen from AIFF header
-			int waveSize = 0, waveRate = 0;
-			byte waveFlags = 0;
-			bool ret = Audio::loadAIFFFromStream(*waveStream, waveSize, waveRate, waveFlags);
-			if (!ret)
-				error("Failed to load AIFF from stream");
-
-			*sampleLen = (waveFlags & Audio::FLAG_16BITS ? waveSize >> 1 : waveSize) * 60 / waveRate;
-
-			waveStream->seek(0, SEEK_SET);
-			audioStream = Audio::makeAIFFStream(waveStream, DisposeAfterUse::YES);
+			if (!audioSeekStream) {
+				warning("AIFF file is not seekable");
+				delete rewindStream;
+			}
 		} else if (audioRes->size > 14 && READ_BE_UINT16(audioRes->data) == 1 && READ_BE_UINT16(audioRes->data + 2) == 1
 				&& READ_BE_UINT16(audioRes->data + 4) == 5 && READ_BE_UINT32(audioRes->data + 10) == 0x00018051) {
 			// Mac snd detected
diff --git a/engines/sci/sound/drivers/adlib.cpp b/engines/sci/sound/drivers/adlib.cpp
index fcfda2f532..4f557be95e 100644
--- a/engines/sci/sound/drivers/adlib.cpp
+++ b/engines/sci/sound/drivers/adlib.cpp
@@ -27,7 +27,7 @@
 #include "common/textconsole.h"
 
 #include "audio/fmopl.h"
-#include "audio/softsynth/emumidi.h"
+#include "audio/mididrv.h"
 
 #include "sci/resource.h"
 #include "sci/sound/drivers/mididriver.h"
@@ -43,29 +43,30 @@ namespace Sci {
 // FIXME: We don't seem to be sending the polyphony init data, so disable this for now
 #define ADLIB_DISABLE_VOICE_MAPPING
 
-class MidiDriver_AdLib : public MidiDriver_Emulated {
+class MidiDriver_AdLib : public MidiDriver {
 public:
 	enum {
 		kVoices = 9,
 		kRhythmKeys = 62
 	};
 
-	MidiDriver_AdLib(Audio::Mixer *mixer) : MidiDriver_Emulated(mixer), _playSwitch(true), _masterVolume(15), _rhythmKeyMap(0), _opl(0) { }
+	MidiDriver_AdLib(Audio::Mixer *mixer) :_playSwitch(true), _masterVolume(15), _rhythmKeyMap(0), _opl(0), _isOpen(false) { }
 	virtual ~MidiDriver_AdLib() { }
 
 	// MidiDriver
+	int open() { return -1; } // Dummy implementation (use openAdLib)
 	int openAdLib(bool isSCI0);
 	void close();
 	void send(uint32 b);
 	MidiChannel *allocateChannel() { return NULL; }
 	MidiChannel *getPercussionChannel() { return NULL; }
+	bool isOpen() const { return _isOpen; }
+	uint32 getBaseTempo() { return 1000000 / OPL::OPL::kDefaultCallbackFrequency; }
 
-	// AudioStream
-	bool isStereo() const { return _stereo; }
-	int getRate() const { return _mixer->getOutputRate(); }
+	// MidiDriver
+	void setTimerCallback(void *timerParam, Common::TimerManager::TimerProc timerProc);
 
-	// MidiDriver_Emulated
-	void generateSamples(int16 *buf, int len);
+	void onTimer();
 
 	void setVolume(byte volume);
 	void playSwitch(bool play);
@@ -133,6 +134,7 @@ private:
 	bool _stereo;
 	bool _isSCI0;
 	OPL::OPL *_opl;
+	bool _isOpen;
 	bool _playSwitch;
 	int _masterVolume;
 	Channel _channels[MIDI_CHANNELS];
@@ -140,6 +142,9 @@ private:
 	byte *_rhythmKeyMap;
 	Common::Array<AdLibPatch> _patches;
 
+	Common::TimerManager::TimerProc _adlibTimerProc;
+	void *_adlibTimerParam;
+
 	void loadInstrument(const byte *ins);
 	void voiceOn(int voice, int note, int velocity);
 	void voiceOff(int voice);
@@ -215,14 +220,12 @@ static const int ym3812_note[13] = {
 };
 
 int MidiDriver_AdLib::openAdLib(bool isSCI0) {
-	int rate = _mixer->getOutputRate();
-
 	_stereo = STEREO;
 
 	debug(3, "ADLIB: Starting driver in %s mode", (isSCI0 ? "SCI0" : "SCI1"));
 	_isSCI0 = isSCI0;
 
-	_opl = OPL::Config::create(isStereo() ? OPL::Config::kDualOpl2 : OPL::Config::kOpl2);
+	_opl = OPL::Config::create(_stereo ? OPL::Config::kDualOpl2 : OPL::Config::kOpl2);
 
 	// Try falling back to mono, thus plain OPL2 emualtor, when no Dual OPL2 is available.
 	if (!_opl && _stereo) {
@@ -233,22 +236,24 @@ int MidiDriver_AdLib::openAdLib(bool isSCI0) {
 	if (!_opl)
 		return -1;
 
-	_opl->init(rate);
+	if (!_opl->init()) {
+		delete _opl;
+		_opl = nullptr;
+		return -1;
+	}
 
 	setRegister(0xBD, 0);
 	setRegister(0x08, 0);
 	setRegister(0x01, 0x20);
 
-	MidiDriver_Emulated::open();
+	_isOpen = true;
 
-	_mixer->playStream(Audio::Mixer::kPlainSoundType, &_mixerSoundHandle, this, -1, _mixer->kMaxChannelVolume, 0, DisposeAfterUse::NO);
+	_opl->start(new Common::Functor0Mem<void, MidiDriver_AdLib>(this, &MidiDriver_AdLib::onTimer));
 
 	return 0;
 }
 
 void MidiDriver_AdLib::close() {
-	_mixer->stopHandle(_mixerSoundHandle);
-
 	delete _opl;
 	delete[] _rhythmKeyMap;
 }
@@ -325,10 +330,14 @@ void MidiDriver_AdLib::send(uint32 b) {
 	}
 }
 
-void MidiDriver_AdLib::generateSamples(int16 *data, int len) {
-	if (isStereo())
-		len <<= 1;
-	_opl->readBuffer(data, len);
+void MidiDriver_AdLib::setTimerCallback(void *timerParam, Common::TimerManager::TimerProc timerProc) {
+	_adlibTimerProc = timerProc;
+	_adlibTimerParam = timerParam;
+}
+
+void MidiDriver_AdLib::onTimer() {
+	if (_adlibTimerProc)
+		(*_adlibTimerProc)(_adlibTimerParam);
 
 	// Increase the age of the notes
 	for (int i = 0; i < kVoices; i++) {
@@ -684,7 +693,7 @@ void MidiDriver_AdLib::setVelocityReg(int regOffset, int velocity, int kbScaleLe
 	if (!_playSwitch)
 		velocity = 0;
 
-	if (isStereo()) {
+	if (_stereo) {
 		int velLeft = velocity;
 		int velRight = velocity;
 
@@ -734,7 +743,7 @@ void MidiDriver_AdLib::setRegister(int reg, int value, int channels) {
 		_opl->write(0x221, value);
 	}
 
-	if (isStereo()) {
+	if (_stereo) {
 		if (channels & kRightChannel) {
 			_opl->write(0x222, reg);
 			_opl->write(0x223, value);
diff --git a/engines/sci/sound/midiparser_sci.cpp b/engines/sci/sound/midiparser_sci.cpp
index c0b4f3122e..9f0d8d150f 100644
--- a/engines/sci/sound/midiparser_sci.cpp
+++ b/engines/sci/sound/midiparser_sci.cpp
@@ -360,6 +360,13 @@ void MidiParser_SCI::sendInitCommands() {
 					sendToDriver(0xB0 | i, 0x4B, voiceCount);
 				}
 			}
+		} else {
+			for (int i = 0; i < _track->channelCount; ++i) {
+				byte voiceCount = _track->channels[i].poly;
+				byte num = _track->channels[i].number;
+				// TODO: Should we skip the control channel?
+				sendToDriver(0xB0 | num, 0x4B, voiceCount);
+			}
 		}
 	}
 
@@ -480,19 +487,25 @@ void MidiParser_SCI::trackState(uint32 b) {
 			s._sustain = (op2 != 0);
 			break;
 		case 0x4B: // voices
+			if (s._voices != op2) {
+				// CHECKME: Should we directly call remapChannels() if _mainThreadCalled?
+				debugC(2, kDebugLevelSound, "Dynamic voice change (%d to %d)", s._voices, op2);
+				_music->needsRemap();
+			}
 			s._voices = op2;
 			_pSnd->_chan[channel]._voices = op2; // Also sync our MusicEntry
 			break;
 		case 0x4E: // mute
 			// This is channel mute only for sci1.
 			// (It's velocity control for sci0, but we don't need state in sci0)
-			if (_soundVersion >= SCI_VERSION_1_EARLY) {
+			if (_soundVersion > SCI_VERSION_1_EARLY) {
 				// FIXME: mute is a level, not a bool, in some SCI versions
 				bool m = op2;
 				if (_pSnd->_chan[channel]._mute != m) {
 					_pSnd->_chan[channel]._mute = m;
-					// TODO: If muting/unmuting a channel, remap channels.
-					warning("Mute change without immediate remapping (mainThread = %d)", _mainThreadCalled);
+					// CHECKME: Should we directly call remapChannels() if _mainThreadCalled?
+					_music->needsRemap();
+					debugC(2, kDebugLevelSound, "Dynamic mute change (arg = %d, mainThread = %d)", m, _mainThreadCalled);
 				}
 			}
 			break;
diff --git a/engines/sci/sound/music.cpp b/engines/sci/sound/music.cpp
index 7a6eaf62b4..dca73c3f51 100644
--- a/engines/sci/sound/music.cpp
+++ b/engines/sci/sound/music.cpp
@@ -144,6 +144,8 @@ void SciMusic::init() {
 		_globalReverb = _pMidiDrv->getReverb();	// Init global reverb for SCI0
 
 	_currentlyPlayingSample = NULL;
+	_timeCounter = 0;
+	_needsRemap = false;
 }
 
 void SciMusic::miditimerCallback(void *p) {
@@ -158,6 +160,11 @@ void SciMusic::onTimer() {
 	// sending out queued commands that were "sent" via main thread
 	sendMidiCommandsFromQueue();
 
+	// remap channels, if requested
+	if (_needsRemap)
+		remapChannels(false);
+	_needsRemap = false;
+
 	for (MusicList::iterator i = _playList.begin(); i != end; ++i)
 		(*i)->onTimer();
 }
@@ -285,8 +292,10 @@ byte SciMusic::getCurrentReverb() {
 	return _pMidiDrv->getReverb();
 }
 
+// A larger priority value has higher priority. For equal priority values,
+// songs that have been added later have higher priority.
 static bool musicEntryCompare(const MusicEntry *l, const MusicEntry *r) {
-	return (l->priority > r->priority);
+	return (l->priority > r->priority) || (l->priority == r->priority && l->time > r->time);
 }
 
 void SciMusic::sortPlayList() {
@@ -317,6 +326,8 @@ void SciMusic::soundInitSnd(MusicEntry *pSnd) {
 			track = digital;
 	}
 
+	pSnd->time = ++_timeCounter;
+
 	if (track) {
 		// Play digital sample
 		if (track->digitalChannelNr != -1) {
@@ -334,6 +345,8 @@ void SciMusic::soundInitSnd(MusicEntry *pSnd) {
 			pSnd->pLoopStream = 0;
 			pSnd->soundType = Audio::Mixer::kSFXSoundType;
 			pSnd->hCurrentAud = Audio::SoundHandle();
+			pSnd->playBed = false;
+			pSnd->overridePriority = false;
 		} else {
 			// play MIDI track
 			Common::StackLock lock(_mutex);
@@ -380,6 +393,8 @@ void SciMusic::soundInitSnd(MusicEntry *pSnd) {
 			int16 prevHold = pSnd->hold;
 			pSnd->loop = 0;
 			pSnd->hold = -1;
+			pSnd->playBed = false;
+			pSnd->overridePriority = false;
 
 			pSnd->pMidiParser->loadMusic(track, pSnd, channelFilterMask, _soundVersion);
 			pSnd->reverb = pSnd->pMidiParser->getSongReverb();
@@ -395,6 +410,23 @@ void SciMusic::soundInitSnd(MusicEntry *pSnd) {
 void SciMusic::soundPlay(MusicEntry *pSnd) {
 	_mutex.lock();
 
+	if (_soundVersion <= SCI_VERSION_1_EARLY && pSnd->playBed) {
+		// If pSnd->playBed, and version <= SCI1_EARLY, then kill
+		// existing sounds with playBed enabled.
+
+		uint playListCount = _playList.size();
+		for (uint i = 0; i < playListCount; i++) {
+			if (_playList[i] != pSnd && _playList[i]->playBed) {
+				debugC(2, kDebugLevelSound, "Automatically stopping old playBed song from soundPlay");
+				MusicEntry *old = _playList[i];
+				_mutex.unlock();
+				soundStop(old);
+				_mutex.lock();
+				break;
+			}
+		}
+	}
+
 	uint playListCount = _playList.size();
 	uint playListNo = playListCount;
 	MusicEntry *alreadyPlaying = NULL;
@@ -408,9 +440,11 @@ void SciMusic::soundPlay(MusicEntry *pSnd) {
 	}
 	if (playListNo == playListCount) { // not found
 		_playList.push_back(pSnd);
-		sortPlayList();
 	}
 
+	pSnd->time = ++_timeCounter;
+	sortPlayList();
+
 	_mutex.unlock();	// unlock to perform mixer-related calls
 
 	if (pSnd->pMidiParser) {
@@ -554,6 +588,7 @@ void SciMusic::soundSetPriority(MusicEntry *pSnd, byte prio) {
 	Common::StackLock lock(_mutex);
 
 	pSnd->priority = prio;
+	pSnd->time = ++_timeCounter;
 	sortPlayList();
 }
 
@@ -905,12 +940,12 @@ int ChannelRemapping::lowestPrio() const {
 }
 
 
-void SciMusic::remapChannels() {
+void SciMusic::remapChannels(bool mainThread) {
 	if (_soundVersion <= SCI_VERSION_0_LATE)
 		return;
 
-	// NB: This function should only be called from the main thread,
-	// with _mutex locked
+	// NB: This function should only be called with _mutex locked
+	// Make sure to set the mainThread argument correctly.
 
 
 	ChannelRemapping *map = determineChannelMap();
@@ -963,9 +998,9 @@ void SciMusic::remapChannels() {
 
 		for (int j = 0; j < 16; ++j) {
 			if (!channelMapped[j]) {
-				song->pMidiParser->mainThreadBegin();
+				if (mainThread) song->pMidiParser->mainThreadBegin();
 				song->pMidiParser->remapChannel(j, -1);
-				song->pMidiParser->mainThreadEnd();
+				if (mainThread) song->pMidiParser->mainThreadEnd();
 #ifdef DEBUG_REMAP
 				if (channelUsed[j])
 					debug(" Unmapping song %d, channel %d", songIndex, j);
@@ -997,9 +1032,9 @@ void SciMusic::remapChannels() {
 #ifdef DEBUG_REMAP
 			debug(" Mapping (dontRemap) song %d, channel %d to device channel %d", songIndex, _channelMap[i]._channel, i);
 #endif
-			_channelMap[i]._song->pMidiParser->mainThreadBegin();
+			if (mainThread) _channelMap[i]._song->pMidiParser->mainThreadBegin();
 			_channelMap[i]._song->pMidiParser->remapChannel(_channelMap[i]._channel, i);
-			_channelMap[i]._song->pMidiParser->mainThreadEnd();
+			if (mainThread) _channelMap[i]._song->pMidiParser->mainThreadEnd();
 		}
 
 	}
@@ -1052,9 +1087,9 @@ void SciMusic::remapChannels() {
 #ifdef DEBUG_REMAP
 				debug(" Mapping song %d, channel %d to device channel %d", songIndex, _channelMap[j]._channel, j);
 #endif
-				_channelMap[j]._song->pMidiParser->mainThreadBegin();
+				if (mainThread) _channelMap[j]._song->pMidiParser->mainThreadBegin();
 				_channelMap[j]._song->pMidiParser->remapChannel(_channelMap[j]._channel, j);
-				_channelMap[j]._song->pMidiParser->mainThreadEnd();
+				if (mainThread) _channelMap[j]._song->pMidiParser->mainThreadEnd();
 				break;
 			}
 		}
@@ -1062,9 +1097,9 @@ void SciMusic::remapChannels() {
 	}
 
 	// And finally, stop any empty channels
-	for (int i = _driverFirstChannel; i <= _driverLastChannel; ++i) {
-		if (!_channelMap[i]._song)
-			resetDeviceChannel(i);
+	for (int i = _driverLastChannel; i >= _driverFirstChannel; --i) {
+		if (!_channelMap[i]._song && currentMap[i]._song)
+			resetDeviceChannel(i, mainThread);
 	}
 
 	delete map;
@@ -1105,7 +1140,8 @@ ChannelRemapping *SciMusic::determineChannelMap() {
 
 
 #ifdef DEBUG_REMAP
-		debug(" Song %d (%p), prio %d", songIndex, (void*)song, song->priority);
+		const char* name = g_sci->getEngineState()->_segMan->getObjectName(song->soundObj);
+		debug(" Song %d (%p) [%s], prio %d%s", songIndex, (void*)song, name, song->priority, song->playBed ? ", bed" : "");
 #endif
 
 		// Store backup. If we fail to map this song, we will revert to this.
@@ -1118,13 +1154,23 @@ ChannelRemapping *SciMusic::determineChannelMap() {
 			if (c == 0xFF || c == 0xFE || c == 0x0F)
 				continue;
 			const MusicEntryChannel &channel = song->_chan[c];
-			if (channel._dontMap)
+			if (channel._dontMap) {
+#ifdef DEBUG_REMAP
+				debug("  Channel %d dontMap, skipping", c);
+#endif
 				continue;
-			if (channel._mute)
+			}
+			if (channel._mute) {
+#ifdef DEBUG_REMAP
+				debug("  Channel %d muted, skipping", c);
+#endif
 				continue;
+			}
+
+			bool dontRemap = channel._dontRemap || song->playBed;
 
 #ifdef DEBUG_REMAP
-			debug("  Channel %d: prio %d, %d voice%s%s", c, channel._prio, channel._voices, channel._voices == 1 ? "" : "s", channel._dontRemap ? ", dontRemap" : "" );
+			debug("  Channel %d: prio %d, %d voice%s%s", c, channel._prio, channel._voices, channel._voices == 1 ? "" : "s", dontRemap ? ", dontRemap" : "" );
 #endif
 
 			DeviceChannelUsage dc = { song, c };
@@ -1132,7 +1178,7 @@ ChannelRemapping *SciMusic::determineChannelMap() {
 			// our target
 			int devChannel = -1;
 
-			if (channel._dontRemap && map->_map[c]._song == 0) {
+			if (dontRemap && map->_map[c]._song == 0) {
 				// unremappable channel, with channel still free
 				devChannel = c;
 			}
@@ -1192,8 +1238,12 @@ ChannelRemapping *SciMusic::determineChannelMap() {
 			int neededVoices = channel._voices;
 			// do we have enough free voices?
 			if (map->_freeVoices < neededVoices) {
-				// We only care for essential channels
-				if (prio > 0) {
+				// We only care for essential channels.
+				// Note: In early SCI1 interpreters, a song started by 'playBed'
+				// would not be skipped even if some channels couldn't be
+				// mapped due to voice limits. So, we treat all channels as
+				// non-essential here for playBed songs.
+				if (prio > 0 || (song->playBed && _soundVersion <= SCI_VERSION_1_EARLY)) {
 #ifdef DEBUG_REMAP
 					debug("   not enough voices; need %d, have %d. Skipping this channel.", neededVoices, map->_freeVoices);
 #endif
@@ -1229,10 +1279,10 @@ ChannelRemapping *SciMusic::determineChannelMap() {
 			map->_map[devChannel] = dc;
 			map->_voices[devChannel] = neededVoices;
 			map->_prio[devChannel] = prio;
-			map->_dontRemap[devChannel] = channel._dontRemap;
+			map->_dontRemap[devChannel] = dontRemap;
 			map->_freeVoices -= neededVoices;
 
-			if (!channel._dontRemap || devChannel == c) {
+			if (!dontRemap || devChannel == c) {
 				// If this channel fits here, we're done.
 #ifdef DEBUG_REMAP
 				debug("    OK");
@@ -1285,14 +1335,18 @@ ChannelRemapping *SciMusic::determineChannelMap() {
 	return map;
 }
 
-void SciMusic::resetDeviceChannel(int devChannel) {
-	// NB: This function should only be called from the main thread
-
+void SciMusic::resetDeviceChannel(int devChannel, bool mainThread) {
 	assert(devChannel >= 0 && devChannel <= 0x0F);
 
-	putMidiCommandInQueue(0x0040B0 | devChannel); // sustain off
-	putMidiCommandInQueue(0x007BB0 | devChannel); // notes off
-	putMidiCommandInQueue(0x004BB0 | devChannel); // release voices
+	if (mainThread) {
+		putMidiCommandInQueue(0x0040B0 | devChannel); // sustain off
+		putMidiCommandInQueue(0x007BB0 | devChannel); // notes off
+		putMidiCommandInQueue(0x004BB0 | devChannel); // release voices
+	} else {
+		_pMidiDrv->send(0x0040B0 | devChannel); // sustain off
+		_pMidiDrv->send(0x007BB0 | devChannel); // notes off
+		_pMidiDrv->send(0x004BB0 | devChannel); // release voices
+	}
 }
 
 
diff --git a/engines/sci/sound/music.h b/engines/sci/sound/music.h
index 4e44074630..a610f32d89 100644
--- a/engines/sci/sound/music.h
+++ b/engines/sci/sound/music.h
@@ -75,6 +75,8 @@ public:
 	SoundResource *soundRes;
 	uint16 resourceId;
 
+	int time; // "tim"estamp to indicate in which order songs have been added
+
 	bool isQueued; // for SCI0 only!
 
 	uint16 dataInc;
@@ -85,6 +87,8 @@ public:
 	int16 volume;
 	int16 hold;
 	int8 reverb;
+	bool playBed;
+	bool overridePriority; // Use soundObj's priority instead of resource's
 
 	int16 pauseCounter;
 	uint sampleLoopCounter;
@@ -224,6 +228,8 @@ public:
 
 	byte getCurrentReverb();
 
+	void needsRemap() { _needsRemap = true; }
+
 	virtual void saveLoadWithSerializer(Common::Serializer &ser);
 
 	// Mutex for music code. Used to guard access to the song playlist, to the
@@ -245,9 +251,9 @@ protected:
 	bool _useDigitalSFX;
 
 	// remapping:
-	void remapChannels();
+	void remapChannels(bool mainThread = true);
 	ChannelRemapping *determineChannelMap();
-	void resetDeviceChannel(int devChannel);
+	void resetDeviceChannel(int devChannel, bool mainThread);
 
 private:
 	MusicList _playList;
@@ -256,6 +262,7 @@ private:
 	MusicEntry *_usedChannel[16];
 	int8 _channelRemap[16];
 	int8 _globalReverb;
+	bool _needsRemap;
 
 	DeviceChannelUsage _channelMap[16];
 
@@ -266,6 +273,9 @@ private:
 	int _driverLastChannel;
 
 	MusicEntry *_currentlyPlayingSample;
+
+	int _timeCounter; // Used to keep track of the order in which MusicEntries
+	                  // are added, for priority purposes.
 };
 
 } // End of namespace Sci
diff --git a/engines/sci/sound/soundcmd.cpp b/engines/sci/sound/soundcmd.cpp
index 73e0a23a6a..ee5903fda2 100644
--- a/engines/sci/sound/soundcmd.cpp
+++ b/engines/sci/sound/soundcmd.cpp
@@ -142,11 +142,14 @@ void SoundCommandParser::processInitSound(reg_t obj) {
 
 reg_t SoundCommandParser::kDoSoundPlay(int argc, reg_t *argv, reg_t acc) {
 	debugC(kDebugLevelSound, "kDoSound(play): %04x:%04x", PRINT_REG(argv[0]));
-	processPlaySound(argv[0]);
+	bool playBed = false;
+	if (argc >= 2 && !argv[1].isNull())
+		playBed = true;
+	processPlaySound(argv[0], playBed);
 	return acc;
 }
 
-void SoundCommandParser::processPlaySound(reg_t obj) {
+void SoundCommandParser::processPlaySound(reg_t obj, bool playBed) {
 	MusicEntry *musicSlot = _music->getSlot(obj);
 	if (!musicSlot) {
 		warning("kDoSound(play): Slot not found (%04x:%04x), initializing it manually", PRINT_REG(obj));
@@ -181,15 +184,26 @@ void SoundCommandParser::processPlaySound(reg_t obj) {
 	}
 
 	musicSlot->loop = readSelectorValue(_segMan, obj, SELECTOR(loop));
-	musicSlot->priority = readSelectorValue(_segMan, obj, SELECTOR(priority));
+
+	// Get song priority from either obj or soundRes
+	byte resourcePriority = 0xFF;
+	if (musicSlot->soundRes)
+		resourcePriority = musicSlot->soundRes->getSoundPriority();
+	if (!musicSlot->overridePriority && resourcePriority != 0xFF) {
+		musicSlot->priority = resourcePriority;
+	} else {
+		musicSlot->priority = readSelectorValue(_segMan, obj, SELECTOR(priority));
+	}
+
 	// Reset hold when starting a new song. kDoSoundSetHold is always called after
 	// kDoSoundPlay to set it properly, if needed. Fixes bug #3413589.
 	musicSlot->hold = -1;
+	musicSlot->playBed = playBed;
 	if (_soundVersion >= SCI_VERSION_1_EARLY)
 		musicSlot->volume = readSelectorValue(_segMan, obj, SELECTOR(vol));
 
-	debugC(kDebugLevelSound, "kDoSound(play): %04x:%04x number %d, loop %d, prio %d, vol %d", PRINT_REG(obj),
-			resourceId, musicSlot->loop, musicSlot->priority, musicSlot->volume);
+	debugC(kDebugLevelSound, "kDoSound(play): %04x:%04x number %d, loop %d, prio %d, vol %d, bed %d", PRINT_REG(obj),
+			resourceId, musicSlot->loop, musicSlot->priority, musicSlot->volume, playBed ? 1 : 0);
 
 	_music->soundPlay(musicSlot);
 
@@ -538,7 +552,7 @@ void SoundCommandParser::processUpdateCues(reg_t obj) {
 	if (_soundVersion >= SCI_VERSION_1_EARLY) {
 		writeSelectorValue(_segMan, obj, SELECTOR(min), musicSlot->ticker / 3600);
 		writeSelectorValue(_segMan, obj, SELECTOR(sec), musicSlot->ticker % 3600 / 60);
-		writeSelectorValue(_segMan, obj, SELECTOR(frame), musicSlot->ticker);
+		writeSelectorValue(_segMan, obj, SELECTOR(frame), musicSlot->ticker % 60 / 2);
 	}
 }
 
@@ -673,23 +687,19 @@ reg_t SoundCommandParser::kDoSoundSetPriority(int argc, reg_t *argv, reg_t acc)
 	}
 
 	if (value == -1) {
-		uint16 resourceId = musicSlot->resourceId;
+		musicSlot->overridePriority = false;
+		musicSlot->priority = 0;
 
-		// Set priority from the song data
-		Resource *song = _resMan->findResource(ResourceId(kResourceTypeSound, resourceId), 0);
-		if (song->data[0] == 0xf0)
-			_music->soundSetPriority(musicSlot, song->data[1]);
-		else
-			warning("kDoSound(setPriority): Attempt to unset song priority when there is no built-in value");
+		// NB: It seems SSCI doesn't actually reset the priority here.
 
-		//pSnd->prio=0;field_15B=0
 		writeSelectorValue(_segMan, obj, SELECTOR(flags), readSelectorValue(_segMan, obj, SELECTOR(flags)) & 0xFD);
 	} else {
 		// Scripted priority
+		musicSlot->overridePriority = true;
 
-		//pSnd->field_15B=1;
 		writeSelectorValue(_segMan, obj, SELECTOR(flags), readSelectorValue(_segMan, obj, SELECTOR(flags)) | 2);
-		//DoSOund(0xF,hobj,w)
+
+		_music->soundSetPriority(musicSlot, value);
 	}
 	return acc;
 }
@@ -777,6 +787,8 @@ void SoundCommandParser::stopAllSounds() {
 }
 
 void SoundCommandParser::startNewSound(int number) {
+	// NB: This is only used by the debugging console.
+
 	Common::StackLock lock(_music->_mutex);
 
 	// Overwrite the first sound in the playlist
@@ -785,7 +797,7 @@ void SoundCommandParser::startNewSound(int number) {
 	processDisposeSound(soundObj);
 	writeSelectorValue(_segMan, soundObj, SELECTOR(number), number);
 	processInitSound(soundObj);
-	processPlaySound(soundObj);
+	processPlaySound(soundObj, false);
 }
 
 void SoundCommandParser::setMasterVolume(int vol) {
diff --git a/engines/sci/sound/soundcmd.h b/engines/sci/sound/soundcmd.h
index 4effda68e4..5bb7cf2cb1 100644
--- a/engines/sci/sound/soundcmd.h
+++ b/engines/sci/sound/soundcmd.h
@@ -63,7 +63,7 @@ public:
 	void printPlayList(Console *con);
 	void printSongInfo(reg_t obj, Console *con);
 
-	void processPlaySound(reg_t obj);
+	void processPlaySound(reg_t obj, bool playBed);
 	void processStopSound(reg_t obj, bool sampleFinishedPlaying);
 	void initSoundResource(MusicEntry *newSound);
 
diff --git a/engines/scumm/POTFILES b/engines/scumm/POTFILES
index 6d10537d3c..246f14d3f0 100644
--- a/engines/scumm/POTFILES
+++ b/engines/scumm/POTFILES
@@ -1,5 +1,6 @@
 engines/scumm/dialogs.cpp
 engines/scumm/help.cpp
+engines/scumm/input.cpp
 engines/scumm/scumm.cpp
 engines/scumm/players/player_v3m.cpp
 engines/scumm/players/player_v5m.cpp
diff --git a/engines/scumm/debugger.cpp b/engines/scumm/debugger.cpp
index 2b718b2cfe..0ebea94608 100644
--- a/engines/scumm/debugger.cpp
+++ b/engines/scumm/debugger.cpp
@@ -256,7 +256,7 @@ bool ScummDebugger::Cmd_Hide(int argc, const char **argv) {
 bool ScummDebugger::Cmd_Script(int argc, const char** argv) {
 	int scriptnum;
 
-	if (argc < 2) {
+	if (argc < 3) {
 		debugPrintf("Syntax: script <scriptnum> <command>\n");
 		return true;
 	}
diff --git a/engines/scumm/detection_tables.h b/engines/scumm/detection_tables.h
index 6eab5c752f..5a994cb699 100644
--- a/engines/scumm/detection_tables.h
+++ b/engines/scumm/detection_tables.h
@@ -306,9 +306,9 @@ static const GameSettings gameVariantsTable[] = {
 
 	// Humongous Entertainment Scumm Version 7.2
 	{"airport", "", 0, GID_HEGAME, 6, 72, MDT_NONE, GF_USE_KEY, UNK, GUIO3(GUIO_NOLAUNCHLOAD, GUIO_NOMIDI, GUIO_NOASPECT)},
+	{"farm", "", 0, GID_HEGAME, 6, 72, MDT_NONE, GF_USE_KEY, UNK, GUIO3(GUIO_NOLAUNCHLOAD, GUIO_NOMIDI, GUIO_NOASPECT)},
 
 	// Changed o_getResourceSize to cover all resource types
-	{"farm", "", 0, GID_HEGAME, 6, 73, MDT_NONE, GF_USE_KEY, UNK, GUIO3(GUIO_NOLAUNCHLOAD, GUIO_NOMIDI, GUIO_NOASPECT)},
 	{"puttzoo", "", 0, GID_PUTTZOO, 6, 73, MDT_NONE, GF_USE_KEY, UNK, GUIO3(GUIO_NOLAUNCHLOAD, GUIO_NOMIDI, GUIO_NOASPECT)},
 	{"puttzoo", "HE 72", 0, GID_PUTTZOO, 6, 72, MDT_NONE, GF_USE_KEY, UNK, GUIO3(GUIO_NOLAUNCHLOAD, GUIO_NOMIDI, GUIO_NOASPECT)},
 	{"puttzoo", "HE 98.5", 0, GID_PUTTZOO, 6, 98, MDT_NONE, GF_USE_KEY | GF_HE_985, UNK, GUIO3(GUIO_NOLAUNCHLOAD, GUIO_NOMIDI, GUIO_NOASPECT)},
@@ -812,6 +812,7 @@ static const GameFilenamePattern gameFilenamesTable[] = {
 	{ "pajama3", "PyjamaHG", kGenHEPC, Common::FR_FRA, UNK, 0 },
 	{ "pajama3", "PyjamaSKS", kGenHEPC, Common::DE_DEU, UNK, 0 },
 	{ "pajama3", "PyjamaSKS", kGenHEMac, Common::DE_DEU, Common::kPlatformMacintosh, 0 },
+	{ "pajama3", "SamLDM", kGenHEPC, Common::IT_ITA, Common::kPlatformWindows, 0 },
 	{ "pajama3", "UKPajamaEAT", kGenHEPC, Common::RU_RUS, UNK, 0 },
 
 	{ "puttcircus", "puttcircus", kGenHEPC, UNK_LANG, UNK, 0 },
@@ -830,6 +831,7 @@ static const GameFilenamePattern gameFilenamesTable[] = {
 	{ "puttrace", "500demo", kGenHEPC, Common::NL_NLD, Common::kPlatformWindows, 0 },
 	{ "puttrace", "course", kGenHEPC, Common::FR_FRA, UNK, 0 },
 	{ "puttrace", "CourseDemo", kGenHEPC, Common::FR_FRA, UNK, 0 },
+	{ "puttrace", "GasGasEG", kGenHEPC, Common::IT_ITA, Common::kPlatformWindows, 0 },
 	{ "puttrace", "racedemo", kGenHEPC, UNK_LANG, Common::kPlatformWindows, 0 },
 	{ "puttrace", "RaceDemo", kGenHEMac, UNK_LANG, Common::kPlatformMacintosh, 0 },
 	{ "puttrace", "Rennen", kGenHEPC, Common::DE_DEU, UNK, 0 },
@@ -926,6 +928,7 @@ static const GameFilenamePattern gameFilenamesTable[] = {
 	{ "spyfox2", "Sf2demo", kGenHEMac, UNK_LANG, Common::kPlatformMacintosh, 0 },
 	{ "spyfox2", "Spy Fox 2", kGenHEMac, UNK_LANG, Common::kPlatformMacintosh, 0 },
 	{ "spyfox2", "Spy Fox 2 - Demo", kGenHEMac, UNK_LANG, Common::kPlatformMacintosh, 0 },
+	{ "spyfox2", "SPyFoxMCR", kGenHEPC, Common::IT_ITA, Common::kPlatformWindows, 0 },
 	{ "spyfox2", "SpyFoxOR", kGenHEPC, Common::DE_DEU, UNK, 0 },
 	{ "spyfox2", "SpyFoxOR", kGenHEMac, Common::DE_DEU, Common::kPlatformMacintosh, 0 },
 	{ "spyfox2", "SPYFoxORE", kGenHEPC, Common::FR_FRA, UNK, 0 },
diff --git a/engines/scumm/help.cpp b/engines/scumm/help.cpp
index cfb23a392a..2281e954ef 100644
--- a/engines/scumm/help.cpp
+++ b/engines/scumm/help.cpp
@@ -36,6 +36,8 @@ int ScummHelp::numPages(byte gameId) {
 	case GID_MANIAC:
 	case GID_ZAK:
 		return 4;
+	case GID_INDY4:
+		return 5;
 	case GID_INDY3:
 		return 6;
 	case GID_LOOM:
@@ -43,7 +45,6 @@ int ScummHelp::numPages(byte gameId) {
 	case GID_MONKEY_VGA:
 	case GID_MONKEY:
 	case GID_MONKEY2:
-	case GID_INDY4:
 	case GID_TENTACLE:
 	case GID_SAMNMAX:
 	case GID_DIG:
@@ -287,10 +288,19 @@ void ScummHelp::updateStrings(byte gameId, byte version, Common::Platform platfo
 			ADD_BIND("F3", "Melissa");
 			ADD_BIND("F4", "Leslie");
 		}
+		if (gameId == GID_INDY4) {
+			ADD_BIND("i", _("Toggle Inventory/IQ Points display"));
+			ADD_BIND("f", _("Toggle Keyboard/Mouse Fighting (*)"));
+			ADD_LINE;
+			ADD_TEXT(_("* Keyboard Fighting is always on,"));
+			ADD_TEXT(_("  so despite the in-game message this"));
+			ADD_TEXT(_("  actually toggles Mouse Fighting Off/On"));
+		}
 		break;
 	case 5:
 		switch (gameId) {
 		case GID_INDY3:
+		case GID_INDY4:
 			title = _("Fighting controls (numpad):");
 			ADD_BIND("7", _("Step back"));
 			ADD_BIND("4", _("Step back"));
@@ -301,7 +311,9 @@ void ScummHelp::updateStrings(byte gameId, byte version, Common::Platform platfo
 			ADD_BIND("9", _("Punch high"));
 			ADD_BIND("6", _("Punch middle"));
 			ADD_BIND("3", _("Punch low"));
-			ADD_LINE;
+			if (gameId == GID_INDY4) {
+				ADD_BIND("0", _("Sucker punch"));
+			}
 			ADD_LINE;
 			ADD_TEXT(_("These are for Indy on left."));
 			ADD_TEXT(_("When Indy is on the right,"));
diff --git a/engines/scumm/imuse_digi/dimuse.cpp b/engines/scumm/imuse_digi/dimuse.cpp
index db260dce42..3f61946bf2 100644
--- a/engines/scumm/imuse_digi/dimuse.cpp
+++ b/engines/scumm/imuse_digi/dimuse.cpp
@@ -201,8 +201,7 @@ void IMuseDigital::saveOrLoad(Serializer *ser) {
 
 			track->stream = Audio::makeQueuingAudioStream(freq, (track->mixerFlags & kFlagStereo) != 0);
 
-			_mixer->playStream(track->getType(), &track->mixChanHandle, track->stream, -1, track->getVol(), track->getPan(),
-							DisposeAfterUse::YES, false, (track->mixerFlags & kFlagStereo) != 0);
+			_mixer->playStream(track->getType(), &track->mixChanHandle, track->stream, -1, track->getVol(), track->getPan());
 			_mixer->pauseHandle(track->mixChanHandle, true);
 		}
 	}
diff --git a/engines/scumm/imuse_digi/dimuse_track.cpp b/engines/scumm/imuse_digi/dimuse_track.cpp
index 34926fa34e..b7abdd074e 100644
--- a/engines/scumm/imuse_digi/dimuse_track.cpp
+++ b/engines/scumm/imuse_digi/dimuse_track.cpp
@@ -110,8 +110,7 @@ void IMuseDigital::startSound(int soundId, const char *soundName, int soundType,
 	track->souStreamUsed = (input != 0);
 
 	if (track->souStreamUsed) {
-		_mixer->playStream(track->getType(), &track->mixChanHandle, input, -1, track->getVol(), track->getPan(),
-							DisposeAfterUse::YES, false, (track->mixerFlags & kFlagStereo) != 0);
+		_mixer->playStream(track->getType(), &track->mixChanHandle, input, -1, track->getVol(), track->getPan());
 	} else {
 		strcpy(track->soundName, soundName);
 		track->soundDesc = _sound->openSound(soundId, soundName, soundType, volGroupId, -1);
@@ -167,8 +166,7 @@ void IMuseDigital::startSound(int soundId, const char *soundName, int soundType,
 		}
 
 		track->stream = Audio::makeQueuingAudioStream(freq, track->mixerFlags & kFlagStereo);
-		_mixer->playStream(track->getType(), &track->mixChanHandle, track->stream, -1, track->getVol(), track->getPan(),
-							DisposeAfterUse::YES, false, (track->mixerFlags & kFlagStereo) != 0);
+		_mixer->playStream(track->getType(), &track->mixChanHandle, track->stream, -1, track->getVol(), track->getPan());
 	}
 
 	track->used = true;
@@ -368,8 +366,7 @@ Track *IMuseDigital::cloneToFadeOutTrack(Track *track, int fadeDelay) {
 
 	// Create an appendable output buffer
 	fadeTrack->stream = Audio::makeQueuingAudioStream(_sound->getFreq(fadeTrack->soundDesc), track->mixerFlags & kFlagStereo);
-	_mixer->playStream(track->getType(), &fadeTrack->mixChanHandle, fadeTrack->stream, -1, fadeTrack->getVol(), fadeTrack->getPan(),
-							DisposeAfterUse::YES, false, (track->mixerFlags & kFlagStereo) != 0);
+	_mixer->playStream(track->getType(), &fadeTrack->mixChanHandle, fadeTrack->stream, -1, fadeTrack->getVol(), fadeTrack->getPan());
 	fadeTrack->used = true;
 
 	debug(5, "cloneToFadeOutTrack() - end of func, soundId %d, fade soundId %d", track->soundId, fadeTrack->soundId);
diff --git a/engines/scumm/input.cpp b/engines/scumm/input.cpp
index 86048af57c..3ce053f6bc 100644
--- a/engines/scumm/input.cpp
+++ b/engines/scumm/input.cpp
@@ -23,6 +23,7 @@
 #include "common/config-manager.h"
 #include "common/events.h"
 #include "common/system.h"
+#include "common/translation.h"
 
 #include "gui/message.h"
 #include "gui/gui-manager.h"
@@ -568,9 +569,9 @@ void ScummEngine::processKeyboard(Common::KeyState lastKeyHit) {
 		lastKeyHit.hasFlags(Common::KBD_CTRL)) {
 		_snapScroll ^= 1;
 		if (_snapScroll) {
-			messageDialog("Snap scroll on");
+			messageDialog(_("Snap scroll on"));
 		} else {
-			messageDialog("Snap scroll off");
+			messageDialog(_("Snap scroll off"));
 		}
 
 		if (VAR_CAMERA_FAST_X != 0xFF)
@@ -583,7 +584,7 @@ void ScummEngine::processKeyboard(Common::KeyState lastKeyHit) {
 			vol--;
 
 		// Display the music volume
-		ValueDisplayDialog dlg("Music volume: ", 0, 16, vol, ']', '[');
+		ValueDisplayDialog dlg(_("Music volume: "), 0, 16, vol, ']', '[');
 		vol = runDialog(dlg);
 
 		vol *= 16;
@@ -600,7 +601,7 @@ void ScummEngine::processKeyboard(Common::KeyState lastKeyHit) {
 			_defaultTalkDelay++;
 
 		// Display the talk speed
-		ValueDisplayDialog dlg("Subtitle speed: ", 0, 9, 9 - _defaultTalkDelay, '+', '-');
+		ValueDisplayDialog dlg(_("Subtitle speed: "), 0, 9, 9 - _defaultTalkDelay, '+', '-');
 		_defaultTalkDelay = 9 - runDialog(dlg);
 
 		// Save the new talkspeed value to ConfMan
diff --git a/engines/scumm/players/player_ad.cpp b/engines/scumm/players/player_ad.cpp
index adcda68e10..4d4be2c3c2 100644
--- a/engines/scumm/players/player_ad.cpp
+++ b/engines/scumm/players/player_ad.cpp
@@ -27,6 +27,7 @@
 #include "scumm/saveload.h"
 
 #include "audio/fmopl.h"
+#include "audio/mixer.h"
 
 #include "common/textconsole.h"
 #include "common/config-manager.h"
@@ -35,26 +36,19 @@ namespace Scumm {
 
 #define AD_CALLBACK_FREQUENCY 472
 
-Player_AD::Player_AD(ScummEngine *scumm, Audio::Mixer *mixer)
-	: _vm(scumm), _mixer(mixer), _rate(mixer->getOutputRate()) {
+Player_AD::Player_AD(ScummEngine *scumm)
+	: _vm(scumm) {
 	_opl2 = OPL::Config::create();
-	if (!_opl2->init(_rate)) {
+	if (!_opl2->init()) {
 		error("Could not initialize OPL2 emulator");
 	}
 
-	_samplesPerCallback = _rate / AD_CALLBACK_FREQUENCY;
-	_samplesPerCallbackRemainder = _rate % AD_CALLBACK_FREQUENCY;
-	_samplesTillCallback = 0;
-	_samplesTillCallbackRemainder = 0;
-
 	memset(_registerBackUpTable, 0, sizeof(_registerBackUpTable));
 	writeReg(0x01, 0x00);
 	writeReg(0xBD, 0x00);
 	writeReg(0x08, 0x00);
 	writeReg(0x01, 0x20);
 
-	_mixer->playStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
-
 	_engineMusicTimer = 0;
 	_soundPlaying = -1;
 
@@ -78,11 +72,11 @@ Player_AD::Player_AD(ScummEngine *scumm, Audio::Mixer *mixer)
 
 	_musicVolume = _sfxVolume = 255;
 	_isSeeking = false;
+
+	_opl2->start(new Common::Functor0Mem<void, Player_AD>(this, &Player_AD::onTimer), AD_CALLBACK_FREQUENCY);
 }
 
 Player_AD::~Player_AD() {
-	_mixer->stopHandle(_soundHandle);
-
 	stopAllSounds();
 	Common::StackLock lock(_mutex);
 	delete _opl2;
@@ -244,36 +238,14 @@ void Player_AD::saveLoadWithSerializer(Serializer *ser) {
 	}
 }
 
-int Player_AD::readBuffer(int16 *buffer, const int numSamples) {
+void Player_AD::onTimer() {
 	Common::StackLock lock(_mutex);
 
-	int len = numSamples;
-
-	while (len > 0) {
-		if (!_samplesTillCallback) {
-			if (_curOffset) {
-				updateMusic();
-			}
-
-			updateSfx();
-
-			_samplesTillCallback = _samplesPerCallback;
-			_samplesTillCallbackRemainder += _samplesPerCallbackRemainder;
-			if (_samplesTillCallbackRemainder >= AD_CALLBACK_FREQUENCY) {
-				++_samplesTillCallback;
-				_samplesTillCallbackRemainder -= AD_CALLBACK_FREQUENCY;
-			}
-		}
-
-		const int samplesToRead = MIN(len, _samplesTillCallback);
-		_opl2->readBuffer(buffer, samplesToRead);
-
-		buffer += samplesToRead;
-		len -= samplesToRead;
-		_samplesTillCallback -= samplesToRead;
+	if (_curOffset) {
+		updateMusic();
 	}
 
-	return numSamples;
+	updateSfx();
 }
 
 void Player_AD::setupVolume() {
diff --git a/engines/scumm/players/player_ad.h b/engines/scumm/players/player_ad.h
index 63a8503f47..63fda3cc7c 100644
--- a/engines/scumm/players/player_ad.h
+++ b/engines/scumm/players/player_ad.h
@@ -26,7 +26,6 @@
 #include "scumm/music.h"
 
 #include "audio/audiostream.h"
-#include "audio/mixer.h"
 
 #include "common/mutex.h"
 
@@ -41,9 +40,9 @@ class ScummEngine;
 /**
  * Sound output for v3/v4 AdLib data.
  */
-class Player_AD : public MusicEngine, public Audio::AudioStream {
+class Player_AD : public MusicEngine {
 public:
-	Player_AD(ScummEngine *scumm, Audio::Mixer *mixer);
+	Player_AD(ScummEngine *scumm);
 	virtual ~Player_AD();
 
 	// MusicEngine API
@@ -56,18 +55,12 @@ public:
 
 	virtual void saveLoadWithSerializer(Serializer *ser);
 
-	// AudioStream API
-	virtual int readBuffer(int16 *buffer, const int numSamples);
-	virtual bool isStereo() const { return false; }
-	virtual bool endOfData() const { return false; }
-	virtual int getRate() const { return _rate; }
+	// Timer callback
+	void onTimer();
 
 private:
 	ScummEngine *const _vm;
 	Common::Mutex _mutex;
-	Audio::Mixer *const _mixer;
-	const int _rate;
-	Audio::SoundHandle _soundHandle;
 
 	void setupVolume();
 	int _musicVolume;
@@ -75,11 +68,6 @@ private:
 
 	OPL::OPL *_opl2;
 
-	int _samplesPerCallback;
-	int _samplesPerCallbackRemainder;
-	int _samplesTillCallback;
-	int _samplesTillCallbackRemainder;
-
 	int _soundPlaying;
 	int32 _engineMusicTimer;
 
diff --git a/engines/scumm/players/player_towns.cpp b/engines/scumm/players/player_towns.cpp
index 5b8ca04021..d540fc4f6b 100644
--- a/engines/scumm/players/player_towns.cpp
+++ b/engines/scumm/players/player_towns.cpp
@@ -202,23 +202,24 @@ Player_Towns_v1::Player_Towns_v1(ScummEngine *vm, Audio::Mixer *mixer) : Player_
 		memset(_soundOverride, 0, _numSoundMax * sizeof(SoundOvrParameters));
 	}
 
-	_driver = new TownsEuphonyDriver(mixer);
+	_player = new EuphonyPlayer(mixer);
+	_intf = new TownsAudioInterface(mixer, 0);
 }
 
 Player_Towns_v1::~Player_Towns_v1() {
-	delete _driver;
+	delete _intf;
+	delete _player;
 	delete[] _soundOverride;
 }
 
 bool Player_Towns_v1::init() {
-	if (!_driver)
+	if (!_player)
 		return false;
 
-	if (!_driver->init())
+	if (!_player->init())
 		return false;
 
-	_driver->reserveSoundEffectChannels(8);
-	_intf = _driver->intf();
+	_player->driver()->reserveSoundEffectChannels(8);
 
 	// Treat all 6 fm channels and all 8 pcm channels as sound effect channels
 	// since music seems to exist as CD audio only in the games which use this
@@ -231,7 +232,7 @@ bool Player_Towns_v1::init() {
 }
 
 void Player_Towns_v1::setMusicVolume(int vol) {
-	_driver->setMusicVolume(vol);
+	_player->driver()->setMusicVolume(vol);
 }
 
 void Player_Towns_v1::startSound(int sound) {
@@ -254,7 +255,9 @@ void Player_Towns_v1::startSound(int sound) {
 		uint16 len = READ_LE_UINT16(ptr) + 2;
 		playPcmTrack(sound, ptr + 6, velocity, 64, note ? note : (len > 50 ? ptr[50] : 60), READ_LE_UINT16(ptr + 10));
 
-	} else if (type == 1) {
+		// WORKAROUND for bug #1873 INDY3 FMTOWNS: Music in Venice is distorted
+		// The resource for sound 40 accidently sets the sound type to 255 instead of 1.
+	} else if (type == 1 || (_vm->_game.id == GID_INDY3 && sound == 40)) {
 		playEuphonyTrack(sound, ptr + 6);
 
 	} else if (type == 2) {
@@ -275,7 +278,7 @@ void Player_Towns_v1::stopSound(int sound) {
 	if (sound != 0 && sound == _eupCurrentSound) {
 		_eupCurrentSound = 0;
 		_eupLooping = false;
-		_driver->stopParser();
+		_player->stop();
 	}
 
 	stopPcmTrack(sound);
@@ -288,7 +291,7 @@ void Player_Towns_v1::stopAllSounds() {
 
 	_eupCurrentSound = 0;
 	_eupLooping = false;
-	_driver->stopParser();
+	_player->stop();
 
 	stopPcmTrack(0);
 }
@@ -297,7 +300,7 @@ int Player_Towns_v1::getSoundStatus(int sound) const {
 	if (sound == _cdaCurrentSound)
 		return _vm->_sound->pollCD();
 	if (sound == _eupCurrentSound)
-		return _driver->parserIsPlaying() ? 1 : 0;
+		return _player->isPlaying() ? 1 : 0;
 	return Player_Towns::getSoundStatus(sound);
 }
 
@@ -306,7 +309,7 @@ int32 Player_Towns_v1::doCommand(int numargs, int args[]) {
 
 	switch (args[0]) {
 	case 2:
-		_driver->intf()->callback(73, 0);
+		_player->driver()->cdaToggle(0);
 		break;
 
 	case 3:
@@ -344,7 +347,7 @@ int32 Player_Towns_v1::doCommand(int numargs, int args[]) {
 void Player_Towns_v1::setVolumeCD(int left, int right) {
 	_cdaVolLeft = left & 0xff;
 	_cdaVolRight = right & 0xff;
-	_driver->setOutputVolume(1, left >> 1, right >> 1);
+	_player->driver()->setOutputVolume(1, left >> 1, right >> 1);
 }
 
 void Player_Towns_v1::setSoundVolume(int sound, int left, int right) {
@@ -373,7 +376,7 @@ void Player_Towns_v1::saveLoadWithSerializer(Serializer *ser) {
 
 	ser->saveLoadEntries(this, cdEntries);
 
-	if (!_eupLooping && !_driver->parserIsPlaying())
+	if (!_eupLooping && !_player->isPlaying())
 		_eupCurrentSound = 0;
 
 	static const SaveLoadEntry eupEntries[] = {
@@ -409,7 +412,9 @@ void Player_Towns_v1::restoreAfterLoad() {
 		if (_vm->_game.version != 3)
 			ptr += 2;
 
-		if (ptr[7] == 1) {
+		// WORKAROUND for bug #1873 INDY3 FMTOWNS: Music in Venice is distorted
+		// The resource for sound 40 accidently sets the sound type to 255 instead of 1.
+		if (ptr[7] == 1 || (_vm->_game.id == GID_INDY3 && _eupCurrentSound == 40)) {
 			setSoundVolume(_eupCurrentSound, _eupVolLeft, _eupVolRight);
 			playEuphonyTrack(_eupCurrentSound, ptr);
 		}
@@ -439,10 +444,10 @@ void Player_Towns_v1::restartLoopingSounds() {
 			c++;
 		}
 
-		_driver->playSoundEffect(i + 0x3f, _pcmCurrentSound[i].note, _pcmCurrentSound[i].velo, ptr);
+		_player->driver()->playSoundEffect(i + 0x3f, _pcmCurrentSound[i].note, _pcmCurrentSound[i].velo, ptr);
 	}
 
-	_driver->intf()->callback(73, 1);
+	_player->driver()->cdaToggle(1);
 }
 
 void Player_Towns_v1::startSoundEx(int sound, int velo, int pan, int note) {
@@ -492,9 +497,9 @@ void Player_Towns_v1::stopSoundSuspendLooping(int sound) {
 	} else {
 		for (int i = 1; i < 9; i++) {
 			if (sound == _pcmCurrentSound[i].index) {
-				if (!_driver->soundEffectIsPlaying(i + 0x3f))
+				if (!_player->driver()->soundEffectIsPlaying(i + 0x3f))
 					continue;
-				_driver->stopSoundEffect(i + 0x3f);
+				_player->driver()->stopSoundEffect(i + 0x3f);
 				if (_pcmCurrentSound[i].looping)
 					_pcmCurrentSound[i].paused = 1;
 				else
@@ -510,23 +515,23 @@ void Player_Towns_v1::playEuphonyTrack(int sound, const uint8 *data) {
 	const uint8 *trackData = src + 150;
 
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_enable(i, *src++);
+		_player->configPart_enable(i, *src++);
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_setMode(i, 0xff);
+		_player->configPart_setType(i, 0xff);
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_remap(i, *src++);
+		_player->configPart_remap(i, *src++);
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_adjustVolume(i, *src++);
+		_player->configPart_adjustVolume(i, *src++);
 	for (int i = 0; i < 32; i++)
-		_driver->configChan_setTranspose(i, *src++);
+		_player->configPart_setTranspose(i, *src++);
 
 	src += 8;
 	for (int i = 0; i < 6; i++)
-		_driver->assignChannel(i, *src++);
+		_player->driver()->assignPartToChannel(i, *src++);
 
 	for (int i = 0; i < data[14]; i++) {
-		_driver->loadInstrument(i, i, pos + i * 48);
-		_driver->intf()->callback(4, i, i);
+		_player->driver()->loadInstrument(i, i, pos + i * 48);
+		_player->driver()->setInstrument(i, i);
 	}
 
 	_eupVolLeft = _soundOverride[sound].vLeft;
@@ -537,18 +542,18 @@ void Player_Towns_v1::playEuphonyTrack(int sound, const uint8 *data) {
 	lvl >>= 2;
 
 	for (int i = 0; i < 6; i++)
-		_driver->chanVolume(i, lvl);
+		_player->driver()->channelVolume(i, lvl);
 
 	uint32 trackSize = READ_LE_UINT32(src);
 	src += 4;
 	uint8 startTick = *src++;
 
-	_driver->setMusicTempo(*src++);
-	_driver->startMusicTrack(trackData, trackSize, startTick);
+	_player->setTempo(*src++);
+	_player->startTrack(trackData, trackSize, startTick);
 
 	_eupLooping = (*src != 1) ? 1 : 0;
-	_driver->setMusicLoop(_eupLooping != 0);
-	_driver->continueParsing();
+	_player->setLoopStatus(_eupLooping != 0);
+	_player->resume();
 	_eupCurrentSound = sound;
 }
 
diff --git a/engines/scumm/players/player_towns.h b/engines/scumm/players/player_towns.h
index 3736524ee2..576d17e392 100644
--- a/engines/scumm/players/player_towns.h
+++ b/engines/scumm/players/player_towns.h
@@ -104,8 +104,6 @@ public:
 	void saveLoadWithSerializer(Serializer *ser);
 	void restoreAfterLoad();
 
-	TownsEuphonyDriver *driver() { return _driver; }
-
 private:
 	void restartLoopingSounds();
 	void startSoundEx(int sound, int velo, int pan, int note);
@@ -137,7 +135,7 @@ private:
 	uint8 _cdaCurrentSoundTemp;
 	uint8 _cdaNumLoopsTemp;
 
-	TownsEuphonyDriver *_driver;
+	EuphonyPlayer *_player;
 };
 
 class Player_Towns_v2 : public Player_Towns {
diff --git a/engines/scumm/scumm-md5.h b/engines/scumm/scumm-md5.h
index 5be18fb990..c85073b877 100644
--- a/engines/scumm/scumm-md5.h
+++ b/engines/scumm/scumm-md5.h
@@ -1,5 +1,5 @@
 /*
-  This file was generated by the md5table tool on Sun Dec  7 23:09:10 2014
+  This file was generated by the md5table tool on Thu Aug 27 23:44:49 2015
   DO NOT EDIT MANUALLY!
  */
 
@@ -27,6 +27,7 @@ static const MD5Table md5table[] = {
 	{ "0557df19f046a84c2fdc63507c6616cb", "farm", "HE 72", "Demo", -1, Common::NL_NLD, Common::kPlatformWindows },
 	{ "055ffe4f47753e47594ac67823220c54", "puttrace", "HE 99", "", -1, Common::DE_DEU, Common::kPlatformUnknown },
 	{ "057c9b456dedcc4d71b991a3072a20b3", "monkey", "SEGA", "", 9465, Common::JA_JPN, Common::kPlatformSegaCD },
+	{ "05d3143827ab4f5d2521a1a47dab8ff2", "puttrace", "HE 98", "", -1, Common::IT_ITA, Common::kPlatformUnknown },
 	{ "06b187468113f9ae5a400b148a847fac", "atlantis", "Floppy", "Floppy", 12075, Common::EN_ANY, Common::kPlatformMacintosh },
 	{ "06c3cf4f31daad8b1cd93153491db9e6", "pajama3", "", "", 79382, Common::NL_NLD, Common::kPlatformUnknown },
 	{ "07433205acdca3bc553d0e731588b35f", "airport", "", "", -1, Common::EN_ANY, Common::kPlatformWindows },
@@ -67,6 +68,7 @@ static const MD5Table md5table[] = {
 	{ "114acdc2659a273c220f86ee9edb24c1", "maniac", "V2", "V2", -1, Common::FR_FRA, Common::kPlatformDOS },
 	{ "11ddf1fde76e3156eb3a38da213f484e", "monkey2", "", "", -1, Common::IT_ITA, Common::kPlatformAmiga },
 	{ "11e6e244078ff09b0f3832e35420e0a7", "catalog", "", "Demo", -1, Common::EN_ANY, Common::kPlatformWindows },
+	{ "12cdc256eae5a461bcc9a49975999841", "atlantis", "Floppy", "Demo", -1, Common::EN_ANY, Common::kPlatformDOS },
 	{ "132bff65e6367c09cc69318ce1b59333", "monkey2", "", "", 11155, Common::EN_ANY, Common::kPlatformAmiga },
 	{ "1387d16aa620dc1c2d1fd87f8a9e7a09", "puttcircus", "", "Demo", -1, Common::FR_FRA, Common::kPlatformWindows },
 	{ "13d2a86a7290813a1c386490447d72db", "fbear", "HE 62", "", -1, Common::EN_ANY, Common::kPlatform3DO },
@@ -119,6 +121,7 @@ static const MD5Table md5table[] = {
 	{ "22c9eb04455440131ffc157aeb8d40a8", "fbear", "HE 70", "Demo", -1, Common::EN_ANY, Common::kPlatformWindows },
 	{ "22de86b2f7ec6e5db745ed1123310b44", "spyfox2", "", "Demo", 15832, Common::FR_FRA, Common::kPlatformWindows },
 	{ "22f4ea88a09da12df9308ba30bcb7d0f", "loom", "EGA", "EGA", -1, Common::EN_ANY, Common::kPlatformDOS },
+	{ "2328be0317008ef047eed7912a4b0850", "pajama2", "HE 98.5", "", -1, Common::EN_GRB, Common::kPlatformWindows },
 	{ "23394c8d29cc63c61313959431a12476", "spyfox", "HE 100", "Updated", -1, Common::EN_ANY, Common::kPlatformWindows },
 	{ "24942a4200d99bdb4bdb78f9c7e07027", "pajama3", "", "Mini Game", 13911, Common::NL_NLD, Common::kPlatformWindows },
 	{ "254fede2f15dbb32a23760d601b01816", "zak", "V1", "", -1, Common::EN_ANY, Common::kPlatformC64 },
@@ -164,6 +167,7 @@ static const MD5Table md5table[] = {
 	{ "3686cf8f89e102ececf4366e1d2c8126", "monkey2", "", "", 11135, Common::EN_ANY, Common::kPlatformDOS },
 	{ "36a6750e03fb505fc19fc2bf3e4dbe91", "pajama2", "", "Demo", 58749, Common::EN_ANY, Common::kPlatformUnknown },
 	{ "3769b56c9a22f5521d74525ee459f88d", "puttrace", "HE 99", "Demo", 13108, Common::DE_DEU, Common::kPlatformWindows },
+	{ "3785fd25f7e02b5782bfc5072d8f77c8", "spyfox2", "", "", -1, Common::IT_ITA, Common::kPlatformUnknown },
 	{ "37aed3f91c1ef959e0bd265f9b13781f", "pajama", "HE 100", "Updated", -1, Common::EN_USA, Common::kPlatformUnknown },
 	{ "37f56ceb13e401a7ac7d9e6b37fecaf7", "loom", "EGA", "EGA", 5748, Common::EN_ANY, Common::kPlatformDOS },
 	{ "37ff1b308999c4cca7319edfcc1280a0", "puttputt", "HE 70", "Demo", 8269, Common::EN_ANY, Common::kPlatformWindows },
@@ -176,7 +180,7 @@ static const MD5Table md5table[] = {
 	{ "3a03dab514e4038df192d8a8de469788", "atlantis", "Floppy", "Floppy", -1, Common::EN_ANY, Common::kPlatformAmiga },
 	{ "3a0c35f3c147b98a2bdf8d400cfc4ab5", "indy3", "FM-TOWNS", "", -1, Common::JA_JPN, Common::kPlatformFMTowns },
 	{ "3a3e592b074f595489f7f11e150c398d", "puttzoo", "HE 99", "Updated", -1, Common::EN_USA, Common::kPlatformWindows },
-	{ "3a5d13675e9a23aedac0bac7730f0ac1", "samnmax", "", "CD", -1, Common::FR_FRA, Common::kPlatformMacintosh },
+	{ "3a5d13675e9a23aedac0bac7730f0ac1", "samnmax", "", "CD", 228446581, Common::FR_FRA, Common::kPlatformMacintosh },
 	{ "3a5ec90d556d4920976c5578bfbfaf79", "maniac", "NES", "", -1, Common::DE_DEU, Common::kPlatformNES },
 	{ "3ae7f002d9256b8bdf76aaf8a3a069f8", "freddi", "HE 100", "", 34837, Common::EN_GRB, Common::kPlatformWii },
 	{ "3af61c5edf8e15b43dbafd285b2e9777", "puttcircus", "", "Demo", -1, Common::HE_ISR, Common::kPlatformWindows },
@@ -189,6 +193,7 @@ static const MD5Table md5table[] = {
 	{ "3df6ead57930488bc61e6e41901d0e97", "fbear", "HE 62", "", -1, Common::EN_ANY, Common::kPlatformMacintosh },
 	{ "3e48298920fab9b7aec5a971e1bd1fab", "pajama3", "", "Demo", -1, Common::EN_GRB, Common::kPlatformWindows },
 	{ "3e861421f494711bc6f619d4aba60285", "airport", "", "", 93231, Common::RU_RUS, Common::kPlatformWindows },
+	{ "403d2ec4d60d3cdae925e6cbf67716d6", "ft", "", "", 489436643, Common::FR_FRA, Common::kPlatformMacintosh },
 	{ "40564ec47da48a67787d1f9bd043902a", "maniac", "V2 Demo", "V2 Demo", 1988, Common::EN_ANY, Common::kPlatformDOS },
 	{ "4167a92a1d46baa4f4127d918d561f88", "tentacle", "", "CD", 7932, Common::EN_ANY, Common::kPlatformUnknown },
 	{ "41958e24d03181ff9a381a66d048a581", "ft", "", "", -1, Common::PT_BRA, Common::kPlatformUnknown },
@@ -250,6 +255,7 @@ static const MD5Table md5table[] = {
 	{ "55f4e9402bec2bded383843123f37c5c", "pajama2", "HE 98.5", "", -1, Common::DE_DEU, Common::kPlatformWindows },
 	{ "566165a7338fa11029e7c14d94fa70d0", "freddi", "HE 73", "Demo", 9800, Common::EN_ANY, Common::kPlatformWindows },
 	{ "56b5922751be7ffd771b38dda56b028b", "freddi", "HE 100", "", 34837, Common::NL_NLD, Common::kPlatformWii },
+	{ "56e8c37a0a08c3a7076f82417461a877", "indy3", "EGA", "EGA", -1, Common::EN_ANY, Common::kPlatformDOS },
 	{ "5719fc8a13b4638b78d9d8d12f091f94", "puttrace", "HE 99", "", -1, Common::FR_FRA, Common::kPlatformWindows },
 	{ "5798972220cd458be2626d54c80f71d7", "atlantis", "Floppy", "Floppy", -1, Common::IT_ITA, Common::kPlatformAmiga },
 	{ "57a17febe2183f521250e55d55b83e60", "PuttTime", "HE 99", "", -1, Common::FR_FRA, Common::kPlatformWindows },
@@ -266,7 +272,7 @@ static const MD5Table md5table[] = {
 	{ "5c21fc49aee8f46e58fef21579e614a1", "thinker1", "", "", -1, Common::EN_USA, Common::kPlatformUnknown },
 	{ "5c9cecbd2952ccec14c9ecebf5822a34", "puttzoo", "HE 100", "", -1, Common::EN_ANY, Common::kPlatformIOS },
 	{ "5d88b9d6a88e6f8e90cded9d01b7f082", "loom", "VGA", "VGA", 8307, Common::EN_ANY, Common::kPlatformDOS },
-	{ "5dda73606533d66a4c3f4f9ea6e842af", "farm", "", "", 87061, Common::RU_RUS, Common::kPlatformWindows },
+	{ "5dda73606533d66a4c3f4f9ea6e842af", "farm", "HE 73", "", 87061, Common::RU_RUS, Common::kPlatformWindows },
 	{ "5e8fb66971a60e523e5afbc4c129c0e8", "socks", "HE 85", "", -1, Common::EN_USA, Common::kPlatformUnknown },
 	{ "5ebb57234b2fe5c5dff641e00184ad81", "freddi", "HE 73", "", -1, Common::FR_FRA, Common::kPlatformWindows },
 	{ "5fbe557049892eb4b709d90916ec97ca", "indy3", "EGA", "EGA", 5361, Common::EN_ANY, Common::kPlatformDOS },
@@ -282,6 +288,7 @@ static const MD5Table md5table[] = {
 	{ "62b8c16b6db226ba95aaa8be73f9885c", "indy3", "EGA", "EGA", -1, Common::ES_ESP, Common::kPlatformAmiga },
 	{ "632d2fddb8ba97723fa15334763ae857", "thinker1", "", "", 33270, Common::EN_ANY, Common::kPlatformWindows },
 	{ "63fdcdc95cdeea00060883aed38e5504", "PuttTime", "HE 85", "", -1, Common::EN_ANY, Common::kPlatformUnknown },
+	{ "64a22be96d679018696e5c8d3ca8b71d", "freddi", "HE 73", "", 26375, Common::JA_JPN, Common::kPlatformWindows },
 	{ "6508fd55530e6915507e1cc37f7f045d", "indy3", "EGA", "EGA", -1, Common::EN_ANY, Common::kPlatformDOS },
 	{ "65563295c3a06493351870f20a1630cf", "spyozon", "HE CUP", "Preview", 5235008, Common::UNK_LANG, Common::kPlatformUnknown },
 	{ "659942b9a6b519f123a13cca3c333a13", "jungle", "", "", -1, Common::EN_ANY, Common::kPlatformMacintosh },
@@ -376,6 +383,7 @@ static const MD5Table md5table[] = {
 	{ "8368f552b1e3eba559f8d559bcc4cadb", "freddi3", "", "", -1, Common::UNK_LANG, Common::kPlatformUnknown },
 	{ "839a658f7d22de00787ebc945348cdb6", "dog", "", "", 19681, Common::DE_DEU, Common::kPlatformWindows },
 	{ "83cedbe26aa8b58988e984e3d34cac8e", "freddi3", "HE 99", "", -1, Common::DE_DEU, Common::kPlatformUnknown },
+	{ "83e7a9205567dceb456ee35eeaf26ffa", "pajama3", "", "", -1, Common::IT_ITA, Common::kPlatformUnknown },
 	{ "84e3c23a49ded8a6f9197735c8eb3de7", "PuttTime", "HE 85", "", -1, Common::DE_DEU, Common::kPlatformWindows },
 	{ "8539c0ff89868e55a08e652ac44daaae", "water", "HE 98.5", "", -1, Common::NL_NLD, Common::kPlatformUnknown },
 	{ "861e59ed72a1cd0e6d454f7ee7e2bf3d", "comi", "", "", -1, Common::RU_RUS, Common::kPlatformWindows },
@@ -458,7 +466,7 @@ static const MD5Table md5table[] = {
 	{ "a194f15f51ee62badab74b9e7da97693", "baseball2001", "", "Demo", 20507, Common::EN_ANY, Common::kPlatformUnknown },
 	{ "a197a87ae77f3b3333f09a7a2c448fe2", "freddi", "HE 99", "Updated", -1, Common::EN_ANY, Common::kPlatformWindows },
 	{ "a22af0ad0e3126d19d22707b0267a37d", "balloon", "HE 80", "", -1, Common::NL_NLD, Common::kPlatformWindows },
-	{ "a2386da005672cbd5136f4f27a626c5f", "farm", "", "", 87061, Common::NL_NLD, Common::kPlatformWindows },
+	{ "a2386da005672cbd5136f4f27a626c5f", "farm", "HE 73", "", 87061, Common::NL_NLD, Common::kPlatformWindows },
 	{ "a28135a7ade38cc0208b04507c46efd1", "spyfox", "HE 99", "", -1, Common::DE_DEU, Common::kPlatformUnknown },
 	{ "a2bb6aa0537402c1b3c2ea899ccef64b", "lost", "HE 99", "Demo", 15540, Common::EN_ANY, Common::kPlatformWindows },
 	{ "a3036878840720fbefa41e6965fa4a0a", "samnmax", "Floppy", "Floppy", -1, Common::EN_ANY, Common::kPlatformDOS },
@@ -473,7 +481,7 @@ static const MD5Table md5table[] = {
 	{ "a654fb60c3b67d6317a7894ffd9f25c5", "pajama3", "", "Demo", -1, Common::EN_USA, Common::kPlatformUnknown },
 	{ "a71014c53a6d18c66ef2ea0ee42328e9", "PuttTime", "HE 99", "Mini Game", 18458, Common::NL_NLD, Common::kPlatformWindows },
 	{ "a7cacad9c40c4dc9e1812abf6c8af9d5", "puttcircus", "", "Demo", -1, Common::EN_ANY, Common::kPlatformUnknown },
-	{ "a85856675429fe88051744f755b72f93", "farm", "", "", -1, Common::EN_ANY, Common::kPlatformWindows },
+	{ "a85856675429fe88051744f755b72f93", "farm", "HE 73", "", -1, Common::EN_ANY, Common::kPlatformWindows },
 	{ "a86f9c49355579c30d4a55b477c0d869", "baseball2001", "", "", -1, Common::EN_ANY, Common::kPlatformUnknown },
 	{ "a8fcc3084ad5e3e569722755f205b1ef", "pajama3", "", "Mini Game", 13911, Common::DE_DEU, Common::kPlatformWindows },
 	{ "a9543ef0d79bcb47cd76ec197ad0a967", "puttmoon", "", "", -1, Common::EN_ANY, Common::kPlatform3DO },
@@ -637,13 +645,13 @@ static const MD5Table md5table[] = {
 	{ "ecc4340c2b801f5af8da4e00c0e432d9", "puttcircus", "", "", -1, Common::NL_NLD, Common::kPlatformUnknown },
 	{ "ed2b074bc3166087a747acb2a3c6abb0", "freddi3", "HE 98.5", "Demo", -1, Common::DE_DEU, Common::kPlatformUnknown },
 	{ "ed361270102e355afe5236954216aba2", "lost", "", "", -1, Common::EN_USA, Common::kPlatformUnknown },
-	{ "ede149fda3edfc1dbd7347e0737cb583", "tentacle", "", "CD", -1, Common::FR_FRA, Common::kPlatformMacintosh },
+	{ "ede149fda3edfc1dbd7347e0737cb583", "tentacle", "", "CD", 282830409, Common::FR_FRA, Common::kPlatformMacintosh },
 	{ "edfdb24a499d92c59f824c52987c0eec", "atlantis", "Floppy", "Floppy", -1, Common::FR_FRA, Common::kPlatformDOS },
 	{ "ee41f6afbc5b26fa475754b56fe92048", "puttputt", "HE 61", "", 8032, Common::JA_JPN, Common::kPlatform3DO },
 	{ "ee785fe2569bc9965526e774f7ab86f1", "spyfox", "HE 99", "", -1, Common::FR_FRA, Common::kPlatformMacintosh },
 	{ "ee8cfeb76e55d43a01c25e0865a9db76", "puttrace", "HE 98", "Demo", 13135, Common::NL_NLD, Common::kPlatformMacintosh },
 	{ "eea4d9ac2fb6f145945a308e8866915b", "maniac", "C64", "", -1, Common::EN_ANY, Common::kPlatformC64 },
-	{ "eeb606c2d2ec877a712a9f20c10bcdda", "farm", "", "", 87034, Common::NL_NLD, Common::kPlatformMacintosh },
+	{ "eeb606c2d2ec877a712a9f20c10bcdda", "farm", "HE 73", "", 87034, Common::NL_NLD, Common::kPlatformMacintosh },
 	{ "ef347474f3c7be3b29584eaa133cca05", "samnmax", "Floppy", "Floppy", -1, Common::FR_FRA, Common::kPlatformDOS },
 	{ "ef71a322b6530ac45b1a070f7c0795f7", "moonbase", "Demo", "Demo", -1, Common::EN_ANY, Common::kPlatformWindows },
 	{ "ef74d9071d4e564b037cb44bd6774de7", "fbear", "HE 62", "", -1, Common::HE_ISR, Common::kPlatformDOS },
@@ -651,6 +659,7 @@ static const MD5Table md5table[] = {
 	{ "f049e38c1f8302b5db6170f1872af89a", "monkey", "CD", "CD", 8955, Common::ES_ESP, Common::kPlatformDOS },
 	{ "f06e66fd45b2f8b0f4a2833ff4476050", "fbpack", "", "", -1, Common::HE_ISR, Common::kPlatformDOS },
 	{ "f08145577e4f13584cc90b3d6e9caa55", "pajama3", "", "Demo", -1, Common::NL_NLD, Common::kPlatformUnknown },
+	{ "f0ccc12a8704bf57706b42a37f877128", "tentacle", "Floppy", "Floppy", -1, Common::EN_ANY, Common::kPlatformDOS },
 	{ "f1b0e0d587b85052de5534a3847e68fe", "water", "HE 99", "Updated", -1, Common::EN_ANY, Common::kPlatformUnknown },
 	{ "f237bf8a5ef9af78b2a6a4f3901da341", "pajama", "", "Demo", 18354, Common::EN_ANY, Common::kPlatformUnknown },
 	{ "f27b1ba0eadaf2a6617b2b58192d1dbf", "samnmax", "Floppy", "Floppy", -1, Common::DE_DEU, Common::kPlatformDOS },
@@ -671,7 +680,7 @@ static const MD5Table md5table[] = {
 	{ "faa89ab5e67ba4eebb4399f584f7490c", "pajama3", "", "Mini Game", 13911, Common::FR_FRA, Common::kPlatformWindows },
 	{ "fb66aa42de21675116346213f176a366", "monkey", "VGA", "VGA", -1, Common::IT_ITA, Common::kPlatformAmiga },
 	{ "fbb697d89d2beca87360a145f467bdae", "PuttTime", "HE 90", "Demo", -1, Common::DE_DEU, Common::kPlatformUnknown },
-	{ "fbbbb38a81fc9d6a61d509278390a290", "farm", "", "", -1, Common::EN_ANY, Common::kPlatformMacintosh },
+	{ "fbbbb38a81fc9d6a61d509278390a290", "farm", "HE 73", "", -1, Common::EN_ANY, Common::kPlatformMacintosh },
 	{ "fbdd947d21e8f5bac6d6f7a316af1c5a", "spyfox", "", "Demo", 15693, Common::EN_ANY, Common::kPlatformUnknown },
 	{ "fc53ce0e5f6562b1c1e1b4b8203acafb", "samnmax", "Floppy", "Floppy", -1, Common::ES_ESP, Common::kPlatformDOS },
 	{ "fc6b6148e80d67939d9a18697c0f626a", "monkey", "EGA", "EGA", 8367, Common::DE_DEU, Common::kPlatformDOS },
diff --git a/engines/scumm/scumm.cpp b/engines/scumm/scumm.cpp
index 7d927b0cda..24d676a1ff 100644
--- a/engines/scumm/scumm.cpp
+++ b/engines/scumm/scumm.cpp
@@ -316,6 +316,7 @@ ScummEngine::ScummEngine(OSystem *syst, const DetectorResult &dr)
 	_NES_lastTalkingActor = 0;
 	_NES_talkColor = 0;
 	_keepText = false;
+	_msgCount = 0;
 	_costumeLoader = NULL;
 	_costumeRenderer = NULL;
 	_2byteFontPtr = 0;
@@ -1904,7 +1905,7 @@ void ScummEngine::setupMusic(int midi) {
 		// EGA/VGA. However, we support multi MIDI for that game and we cannot
 		// support this with the Player_AD code at the moment. The reason here
 		// is that multi MIDI is supported internally by our iMuse output.
-		_musicEngine = new Player_AD(this, _mixer);
+		_musicEngine = new Player_AD(this);
 	} else if (_game.version >= 3 && _game.heversion <= 62) {
 		MidiDriver *nativeMidiDriver = 0;
 		MidiDriver *adlibMidiDriver = 0;
@@ -2612,7 +2613,7 @@ bool ScummEngine::startManiac() {
 			if (path.hasPrefix(currentPath)) {
 				path.erase(0, currentPath.size() + 1);
 				if (path.equalsIgnoreCase("maniac")) {
-					maniacTarget = dom.getVal("gameid");
+					maniacTarget = iter->_key;
 					break;
 				}
 			}
diff --git a/engines/scumm/scumm.h b/engines/scumm/scumm.h
index 30b4d61880..6e0adc3ff3 100644
--- a/engines/scumm/scumm.h
+++ b/engines/scumm/scumm.h
@@ -1182,6 +1182,7 @@ protected:
 	byte _charsetBuffer[512];
 
 	bool _keepText;
+	byte _msgCount;
 
 	int _nextLeft, _nextTop;
 
diff --git a/engines/scumm/smush/smush_player.cpp b/engines/scumm/smush/smush_player.cpp
index 7617fc541f..05c7ff2d9a 100644
--- a/engines/scumm/smush/smush_player.cpp
+++ b/engines/scumm/smush/smush_player.cpp
@@ -115,6 +115,11 @@ public:
 				if (data_end[-2] == '\r' && data_end[-1] == '\n' && data_end[0] == '\r' && data_end[1] == '\n') {
 					break;
 				}
+				// In the Steam Mac version of The Dig, LF-LF is used
+				// instead of CR-LF
+				if (data_end[-2] == '\n' && data_end[-1] == '\n') {
+					break;
+				}
 				// In Russian Full Throttle strings are finished with
 				// just one pair of CR-LF
 				if (data_end[-2] == '\r' && data_end[-1] == '\n' && data_end[0] == '#') {
diff --git a/engines/scumm/string.cpp b/engines/scumm/string.cpp
index d60c4c6a50..3049fbcf62 100644
--- a/engines/scumm/string.cpp
+++ b/engines/scumm/string.cpp
@@ -283,6 +283,7 @@ bool ScummEngine::handleNextCharsetCode(Actor *a, int *code) {
 		switch (c) {
 		case 1:
 			c = 13; // new line
+			_msgCount = _screenWidth;
 			endLoop = true;
 			break;
 		case 2:
@@ -293,6 +294,7 @@ bool ScummEngine::handleNextCharsetCode(Actor *a, int *code) {
 		case 3:
 			_haveMsg = (_game.version >= 7) ? 1 : 0xFF;
 			_keepText = false;
+			_msgCount = 0;
 			endLoop = true;
 			break;
 		case 8:
@@ -573,6 +575,9 @@ void ScummEngine::CHARSET_1() {
 #endif
 				restoreCharsetBg();
 		}
+		_msgCount = 0;
+	} else if (_game.version <= 2) {
+		_talkDelay += _msgCount * _defaultTalkDelay;
 	}
 
 	if (_game.version > 3) {
@@ -600,6 +605,7 @@ void ScummEngine::CHARSET_1() {
 			// End of text reached, set _haveMsg accordingly
 			_haveMsg = (_game.version >= 7) ? 2 : 1;
 			_keepText = false;
+			_msgCount = 0;
 			break;
 		}
 
@@ -648,6 +654,7 @@ void ScummEngine::CHARSET_1() {
 			}
 			if (_game.version <= 3) {
 				_charset->printChar(c, false);
+				_msgCount += 1;
 			} else {
 				if (_game.features & GF_16BIT_COLOR) {
 					// HE games which use sprites for subtitles
diff --git a/engines/sherlock/animation.cpp b/engines/sherlock/animation.cpp
new file mode 100644
index 0000000000..681e71d0f6
--- /dev/null
+++ b/engines/sherlock/animation.cpp
@@ -0,0 +1,322 @@
+/* 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 "sherlock/animation.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "common/algorithm.h"
+
+namespace Sherlock {
+
+static const int NO_FRAMES = FRAMES_END;
+
+Animation::Animation(SherlockEngine *vm) : _vm(vm) {
+}
+
+bool Animation::play(const Common::String &filename, bool intro, int minDelay, int fade,
+		bool setPalette, int speed) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	Sound &sound = *_vm->_sound;
+	int soundNumber = 0;
+
+	// Check for any any sound frames for the given animation
+	const int *soundFrames = checkForSoundFrames(filename, intro);
+
+	// Add on the VDX extension
+	Common::String vdxName = filename + ".vdx";
+
+	// Load the animation
+	Common::SeekableReadStream *stream;
+	if (!_gfxLibraryFilename.empty())
+		stream = _vm->_res->load(vdxName, _gfxLibraryFilename);
+	else if (_vm->_useEpilogue2)
+		stream = _vm->_res->load(vdxName, "epilog2.lib");
+	else
+		stream = _vm->_res->load(vdxName, "epilogue.lib");
+
+	// Load initial image
+	Common::String vdaName = filename + ".vda";
+	ImageFile images(vdaName, true, true);
+
+	events.wait(minDelay);
+	if (fade != 0 && fade != 255)
+		screen.fadeToBlack();
+
+	if (setPalette) {
+		if (fade != 255)
+			screen.setPalette(images._palette);
+	}
+
+	int frameNumber = 0;
+	Common::Point pt;
+	bool skipped = false;
+	while (!_vm->shouldQuit()) {
+		// Get the next sprite to display
+		int imageFrame = stream->readSint16LE();
+
+		if (imageFrame == -2) {
+			// End of animation reached
+			break;
+		} else if (imageFrame != -1) {
+			// Read position from either animation stream or the sprite frame itself
+			if (imageFrame < 0) {
+				imageFrame += 32768;
+				pt.x = stream->readUint16LE();
+				pt.y = stream->readUint16LE();
+			} else {
+				pt = images[imageFrame]._offset;
+			}
+
+			// Draw the sprite. Note that we explicitly use the raw frame below, rather than the ImageFrame,
+			// since we don't want the offsets in the image file to be used, just the explicit position we specify
+			screen.transBlitFrom(images[imageFrame]._frame, pt);
+		} else {
+			// At this point, either the sprites for the frame has been complete, or there weren't any sprites
+			// at all to draw for the frame
+			if (fade == 255) {
+				// Gradual fade in
+				if (screen.equalizePalette(images._palette) == 0)
+					fade = 0;
+			}
+
+			// Check if we've reached a frame with sound
+			if (frameNumber++ == *soundFrames) {
+				++soundNumber;
+				++soundFrames;
+
+				Common::String sampleFilename;
+
+				if (!intro) {
+					// regular animation, append 1-digit number
+					sampleFilename = Common::String::format("%s%01d", filename.c_str(), soundNumber);
+				} else {
+					// intro animation, append 2-digit number
+					sampleFilename = Common::String::format("%s%02d", filename.c_str(), soundNumber);
+				}
+
+				if (sound._voices)
+					sound.playSound(sampleFilename, WAIT_RETURN_IMMEDIATELY, 100, _soundLibraryFilename.c_str());
+			}
+
+			events.wait(speed * 3);
+		}
+
+		if (events.kbHit()) {
+			Common::KeyState keyState = events.getKey();
+			if (keyState.keycode == Common::KEYCODE_ESCAPE ||
+				keyState.keycode == Common::KEYCODE_SPACE) {
+				skipped = true;
+				break;
+			}
+		} else if (events._pressed) {
+			skipped = true;
+			break;
+		}
+	}
+
+	events.clearEvents();
+	sound.stopSound();
+	delete stream;
+
+	return !skipped && !_vm->shouldQuit();
+}
+
+bool Animation::play3DO(const Common::String &filename, bool intro, int minDelay, bool fadeFromGrey,
+		int speed) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	Sound  &sound  = *_vm->_sound;
+	int soundNumber = 0;
+
+	bool   fadeActive = false;
+	uint16 fadeLimitColor      = 0;
+	uint16 fadeLimitColorRed   = 0;
+	uint16 fadeLimitColorGreen = 0;
+	uint16 fadeLimitColorBlue  = 0;
+
+	// Check for any any sound frames for the given animation
+	const int *soundFrames = checkForSoundFrames(filename, intro);
+
+	// Add the VDX extension
+	Common::String indexName = "prologue/" + filename + ".3dx";
+
+	// Load the animation
+	Common::File *indexStream = new Common::File();
+
+	if (!indexStream->open(indexName)) {
+		warning("unable to open %s\n", indexName.c_str());
+		return false;
+	}
+
+	// Load initial image
+	Common::String graphicsName = "prologue/" + filename + ".3da";
+	ImageFile3DO images(graphicsName, kImageFile3DOType_Animation);
+
+	events.wait(minDelay);
+
+	if (fadeFromGrey) {
+		fadeActive = true;
+		fadeLimitColor = 0xCE59; // RGB565: 25, 50, 25 -> "grey"
+	}
+
+	int frameNumber = 0;
+	Common::Point pt;
+	bool skipped = false;
+	while (!_vm->shouldQuit()) {
+		// Get the next sprite to display
+		int imageFrame = indexStream->readSint16BE();
+
+		if (imageFrame == -2) {
+			// End of animation reached
+			break;
+		} else if (imageFrame != -1) {
+			// Read position from either animation stream or the sprite frame itself
+			if (imageFrame < 0) {
+				imageFrame += 32768;
+				pt.x = indexStream->readUint16BE();
+				pt.y = indexStream->readUint16BE();
+			} else {
+				pt = images[imageFrame]._offset;
+			}
+
+			// Draw the sprite. Note that we explicitly use the raw frame below, rather than the ImageFrame,
+			// since we don't want the offsets in the image file to be used, just the explicit position we specify
+			screen._backBuffer1.transBlitFrom(images[imageFrame]._frame, pt);
+			if (!fadeActive)
+				screen.slamArea(pt.x, pt.y, images[imageFrame]._frame.w, images[imageFrame]._frame.h);
+		} else {
+			// At this point, either the sprites for the frame has been complete, or there weren't any sprites
+			// at all to draw for the frame
+
+			if (fadeActive) {
+				// process fading
+				static_cast<Scalpel::Scalpel3DOScreen *>(_vm->_screen)->blitFrom3DOcolorLimit(fadeLimitColor);
+
+				if (!fadeLimitColor) {
+					// we are at the end, so stop
+					fadeActive = false;
+				} else {
+					// decrease limit color
+					fadeLimitColorRed = fadeLimitColor & 0xF800;
+					fadeLimitColorGreen = fadeLimitColor & 0x07E0;
+					fadeLimitColorBlue = fadeLimitColor & 0x001F;
+					if (fadeLimitColorRed)
+						fadeLimitColor -= 0x0800;
+					if (fadeLimitColorGreen)
+						fadeLimitColor -= 0x0040; // -2 because we are using RGB565, sherlock uses RGB555
+					if (fadeLimitColorBlue)
+						fadeLimitColor -= 0x0001;
+				}
+			}
+
+			// Check if we've reached a frame with sound
+			if (frameNumber++ == *soundFrames) {
+				++soundNumber;
+				++soundFrames;
+
+				Common::String sampleFilename;
+
+				// append 1-digit number
+				sampleFilename = Common::String::format("prologue/sounds/%s%01d", filename.c_str(), soundNumber);
+
+				if (sound._voices)
+					sound.playSound(sampleFilename, WAIT_RETURN_IMMEDIATELY, 100); // no sound library
+			}
+			events.wait(speed * 3);
+		}
+
+		if (events.kbHit()) {
+			Common::KeyState keyState = events.getKey();
+			if (keyState.keycode == Common::KEYCODE_ESCAPE ||
+				keyState.keycode == Common::KEYCODE_SPACE) {
+				skipped = true;
+				break;
+			}
+		} else if (events._pressed) {
+			skipped = true;
+			break;
+		}
+	}
+
+	events.clearEvents();
+	sound.stopSound();
+	delete indexStream;
+
+	return !skipped && !_vm->shouldQuit();
+}
+
+void Animation::setPrologueNames(const char *const *names, int count) {
+	for (int idx = 0; idx < count; ++idx, ++names) {
+		_prologueNames.push_back(*names);
+	}
+}
+
+void Animation::setPrologueFrames(const int *frames, int count, int maxFrames) {
+	_prologueFrames.resize(count);
+
+	for (int idx = 0; idx < count; ++idx, frames += maxFrames) {
+		_prologueFrames[idx].resize(maxFrames);
+		Common::copy(frames, frames + maxFrames, &_prologueFrames[idx][0]);
+	}
+}
+
+void Animation::setTitleNames(const char *const *names, int count) {
+	for (int idx = 0; idx < count; ++idx, ++names) {
+		_titleNames.push_back(*names);
+	}
+}
+
+void Animation::setTitleFrames(const int *frames, int count, int maxFrames) {
+	_titleFrames.resize(count);
+
+	for (int idx = 0; idx < count; ++idx, frames += maxFrames) {
+		_titleFrames[idx].resize(maxFrames);
+		Common::copy(frames, frames + maxFrames, &_titleFrames[idx][0]);
+	}
+}
+
+const int *Animation::checkForSoundFrames(const Common::String &filename, bool intro) {
+	const int *frames = &NO_FRAMES;
+
+	if (!intro) {
+		// regular animation is playing
+		for (uint idx = 0; idx < _prologueNames.size(); ++idx) {
+			if (filename.equalsIgnoreCase(_prologueNames[idx])) {
+				frames = &_prologueFrames[idx][0];
+				break;
+			}
+		}
+	} else {
+		// intro-animation is playing
+		for (uint idx = 0; idx < _titleNames.size(); ++idx) {
+			if (filename.equalsIgnoreCase(_titleNames[idx])) {
+				frames = &_titleFrames[idx][0];
+				break;
+			}
+		}
+	}
+
+	return frames;
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/animation.h b/engines/sherlock/animation.h
new file mode 100644
index 0000000000..f3c95d4027
--- /dev/null
+++ b/engines/sherlock/animation.h
@@ -0,0 +1,86 @@
+/* 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 SHERLOCK_ANIMATION_H
+#define SHERLOCK_ANIMATION_H
+
+#include "common/scummsys.h"
+#include "common/str.h"
+#include "common/array.h"
+
+namespace Sherlock {
+
+#define FRAMES_END 32000
+
+class SherlockEngine;
+
+class Animation {
+private:
+	SherlockEngine *_vm;
+
+	Common::Array<const char *> _prologueNames;
+	Common::Array<Common::Array<int> > _prologueFrames;
+	Common::Array<const char *> _titleNames;
+	Common::Array<Common::Array<int> > _titleFrames;
+
+	/**
+	 * Checks for whether an animation is being played that has associated sound
+	 */
+	const int *checkForSoundFrames(const Common::String &filename, bool intro);
+public:
+	Common::String _soundLibraryFilename;
+	Common::String _gfxLibraryFilename;
+
+public:
+	Animation(SherlockEngine *vm);
+
+	/**
+	 * Load the prologue name array
+	 */
+	void setPrologueNames(const char *const *names, int count);
+	
+	/**
+	 * Load the prologue frame array
+	 */
+	void setPrologueFrames(const int *frames, int count, int maxFrames);
+
+	/**
+	 * Load the title name array
+	 */
+	void setTitleNames(const char *const *names, int count);
+	
+	/**
+	 * Load the title frame array
+	 */
+	void setTitleFrames(const int *frames, int count, int maxFrames);
+
+	/**
+	 * Play a full-screen animation
+	 */
+	bool play(const Common::String &filename, bool intro, int minDelay, int fade, bool setPalette, int speed);
+
+	bool play3DO(const Common::String &filename, bool intro, int minDelay, bool fadeFromGrey, int speed);
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/configure.engine b/engines/sherlock/configure.engine
new file mode 100644
index 0000000000..a56129a8f0
--- /dev/null
+++ b/engines/sherlock/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 sherlock "The Lost Files of Sherlock Holmes" no
diff --git a/engines/sherlock/debugger.cpp b/engines/sherlock/debugger.cpp
new file mode 100644
index 0000000000..39f8da3806
--- /dev/null
+++ b/engines/sherlock/debugger.cpp
@@ -0,0 +1,166 @@
+/* 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 "sherlock/debugger.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/music.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/scalpel/scalpel_debugger.h"
+#include "sherlock/tattoo/tattoo_debugger.h"
+#include "audio/mixer.h"
+#include "audio/decoders/aiff.h"
+#include "audio/decoders/wave.h"
+#include "common/str-array.h"
+
+namespace Sherlock {
+
+Debugger *Debugger::init(SherlockEngine *vm) {
+	if (vm->getGameID() == GType_RoseTattoo)
+		return new Tattoo::TattooDebugger(vm);
+	else
+		return new Scalpel::ScalpelDebugger(vm);
+}
+
+Debugger::Debugger(SherlockEngine *vm) : GUI::Debugger(), _vm(vm) {
+	_showAllLocations = LOC_DISABLED;
+
+	registerCmd("continue",	     WRAP_METHOD(Debugger, cmdExit));
+	registerCmd("scene",         WRAP_METHOD(Debugger, cmdScene));
+	registerCmd("song",          WRAP_METHOD(Debugger, cmdSong));
+	registerCmd("songs",         WRAP_METHOD(Debugger, cmdListSongs));
+	registerCmd("listfiles",     WRAP_METHOD(Debugger, cmdListFiles));
+	registerCmd("dumpfile",      WRAP_METHOD(Debugger, cmdDumpFile));
+	registerCmd("locations",     WRAP_METHOD(Debugger, cmdLocations));
+}
+
+void Debugger::postEnter() {
+	if (!_3doPlayMovieFile.empty()) {
+		static_cast<Scalpel::ScalpelEngine *>(_vm)->play3doMovie(_3doPlayMovieFile, Common::Point(0, 0));
+
+		_3doPlayMovieFile.clear();
+	}
+
+	_vm->pauseEngine(false);
+}
+
+int Debugger::strToInt(const char *s) {
+	if (!*s)
+		// No string at all
+		return 0;
+	else if (toupper(s[strlen(s) - 1]) != 'H')
+		// Standard decimal string
+		return atoi(s);
+
+	// Hexadecimal string
+	uint tmp = 0;
+	int read = sscanf(s, "%xh", &tmp);
+	if (read < 1)
+		error("strToInt failed on string \"%s\"", s);
+	return (int)tmp;
+}
+
+bool Debugger::cmdScene(int argc, const char **argv) {
+	if (argc != 2) {
+		debugPrintf("Format: scene <room>\n");
+		return true;
+	} else {
+		_vm->_scene->_goToScene = strToInt(argv[1]);
+		return false;
+	}
+}
+
+bool Debugger::cmdSong(int argc, const char **argv) {
+	if (argc != 2) {
+		debugPrintf("Format: song <name>\n");
+		return true;
+	}
+
+	Common::StringArray songs;
+	_vm->_music->getSongNames(songs);
+
+	for (uint i = 0; i < songs.size(); i++) {
+		if (songs[i].equalsIgnoreCase(argv[1])) {
+			_vm->_music->loadSong(songs[i]);
+			return false;
+		}
+	}
+
+	debugPrintf("Invalid song. Use the 'songs' command to see which ones are available.\n");
+	return true;
+}
+
+bool Debugger::cmdListSongs(int argc, const char **argv) {
+	Common::StringArray songs;
+	_vm->_music->getSongNames(songs);
+	debugPrintColumns(songs);
+	return true;
+}
+
+bool Debugger::cmdListFiles(int argc, const char **argv) {
+	if (argc != 2) {
+		debugPrintf("Format: listfiles <resource file>\n");
+		return true;
+	}
+	Common::StringArray files;
+	_vm->_res->getResourceNames(Common::String(argv[1]), files);
+	debugPrintColumns(files);
+	return true;
+}
+
+bool Debugger::cmdDumpFile(int argc, const char **argv) {
+	if (argc != 2) {
+		debugPrintf("Format: dumpfile <resource name>\n");
+		return true;
+	}
+
+	Common::SeekableReadStream *s = _vm->_res->load(argv[1]);
+	if (!s) {
+		debugPrintf("Invalid resource.\n");
+		return true;
+	}
+
+	byte *buffer = new byte[s->size()];
+	s->read(buffer, s->size());
+
+	Common::DumpFile dumpFile;
+	dumpFile.open(argv[1]);
+
+	dumpFile.write(buffer, s->size());
+	dumpFile.flush();
+	dumpFile.close();
+
+	delete[] buffer;
+
+	debugPrintf("Resource %s has been dumped to disk.\n", argv[1]);
+
+	return true;
+}
+
+bool Debugger::cmdLocations(int argc, const char **argv) {
+	_showAllLocations = LOC_REFRESH;
+
+	debugPrintf("Now showing all map locations\n");
+	return false;
+}
+
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/debugger.h b/engines/sherlock/debugger.h
new file mode 100644
index 0000000000..bcc4448c32
--- /dev/null
+++ b/engines/sherlock/debugger.h
@@ -0,0 +1,86 @@
+/* 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 SHERLOCK_DEBUGGER_H
+#define SHERLOCK_DEBUGGER_H
+
+#include "common/scummsys.h"
+#include "gui/debugger.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+enum AllLocations { LOC_REFRESH = -1, LOC_DISABLED = 0, LOC_ALL = 1 };
+
+class Debugger : public GUI::Debugger {
+private:
+	/**
+	 * Converts a decimal or hexadecimal string into a number
+	 */
+	int strToInt(const char *s);
+
+	/**
+	 * Switch to another scene
+	 */
+	bool cmdScene(int argc, const char **argv);
+
+	/**
+	 * Plays a song
+	 */
+	bool cmdSong(int argc, const char **argv);
+
+	/**
+	 * Lists all available songs
+	 */
+	bool cmdListSongs(int argc, const char **argv);
+
+	/**
+	 * Lists all files in a library (use at your own risk)
+	 */
+	bool cmdListFiles(int argc, const char **argv);
+
+	/**
+	 * Dumps a file to disk
+	 */
+	bool cmdDumpFile(int argc, const char **argv);
+
+	/**
+	 * Show all locations on the map
+	 */
+	bool cmdLocations(int argc, const char **argv);
+protected:
+	SherlockEngine *_vm;
+	Common::String _3doPlayMovieFile;
+public:
+	AllLocations _showAllLocations;
+public:
+	Debugger(SherlockEngine *vm);
+	virtual ~Debugger() {}
+	static Debugger *init(SherlockEngine *vm);
+
+	void postEnter();
+};
+
+} // End of namespace Sherlock
+
+#endif	/* SHERLOCK_DEBUGGER_H */
diff --git a/engines/sherlock/decompress.cpp b/engines/sherlock/decompress.cpp
new file mode 100644
index 0000000000..8e02da3212
--- /dev/null
+++ b/engines/sherlock/decompress.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 "sherlock/decompress.h"
+
+namespace Sherlock {
+
+/**
+ * Decompresses an LZW compressed resource. If no outSize is specified, it will
+ * decompress the entire resource. If, however, an explicit size is specified,
+ * then it means we're already within a resource, and only want to decompress
+ * part of it.
+ */
+Common::SeekableReadStream *decompressLZ(Common::SeekableReadStream &source, int32 outSize) {
+	if (outSize == -1) {
+		source.seek(5);
+		outSize = source.readSint32LE();
+	}
+
+	byte lzWindow[4096];
+	uint16 lzWindowPos;
+	uint16 cmd;
+
+	byte *outBuffer = new byte[outSize];
+	byte *outBufferEnd = outBuffer + outSize;
+	Common::MemoryReadStream *outS = new Common::MemoryReadStream(outBuffer, outSize, DisposeAfterUse::YES);
+
+	memset(lzWindow, 0xFF, 0xFEE);
+	lzWindowPos = 0xFEE;
+	cmd = 0;
+
+	do {
+		cmd >>= 1;
+		if (!(cmd & 0x100))
+			cmd = source.readByte() | 0xFF00;
+
+		if (cmd & 1) {
+			byte literal = source.readByte();
+			*outBuffer++ = literal;
+			lzWindow[lzWindowPos] = literal;
+			lzWindowPos = (lzWindowPos + 1) & 0x0FFF;
+		} else {
+			int copyPos, copyLen;
+			copyPos = source.readByte();
+			copyLen = source.readByte();
+			copyPos = copyPos | ((copyLen & 0xF0) << 4);
+			copyLen = (copyLen & 0x0F) + 3;
+			while (copyLen--) {
+				byte literal = lzWindow[copyPos];
+				copyPos = (copyPos + 1) & 0x0FFF;
+				*outBuffer++ = literal;
+				lzWindow[lzWindowPos] = literal;
+				lzWindowPos = (lzWindowPos + 1) & 0x0FFF;
+			}
+		}
+	} while (outBuffer < outBufferEnd);
+
+	return outS;
+}
+
+
+/**
+ * Decompresses a Rose Tattoo resource
+ *
+Common::SeekableReadStream *decompress32(Common::SeekableReadStream &source, int32 outSize) {
+	if (outSize == -1) {
+		outSize = source.readSint32LE();
+	}
+
+	byte lzWindow[8192];
+	byte *outBuffer = new byte[outSize];
+	byte *outBufferEnd = outBuffer + outSize;
+	Common::MemoryReadStream *outS = new Common::MemoryReadStream(outBuffer, outSize, DisposeAfterUse::YES);
+
+	memset(lzWindow, 0xFF, 8192);
+	int lzWindowPos = 0xFEE;
+	int cmd = 0;
+
+	do {
+		cmd >>= 1;
+		if (!(cmd & 0x100))
+			cmd = source.readByte() | 0xFF00;
+
+		if (cmd & 1) {
+			byte literal = source.readByte();
+			*outBuffer++ = literal;
+			lzWindow[lzWindowPos] = literal;
+			lzWindowPos = (lzWindowPos + 1) & 0x0FFF;
+		} else {
+			int copyPos, copyLen;
+			copyPos = source.readByte();
+			copyLen = source.readByte();
+			copyPos = copyPos | ((copyLen & 0xF0) << 4);
+			copyLen = (copyLen & 0x0F) + 3;
+			while (copyLen--) {
+				byte literal = lzWindow[copyPos];
+				copyPos = (copyPos + 1) & 0x0FFF;
+				*outBuffer++ = literal;
+				lzWindow[lzWindowPos] = literal;
+				lzWindowPos = (lzWindowPos + 1) & 0x0FFF;
+			}
+		}
+	} while (outBuffer < outBufferEnd);
+
+	return outS;
+}
+*/
+
+} // namespace Sherlock
diff --git a/engines/sherlock/detection.cpp b/engines/sherlock/detection.cpp
new file mode 100644
index 0000000000..5a94b3485f
--- /dev/null
+++ b/engines/sherlock/detection.cpp
@@ -0,0 +1,256 @@
+/* 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 "sherlock/sherlock.h"
+#include "sherlock/saveload.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "common/system.h"
+#include "common/translation.h"
+#include "engines/advancedDetector.h"
+
+namespace Sherlock {
+
+struct SherlockGameDescription {
+	ADGameDescription desc;
+
+	GameType gameID;
+};
+
+GameType SherlockEngine::getGameID() const {
+	return _gameDescription->gameID;
+}
+
+Common::Platform SherlockEngine::getPlatform() const {
+	return _gameDescription->desc.platform;
+}
+
+Common::Language SherlockEngine::getLanguage() const {
+	return _gameDescription->desc.language;
+}
+
+} // End of namespace Sherlock
+
+static const PlainGameDescriptor sherlockGames[] = {
+	{ "scalpel", "The Case of the Serrated Scalpel" },
+	{ "rosetattoo", "The Case of the Rose Tattoo" },
+	{0, 0}
+};
+
+
+#define GAMEOPTION_ORIGINAL_SAVES	GUIO_GAMEOPTIONS1
+#define GAMEOPTION_FADE_STYLE		GUIO_GAMEOPTIONS2
+#define GAMEOPTION_HELP_STYLE		GUIO_GAMEOPTIONS3
+#define GAMEOPTION_PORTRAITS_ON		GUIO_GAMEOPTIONS4
+#define GAMEOPTION_WINDOW_STYLE		GUIO_GAMEOPTIONS5
+#define GAMEOPTION_TRANSPARENT_WINDOWS		GUIO_GAMEOPTIONS6
+
+static const ADExtraGuiOptionsMap optionsList[] = {
+	{
+		GAMEOPTION_ORIGINAL_SAVES,
+		{
+			_s("Use original savegame dialog"),
+			_s("Files button in-game shows original savegame dialog rather than the ScummVM menu"),
+			"originalsaveload",
+			false
+		}
+	},
+
+	{
+		GAMEOPTION_FADE_STYLE,
+		{
+			_s("Pixellated scene transitions"),
+			_s("When changing scenes, a randomized pixel transition is done"),
+			"fade_style",
+			true
+		}
+	},
+
+	{
+		GAMEOPTION_HELP_STYLE,
+		{
+			_s("Don't show hotspots when moving mouse"),
+			_s("Only show hotspot names after you actually click on a hotspot or action button"),
+			"help_style",
+			false
+		}
+	},
+
+	{
+		GAMEOPTION_PORTRAITS_ON,
+		{
+			_s("Show character portraits"),
+			_s("Show portraits for the characters when conversing"),
+			"portraits_on",
+			true
+		}
+	},
+
+	{
+		GAMEOPTION_WINDOW_STYLE,
+		{
+			_s("Slide dialogs into view"),
+			_s("Slide UI dialogs into view, rather than simply showing them immediately"),
+			"window_style",
+			true
+		}
+	},
+
+	{
+		GAMEOPTION_TRANSPARENT_WINDOWS,
+		{
+			_s("Transparent windows"),
+			_s("Show windows with a partially transparent background"),
+			"transparent_windows",
+			true
+		}
+	},
+
+	AD_EXTRA_GUI_OPTIONS_TERMINATOR
+};
+
+
+#include "sherlock/detection_tables.h"
+
+class SherlockMetaEngine : public AdvancedMetaEngine {
+public:
+	SherlockMetaEngine() : AdvancedMetaEngine(Sherlock::gameDescriptions, sizeof(Sherlock::SherlockGameDescription),
+		sherlockGames, optionsList) {}
+
+	virtual const char *getName() const {
+		return "Sherlock Engine";
+	}
+
+	virtual const char *getOriginalCopyright() const {
+		return "Sherlock Engine (C) 1992-1996 Mythos Software, 1992-1996 (C) Electronic Arts";
+	}
+
+	/**
+	 * Creates an instance of the game engine
+	 */
+	virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const;
+
+	/**
+	 * Returns a list of features the game's MetaEngine support
+	 */
+	virtual bool hasFeature(MetaEngineFeature f) const;
+
+	/**
+	 * Return a list of savegames
+	 */
+	virtual SaveStateList listSaves(const char *target) const;
+
+	/**
+	 * Returns the maximum number of allowed save slots
+	 */
+	virtual int getMaximumSaveSlot() const;
+
+	/**
+	 * Deletes a savegame in the specified slot
+	 */
+	virtual void removeSaveState(const char *target, int slot) const;
+
+	/**
+	 * Given a specified savegame slot, returns extended information for the save
+	 */
+	SaveStateDescriptor querySaveMetaInfos(const char *target, int slot) const;
+};
+
+bool SherlockMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const {
+	const Sherlock::SherlockGameDescription *gd = (const Sherlock::SherlockGameDescription *)desc;
+	if (gd) {
+		switch (gd->gameID) {
+		case Sherlock::GType_SerratedScalpel:
+			*engine = new Sherlock::Scalpel::ScalpelEngine(syst, gd);
+			break;
+		case Sherlock::GType_RoseTattoo:
+			*engine = new Sherlock::Tattoo::TattooEngine(syst, gd);
+			break;
+		default:
+			error("Unknown game");
+			break;
+		}
+	}
+	return gd != 0;
+}
+
+bool SherlockMetaEngine::hasFeature(MetaEngineFeature f) const {
+	return
+		(f == kSupportsListSaves) ||
+		(f == kSupportsLoadingDuringStartup) ||
+		(f == kSupportsDeleteSave) ||
+		(f == kSavesSupportMetaInfo) ||
+		(f == kSavesSupportThumbnail);
+}
+
+bool Sherlock::SherlockEngine::hasFeature(EngineFeature f) const {
+	return
+		(f == kSupportsRTL) ||
+		(f == kSupportsLoadingDuringRuntime) ||
+		(f == kSupportsSavingDuringRuntime);
+}
+
+bool Sherlock::SherlockEngine::isDemo() const {
+	return _gameDescription->desc.flags & ADGF_DEMO;
+}
+
+SaveStateList SherlockMetaEngine::listSaves(const char *target) const {
+	return Sherlock::SaveManager::getSavegameList(target);
+}
+
+int SherlockMetaEngine::getMaximumSaveSlot() const {
+	return MAX_SAVEGAME_SLOTS;
+}
+
+void SherlockMetaEngine::removeSaveState(const char *target, int slot) const {
+	Common::String filename = Sherlock::SaveManager(nullptr, target).generateSaveName(slot);
+	g_system->getSavefileManager()->removeSavefile(filename);
+}
+
+SaveStateDescriptor SherlockMetaEngine::querySaveMetaInfos(const char *target, int slot) const {
+	Common::String filename = Sherlock::SaveManager(nullptr, target).generateSaveName(slot);
+	Common::InSaveFile *f = g_system->getSavefileManager()->openForLoading(filename);
+
+	if (f) {
+		Sherlock::SherlockSavegameHeader header;
+		Sherlock::SaveManager::readSavegameHeader(f, header);
+		delete f;
+
+		// Create the return descriptor
+		SaveStateDescriptor desc(slot, header._saveName);
+		desc.setThumbnail(header._thumbnail);
+		desc.setSaveDate(header._year, header._month, header._day);
+		desc.setSaveTime(header._hour, header._minute);
+		desc.setPlayTime(header._totalFrames * GAME_FRAME_TIME);
+
+		return desc;
+	}
+
+	return SaveStateDescriptor();
+}
+
+
+#if PLUGIN_ENABLED_DYNAMIC(SHERLOCK)
+	REGISTER_PLUGIN_DYNAMIC(SHERLOCK, PLUGIN_TYPE_ENGINE, SherlockMetaEngine);
+#else
+	REGISTER_PLUGIN_STATIC(SHERLOCK, PLUGIN_TYPE_ENGINE, SherlockMetaEngine);
+#endif
diff --git a/engines/sherlock/detection_tables.h b/engines/sherlock/detection_tables.h
new file mode 100644
index 0000000000..6567369528
--- /dev/null
+++ b/engines/sherlock/detection_tables.h
@@ -0,0 +1,221 @@
+/* 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.
+ *
+ */
+
+namespace Sherlock {
+
+static const SherlockGameDescription gameDescriptions[] = {
+	{
+		// Case of the Serrated Scalpel - English 3.5" Floppy
+		// The HitSquad CD version has the same MD5
+		{
+			"scalpel",
+			0,
+			AD_ENTRY1s("talk.lib", "ad0c4d6865edf15da4e9204c08815875", 238928),
+			Common::EN_ANY,
+			Common::kPlatformDOS,
+			ADGF_TESTING,
+			GUIO6(GUIO_NOSPEECH, GAMEOPTION_ORIGINAL_SAVES, GAMEOPTION_FADE_STYLE, GAMEOPTION_HELP_STYLE,
+				GAMEOPTION_PORTRAITS_ON, GAMEOPTION_WINDOW_STYLE)
+		},
+		GType_SerratedScalpel,
+	},
+
+	{
+		// Case of the Serrated Scalpel - German CD (from multilingual CD)
+		// Provided by m_kiewitz
+		{
+			"scalpel",
+			0, {
+				{"talk.lib", 0, "40a5f9f37c0e0d2ad48d8f44d8e393c9", 284278},
+				{"music.lib", 0, "68ae2f7684ecf903bd60a00bb6bae195", 366465},
+				AD_LISTEND},
+			Common::DE_DEU,
+			Common::kPlatformDOS,
+			ADGF_TESTING,
+			GUIO6(GUIO_NOSPEECH, GAMEOPTION_ORIGINAL_SAVES, GAMEOPTION_FADE_STYLE, GAMEOPTION_HELP_STYLE,
+				GAMEOPTION_PORTRAITS_ON, GAMEOPTION_WINDOW_STYLE)
+		},
+		GType_SerratedScalpel,
+	},
+
+	{
+		// Case of the Serrated Scalpel - German
+		// Provided by mgerhardy
+		{
+			"scalpel",
+			0, {
+				{"talk.lib", 0, "44652e54172e13b1b075b1ef7d89de24", 284043},
+				{"music.lib", 0, "68ae2f7684ecf903bd60a00bb6bae195", 366465},
+				AD_LISTEND},
+			Common::DE_DEU,
+			Common::kPlatformDOS,
+			ADGF_TESTING,
+			GUIO6(GUIO_NOSPEECH, GAMEOPTION_ORIGINAL_SAVES, GAMEOPTION_FADE_STYLE, GAMEOPTION_HELP_STYLE,
+				GAMEOPTION_PORTRAITS_ON, GAMEOPTION_WINDOW_STYLE)
+		},
+		GType_SerratedScalpel,
+	},
+
+	{
+		// Case of the Serrated Scalpel - German
+		// Provided by max565
+		{
+			"scalpel",
+			0, {
+				{"talk.lib", 0, "3d813fd8505b391a1f8b3a16b1aa7f2e", 284195},
+				{"music.lib", 0, "68ae2f7684ecf903bd60a00bb6bae195", 366465},
+				AD_LISTEND },
+				Common::DE_DEU,
+				Common::kPlatformDOS,
+				ADGF_TESTING,
+				GUIO6(GUIO_NOSPEECH, GAMEOPTION_ORIGINAL_SAVES, GAMEOPTION_FADE_STYLE, GAMEOPTION_HELP_STYLE,
+				GAMEOPTION_PORTRAITS_ON, GAMEOPTION_WINDOW_STYLE)
+		},
+		GType_SerratedScalpel,
+	},
+
+	{
+		// Case of the Serrated Scalpel - Spanish CD (from multilingual CD)
+		// Provided by m_kiewitz
+		{
+			"scalpel",
+			0, {
+				{"talk.lib", 0, "27697804b637a7f3b77234bf16f15dce", 171419},
+				{"music.lib", 0, "68ae2f7684ecf903bd60a00bb6bae195", 366465},
+				AD_LISTEND},
+			Common::ES_ESP,
+			Common::kPlatformDOS,
+			ADGF_TESTING,
+			GUIO6(GUIO_NOSPEECH, GAMEOPTION_ORIGINAL_SAVES, GAMEOPTION_FADE_STYLE, GAMEOPTION_HELP_STYLE,
+				GAMEOPTION_PORTRAITS_ON, GAMEOPTION_WINDOW_STYLE)
+		},
+		GType_SerratedScalpel,
+	},
+
+	{
+		// Case of the Serrated Scalpel - English 3DO
+		{
+			"scalpel",
+			0,
+			AD_ENTRY1s("talk.lib", "20f74a29f2db6475e85b029ac9fc03bc", 240610),
+			Common::EN_ANY,
+			Common::kPlatform3DO,
+			ADGF_UNSTABLE,
+			GUIO4(GAMEOPTION_FADE_STYLE, GAMEOPTION_HELP_STYLE,GAMEOPTION_PORTRAITS_ON, GAMEOPTION_WINDOW_STYLE)
+		},
+		GType_SerratedScalpel,
+	},
+
+	{
+		// Case of the Serrated Scalpel - Interactive English Demo
+		// Provided by Strangerke
+		{
+			"scalpel",
+			"Interactive Demo",
+			AD_ENTRY1s("talk.lib", "dbdc8a20c96900aa7e4d02f3fe8a274c", 121102),
+			Common::EN_ANY,
+			Common::kPlatformDOS,
+			ADGF_TESTING | ADGF_DEMO,
+			GUIO1(GUIO_NOSPEECH)
+		},
+		GType_SerratedScalpel,
+	},
+
+	{
+		// Case of the Serrated Scalpel - Non-Interactive English Demo
+		// Provided by Strangerke
+		{
+			"scalpel",
+			"Non Interactive Demo",
+			AD_ENTRY1s("music.lib", "ec19a09b7fef6fd90b1ab812ce6e9739", 38563),
+			Common::EN_ANY,
+			Common::kPlatformDOS,
+			ADGF_TESTING | ADGF_DEMO,
+			GUIO1(GUIO_NOSPEECH)
+		},
+		GType_SerratedScalpel,
+	},
+
+	{
+		// Case of the Rose Tattoo - French CD
+		// Provided by Strangerke
+		{
+			"rosetattoo",
+			"CD",
+			AD_ENTRY1s("talk.lib", "22e8e6406dd2fbbb238c9898928df42e", 770756),
+			Common::FR_FRA,
+			Common::kPlatformDOS,
+			ADGF_TESTING,
+			GUIO3(GAMEOPTION_ORIGINAL_SAVES, GAMEOPTION_HELP_STYLE, GAMEOPTION_TRANSPARENT_WINDOWS)
+		},
+		GType_RoseTattoo
+	},
+
+	{
+		// Case of the Rose Tattoo - English CD
+		// Provided by dreammaster
+		{
+			"rosetattoo",
+			"CD",
+			AD_ENTRY1s("talk.lib", "9639a756b0993ebd71cb5f4d8b78b2dc", 765134),
+			Common::EN_ANY,
+			Common::kPlatformDOS,
+			ADGF_TESTING,
+			GUIO3(GAMEOPTION_ORIGINAL_SAVES, GAMEOPTION_HELP_STYLE, GAMEOPTION_TRANSPARENT_WINDOWS)
+		},
+		GType_RoseTattoo,
+	},
+
+	{
+		// Case of the Rose Tattoo - German CD
+		// Provided by m_kiewitz
+		{
+			"rosetattoo",
+			"CD",
+			AD_ENTRY1s("talk.lib", "5027aa72f0d263ed3b1c764a6c397911", 873864),
+  			Common::DE_DEU,
+			Common::kPlatformDOS,
+			ADGF_TESTING,
+			GUIO3(GAMEOPTION_ORIGINAL_SAVES, GAMEOPTION_HELP_STYLE, GAMEOPTION_TRANSPARENT_WINDOWS)
+		},
+		GType_RoseTattoo,
+	},
+
+	{
+		// Case of the Rose Tattoo - Spanish CD
+		// Provided by dianiu
+		{
+			"rosetattoo",
+			"CD",
+			AD_ENTRY1s("talk.lib", "4f3ccf50e1012445624569cd605d7449", 783713),
+			Common::ES_ESP,
+			Common::kPlatformDOS,
+			ADGF_TESTING,
+			GUIO3(GAMEOPTION_ORIGINAL_SAVES, GAMEOPTION_HELP_STYLE, GAMEOPTION_TRANSPARENT_WINDOWS)
+		},
+		GType_RoseTattoo,
+	},
+
+	{ AD_TABLE_END_MARKER, (GameType)0 }
+};
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/events.cpp b/engines/sherlock/events.cpp
new file mode 100644
index 0000000000..4b0b7dfb3f
--- /dev/null
+++ b/engines/sherlock/events.cpp
@@ -0,0 +1,411 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/events.h"
+#include "common/system.h"
+#include "engines/util.h"
+#include "graphics/cursorman.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/events.h"
+#include "sherlock/surface.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+enum ButtonFlag { LEFT_BUTTON = 1, RIGHT_BUTTON = 2 };
+
+Events::Events(SherlockEngine *vm): _vm(vm) {
+	_cursorImages = nullptr;
+	_cursorId = INVALID_CURSOR;
+	_frameCounter = 1;
+	_priorFrameTime = 0;
+	_mouseButtons = 0;
+	_pressed = _released = false;
+	_rightPressed = _rightReleased = false;
+	_oldButtons = _oldRightButton = false;
+	_firstPress = false;
+	_waitCounter = 0;
+	_frameRate = GAME_FRAME_RATE;
+
+	if (_vm->_interactiveFl)
+		loadCursors("rmouse.vgs");
+}
+
+Events::~Events() {
+	delete _cursorImages;
+}
+
+void Events::loadCursors(const Common::String &filename) {
+	hideCursor();
+	delete _cursorImages;
+
+	if (!IS_3DO) {
+		// PC
+		_cursorImages = new ImageFile(filename);
+	} else {
+		// 3DO
+		_cursorImages = new ImageFile3DO(filename, kImageFile3DOType_RoomFormat);
+	}
+	_cursorId = INVALID_CURSOR;
+}
+
+void Events::setCursor(CursorId cursorId) {
+	if (cursorId == _cursorId || _waitCounter > 0)
+		return;
+
+	int hotspotX, hotspotY;
+
+	if (cursorId == MAGNIFY) {
+		hotspotX = 8;
+		hotspotY = 8;
+	} else {
+		hotspotX = 0;
+		hotspotY = 0;
+	}
+
+	// Set the cursor data
+	Graphics::Surface &s = (*_cursorImages)[cursorId]._frame;
+
+	setCursor(s, hotspotX, hotspotY);
+
+	_cursorId = cursorId;
+}
+
+void Events::setCursor(const Graphics::Surface &src, int hotspotX, int hotspotY) {
+	_cursorId = INVALID_CURSOR;
+	_hotspotPos = Common::Point(hotspotX, hotspotY);
+	
+	if (!IS_3DO) {
+		// PC 8-bit palettized
+		CursorMan.replaceCursor(src.getPixels(), src.w, src.h, hotspotX, hotspotY, 0xff);
+	} else if (!_vm->_isScreenDoubled) {
+		CursorMan.replaceCursor(src.getPixels(), src.w, src.h, hotspotX, hotspotY, 0x0000, false, &src.format);
+	} else {
+		Graphics::Surface tempSurface;
+		tempSurface.create(2 * src.w, 2 * src.h, src.format);
+
+		for (int y = 0; y < src.h; y++) {
+			const uint16 *srcP = (const uint16 *)src.getBasePtr(0, y);
+			uint16 *destP = (uint16 *)tempSurface.getBasePtr(0, 2 * y);
+			for (int x = 0; x < src.w; ++x, ++srcP, destP += 2) {
+				*destP = *srcP;
+				*(destP + 1) = *srcP;
+				*(destP + 2 * src.w) = *srcP;
+				*(destP + 2 * src.w + 1) = *srcP;
+			}
+		}
+
+		// 3DO RGB565
+		CursorMan.replaceCursor(tempSurface.getPixels(), tempSurface.w, tempSurface.h, 2 * hotspotX, 2 * hotspotY, 0x0000, false, &src.format);
+
+		tempSurface.free();
+	}
+	showCursor();
+}
+
+void Events::setCursor(CursorId cursorId, const Common::Point &cursorPos, const Graphics::Surface &surface) {
+	_cursorId = cursorId;
+
+	// Get the standard cursor frame
+	Graphics::Surface &cursorImg = (*_cursorImages)[cursorId]._frame;
+
+	// If the X pos for the cursor image is -100, this is a special value to indicate
+	// the cursor should be horizontally centered
+	Common::Point cursorPt = cursorPos;
+	if (cursorPos.x == -100)
+		cursorPt.x = (surface.w - cursorImg.w) / 2;
+
+	// Figure total bounds needed for cursor image and passed image
+	Common::Rect bounds(surface.w, surface.h);
+	bounds.extend(Common::Rect(cursorPt.x, cursorPt.y, cursorPt.x + cursorImg.w, cursorPt.y + cursorImg.h));
+	Common::Rect r = bounds;
+	r.moveTo(0, 0);
+
+	// Form a single surface containing both frames
+	Surface s(r.width(), r.height());
+	s.fill(TRANSPARENCY);
+
+	// Draw the passed image
+	Common::Point drawPos;
+	if (cursorPt.x < 0)
+		drawPos.x = -cursorPt.x;
+	if (cursorPt.y < 0)
+		drawPos.y = -cursorPt.y;
+	s.blitFrom(surface, Common::Point(drawPos.x, drawPos.y));
+
+	// Draw the cursor image
+	drawPos = Common::Point(MAX(cursorPt.x, (int16)0), MAX(cursorPt.y, (int16)0));
+	s.transBlitFrom(cursorImg, Common::Point(drawPos.x, drawPos.y));
+
+	// Set up hotspot position for cursor, adjusting for cursor image's position within the surface
+	Common::Point hotspot;
+	if (cursorId == MAGNIFY)
+		hotspot = Common::Point(8, 8);
+	hotspot += drawPos;
+	// Set the cursor
+	setCursor(s.getRawSurface(), hotspot.x, hotspot.y);
+}
+
+void Events::animateCursorIfNeeded() {
+	if (_cursorId >= WAIT && _cursorId < (WAIT + 3)) {
+		CursorId newId = (_cursorId == WAIT + 2) ? WAIT : (CursorId)((int)_cursorId + 1);
+		setCursor(newId);
+	}
+}
+
+void Events::showCursor() {
+	if (IS_SERRATED_SCALPEL || !static_cast<Tattoo::TattooEngine *>(_vm)->_runningProlog)
+		CursorMan.showMouse(true);
+}
+
+void Events::hideCursor() {
+	CursorMan.showMouse(false);
+}
+
+CursorId Events::getCursor() const {
+	return _cursorId;
+}
+
+bool Events::isCursorVisible() const {
+	return CursorMan.isVisible();
+}
+
+void Events::pollEvents() {
+	checkForNextFrameCounter();
+
+	Common::Event event;
+	while (g_system->getEventManager()->pollEvent(event)) {
+		_mousePos = event.mouse;
+		if (_vm->_isScreenDoubled)
+			_mousePos = Common::Point(_mousePos.x / 2, _mousePos.y / 2);
+
+		// Handle events
+		switch (event.type) {
+		case Common::EVENT_QUIT:
+		case Common::EVENT_RTL:
+			return;
+
+		case Common::EVENT_KEYDOWN:
+			// Check for debugger
+			if (event.kbd.keycode == Common::KEYCODE_d && (event.kbd.flags & Common::KBD_CTRL)) {
+				// Attach to the debugger
+				_vm->_debugger->attach();
+				_vm->_debugger->onFrame();
+			} else {
+				_pendingKeys.push(event.kbd);
+			}
+			return;
+		case Common::EVENT_KEYUP:
+			return;
+		case Common::EVENT_LBUTTONDOWN:
+			_mouseButtons |= LEFT_BUTTON;
+			return;
+		case Common::EVENT_RBUTTONDOWN:
+			_mouseButtons |= RIGHT_BUTTON;
+			return;
+		case Common::EVENT_LBUTTONUP:
+			_mouseButtons &= ~LEFT_BUTTON;
+			return;
+		case Common::EVENT_RBUTTONUP:
+			_mouseButtons &= ~RIGHT_BUTTON;
+			return;
+		default:
+ 			break;
+		}
+	}
+}
+
+void Events::pollEventsAndWait() {
+	pollEvents();
+	g_system->delayMillis(10);
+}
+
+void Events::warpMouse(const Common::Point &pt) {
+	Common::Point pos = pt;
+	if (_vm->_isScreenDoubled)
+		pos = Common::Point(pt.x / 2, pt.y);
+
+	_mousePos = pos - _vm->_screen->_currentScroll;
+	g_system->warpMouse(_mousePos.x, _mousePos.y);
+}
+
+void Events::warpMouse() {
+	Screen &screen = *_vm->_screen;
+	warpMouse(Common::Point(screen._currentScroll.x + SHERLOCK_SCREEN_WIDTH / 2,
+		screen._currentScroll.y + SHERLOCK_SCREEN_HEIGHT / 2));
+}
+
+Common::Point Events::mousePos() const {
+	return _vm->_screen->_currentScroll + _mousePos;
+}
+
+void Events::setFrameRate(int newRate) {
+	_frameRate = newRate;
+}
+
+void Events::toggleSpeed() {
+	_frameRate = (_frameRate == GAME_FRAME_RATE) ? GAME_FRAME_RATE * 2 : GAME_FRAME_RATE;
+}
+
+bool Events::checkForNextFrameCounter() {
+	// Check for next game frame
+	uint32 milli = g_system->getMillis();
+	if ((milli - _priorFrameTime) >= (1000 / _frameRate)) {
+		++_frameCounter;
+		_priorFrameTime = milli;
+
+		// Give time to the debugger
+		_vm->_debugger->onFrame();
+
+		// Display the frame
+		_vm->_screen->update();
+
+		return true;
+	}
+
+	return false;
+}
+
+Common::KeyState Events::getKey() {
+	Common::KeyState keyState = _pendingKeys.pop();
+
+	switch (keyState.keycode) {
+	case Common::KEYCODE_KP1:
+		keyState.keycode = Common::KEYCODE_END;
+		break;
+	case Common::KEYCODE_KP2:
+		keyState.keycode = Common::KEYCODE_DOWN;
+		break;
+	case Common::KEYCODE_KP3:
+		keyState.keycode = Common::KEYCODE_PAGEDOWN;
+		break;
+	case Common::KEYCODE_KP4:
+		keyState.keycode = Common::KEYCODE_LEFT;
+		break;
+	case Common::KEYCODE_KP6:
+		keyState.keycode = Common::KEYCODE_RIGHT;
+		break;
+	case Common::KEYCODE_KP7:
+		keyState.keycode = Common::KEYCODE_HOME;
+		break;
+	case Common::KEYCODE_KP8:
+		keyState.keycode = Common::KEYCODE_UP;
+		break;
+	case Common::KEYCODE_KP9:
+		keyState.keycode = Common::KEYCODE_PAGEUP;
+		break;
+	case Common::KEYCODE_KP_ENTER:
+		keyState.keycode = Common::KEYCODE_RETURN;
+		break;
+	default:
+		break;
+	}
+
+	return keyState;
+}
+
+void Events::clearEvents() {
+	_pendingKeys.clear();
+	_mouseButtons = 0;
+	_pressed = _released = false;
+	_rightPressed = _rightReleased = false;
+	_oldButtons = _oldRightButton = false;
+	_firstPress = false;
+}
+
+void Events::clearKeyboard() {
+	_pendingKeys.clear();
+}
+
+void Events::wait(int numFrames) {
+	uint32 totalMilli = numFrames * 1000 / _frameRate;
+	delay(totalMilli);
+}
+
+bool Events::delay(uint32 time, bool interruptable) {
+	// Different handling for really short versus extended times
+	if (time < 10) {
+		// For really short periods, simply delay by the desired amount
+		pollEvents();
+		g_system->delayMillis(time);
+		bool result = !(interruptable && (kbHit() || _pressed || _vm->shouldQuit()));
+
+		if (interruptable)
+			clearEvents();
+		return result;
+	} else {
+		// For long periods go into a loop where we delay by 10ms at a time and then
+		// check for events. This ensures for longer delays that responsiveness is
+		// maintained
+		uint32 delayEnd = g_system->getMillis() + time;
+
+		while (!_vm->shouldQuit() && g_system->getMillis() < delayEnd) {
+			pollEventsAndWait();
+
+			if (interruptable && (kbHit() || _mouseButtons)) {
+				clearEvents();
+				return false;
+			}
+		}
+
+		return !_vm->shouldQuit();
+	}
+}
+
+void Events::setButtonState() {
+	_firstPress = ((_mouseButtons & 1) && !_pressed) || ((_mouseButtons & 2) && !_rightPressed);
+
+	_released = _rightReleased = false;
+	if (_mouseButtons & LEFT_BUTTON)
+		_pressed = _oldButtons = true;
+
+	if ((_mouseButtons & LEFT_BUTTON) == 0 && _oldButtons) {
+		_pressed = _oldButtons = false;
+		_released = true;
+	}
+
+	if (_mouseButtons & RIGHT_BUTTON)
+		_rightPressed = _oldRightButton = true;
+
+	if ((_mouseButtons & RIGHT_BUTTON) == 0 && _oldRightButton) {
+		_rightPressed = _oldRightButton = false;
+		_rightReleased = true;
+	}
+}
+
+bool Events::checkInput() {
+	setButtonState();
+	return kbHit() || _pressed || _released || _rightPressed || _rightReleased;
+}
+
+void Events::incWaitCounter() {
+	setCursor(WAIT);
+	++_waitCounter;		
+}
+
+void Events::decWaitCounter() {
+	assert(_waitCounter > 0);
+	--_waitCounter;
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/events.h b/engines/sherlock/events.h
new file mode 100644
index 0000000000..711804dfdf
--- /dev/null
+++ b/engines/sherlock/events.h
@@ -0,0 +1,217 @@
+/* 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 SHERLOCK_EVENTS_H
+#define SHERLOCK_EVENTS_H
+
+#include "common/scummsys.h"
+#include "common/events.h"
+#include "common/stack.h"
+#include "sherlock/image_file.h"
+
+namespace Sherlock {
+
+#define GAME_FRAME_RATE 30
+#define GAME_FRAME_TIME (1000 / GAME_FRAME_RATE)
+
+enum CursorId { ARROW = 0, MAGNIFY = 1, WAIT = 2, EXIT_ZONES_START = 5, INVALID_CURSOR = -1 };
+
+class SherlockEngine;
+
+class Events {
+private:
+	SherlockEngine *_vm;
+	uint32 _frameCounter;
+	uint32 _priorFrameTime;
+	ImageFile *_cursorImages;
+	int _mouseButtons;
+	Common::Point _mousePos;
+	int _waitCounter;
+	uint _frameRate;
+
+	/**
+	 * Check whether it's time to display the next screen frame
+	 */
+	bool checkForNextFrameCounter();
+public:
+	CursorId _cursorId;
+	bool _pressed;
+	bool _released;
+	bool _rightPressed;
+	bool _rightReleased;
+	bool _oldButtons;
+	bool _oldRightButton;
+	bool _firstPress;
+	Common::Stack<Common::KeyState> _pendingKeys;
+	Common::Point _hotspotPos;
+public:
+	Events(SherlockEngine *vm);
+	~Events();
+
+	/**
+	 * Load a set of cursors from the specified file
+	 */
+	void loadCursors(const Common::String &filename);
+
+	/**
+	 * Set the cursor to show
+	 */
+	void setCursor(CursorId cursorId);
+
+	/**
+	 * Set the cursor to show from a passed frame
+	 */
+	void setCursor(const Graphics::Surface &src, int hotspotX = 0, int hotspotY = 0);
+
+	/**
+	 * Set both a standard cursor as well as an inventory item above it
+	 */
+	void setCursor(CursorId cursorId, const Common::Point &cursorPos, const Graphics::Surface &surface);
+
+	/**
+	 * Animates the mouse cursor if the Wait cursor is showing
+	 */
+	void animateCursorIfNeeded();
+
+	/**
+	 * Show the mouse cursor
+	 */
+	void showCursor();
+
+	/**
+	 * Hide the mouse cursor
+	 */
+	void hideCursor();
+
+	/**
+	 * Returns the cursor
+	 */
+	CursorId getCursor() const;
+
+	/**
+	 * Returns true if the mouse cursor is visible
+	 */
+	bool isCursorVisible() const;
+
+	/**
+	 * Check for any pending events
+	 */
+	void pollEvents();
+
+	/**
+	 * Poll for events and introduce a small delay, to allow the system to
+	 * yield to other running programs
+	 */
+	void pollEventsAndWait();
+
+	/**
+	 * Move the mouse cursor
+	 */
+	void warpMouse(const Common::Point &pt);
+
+	/**
+	* Move the mouse cursor to the center of the screen
+	*/
+	void warpMouse();
+
+	/**
+	 * Get the current mouse position
+	 */
+	Common::Point screenMousePos() const { return _mousePos; }
+
+	/**
+	 * Get the current mouse position within the scene, adjusted by the scroll position
+	 */
+	Common::Point mousePos() const;
+
+	/**
+	 * Override the default frame rate
+	 */
+	void setFrameRate(int newRate);
+
+	/**
+	 * Toggle between standard game speed and an "extra fast" mode
+	 */
+	void toggleSpeed();
+
+	/**
+	 * Return the current game frame number
+	 */
+	uint32 getFrameCounter() const { return _frameCounter; }
+
+	/**
+	 * Returns true if there's a pending keyboard key
+	 */
+	bool kbHit() const { return !_pendingKeys.empty(); }
+
+	/**
+	 * Get a pending keypress
+	 */
+	Common::KeyState getKey();
+
+	/**
+	 * Clear any current keypress or mouse click
+	 */
+	void clearEvents();
+
+	/**
+	 * Clear any pending keyboard inputs
+	 */
+	void clearKeyboard();
+
+	/**
+	 * Delay for a given number of game frames, where each frame is 1/60th of a second
+	 */
+	void wait(int numFrames);
+
+	/**
+	 * Does a delay of the specified number of milliseconds
+	 */
+	bool delay(uint32 time, bool interruptable = false);
+
+	/**
+	 * Sets the pressed and released button flags on the raw button state previously set in pollEvents calls.
+	 * @remarks		The events manager has separate variables for the raw immediate and old button state
+	 *		versus the current buttons states for the frame. This method is expected to be called only once
+	 *		per game frame
+	 */
+	void setButtonState();
+
+	/**
+	 * Checks to see to see if a key or a mouse button is pressed.
+	 */
+	bool checkInput();
+
+	/**
+	 * Increment the wait counter
+	 */
+	void incWaitCounter();
+
+	/**
+	 * Decrement the wait counter
+	 */
+	void decWaitCounter();
+};
+
+} // End of namespace Sherlock
+
+#endif /* SHERLOCK_EVENTS_H */
diff --git a/engines/sherlock/fixed_text.cpp b/engines/sherlock/fixed_text.cpp
new file mode 100644
index 0000000000..cbee944120
--- /dev/null
+++ b/engines/sherlock/fixed_text.cpp
@@ -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.
+ *
+ */
+
+#include "sherlock/sherlock.h"
+#include "sherlock/fixed_text.h"
+#include "sherlock/scalpel/scalpel_fixed_text.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+
+namespace Sherlock {
+
+FixedText *FixedText::init(SherlockEngine *vm) {
+	if (vm->getGameID() == GType_SerratedScalpel)
+		return new Scalpel::ScalpelFixedText(vm);
+	else
+		return new Tattoo::TattooFixedText(vm);
+}
+
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/fixed_text.h b/engines/sherlock/fixed_text.h
new file mode 100644
index 0000000000..40444f4052
--- /dev/null
+++ b/engines/sherlock/fixed_text.h
@@ -0,0 +1,66 @@
+/* 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 SHERLOCK_FIXED_TEXT_H
+#define SHERLOCK_FIXED_TEXT_H
+
+#include "common/scummsys.h"
+#include "common/language.h"
+
+namespace Sherlock {
+
+#define FIXED(MSG) _vm->_fixedText->getText(kFixedText_##MSG)
+
+enum FixedTextActionId {
+	kFixedTextAction_Invalid = -1,
+	kFixedTextAction_Open = 0,
+	kFixedTextAction_Close,
+	kFixedTextAction_Move,
+	kFixedTextAction_Pick,
+	kFixedTextAction_Use
+};
+
+class SherlockEngine;
+
+class FixedText {
+protected:
+	SherlockEngine *_vm;
+
+	FixedText(SherlockEngine *vm) : _vm(vm) {}
+public:
+	static FixedText *init(SherlockEngine *vm);
+	virtual ~FixedText() {}
+
+	/**
+	 * Gets text
+	 */
+	virtual const char *getText(int fixedTextId) = 0;
+
+	/**
+	 * Get action message
+	 */
+	virtual const Common::String getActionMessage(FixedTextActionId actionId, int messageIndex) = 0;
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/fonts.cpp b/engines/sherlock/fonts.cpp
new file mode 100644
index 0000000000..4d0991a47c
--- /dev/null
+++ b/engines/sherlock/fonts.cpp
@@ -0,0 +1,269 @@
+/* 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/platform.h"
+#include "sherlock/fonts.h"
+#include "sherlock/image_file.h"
+#include "sherlock/surface.h"
+#include "sherlock/sherlock.h"
+
+namespace Sherlock {
+
+SherlockEngine *Fonts::_vm;
+ImageFile *Fonts::_font;
+int Fonts::_fontNumber;
+int Fonts::_fontHeight;
+int Fonts::_widestChar;
+uint16 Fonts::_charCount;
+byte Fonts::_yOffsets[255];
+
+void Fonts::setVm(SherlockEngine *vm) {
+	_vm = vm;
+	_font = nullptr;
+	_charCount = 0;
+}
+
+void Fonts::free() {
+	delete _font;
+}
+
+void Fonts::setFont(int fontNum) {
+	_fontNumber = fontNum;
+
+	// Discard previous font
+	delete _font;
+
+	Common::String fontFilename;
+
+	if (_vm->getPlatform() != Common::kPlatform3DO) {
+		// PC
+		// use FONT[number].VGS, which is a regular sherlock graphic file
+		fontFilename = Common::String::format("FONT%d.VGS", fontNum + 1);
+
+		// load font data
+		_font = new ImageFile(fontFilename);
+
+		if (IS_SERRATED_SCALPEL) {
+			if (_vm->getLanguage() == Common::ES_ESP) {
+				if (_fontNumber == 1) {
+					// Create a new character - inverted exclamation mark (0x88)
+					// Seems this wasn't included originally, but some text has it
+					// This was obviously not done in the original game interpreter
+					ImageFrame &frameExclamationMark = (*_font)[0]; // get actual exclamation mark
+					ImageFrame frameRevExclamationMark;
+
+					frameRevExclamationMark._width = frameExclamationMark._width;
+					frameRevExclamationMark._height = frameExclamationMark._height;
+					frameRevExclamationMark._paletteBase = frameExclamationMark._paletteBase;
+					frameRevExclamationMark._rleEncoded = frameExclamationMark._rleEncoded;
+					frameRevExclamationMark._size = frameExclamationMark._size;
+					frameRevExclamationMark._frame.create(frameExclamationMark._width, frameExclamationMark._height, Graphics::PixelFormat::createFormatCLUT8());
+
+					byte *frameExclMarkPixels = (byte *)frameExclamationMark._frame.getPixels();
+					byte *frameRevExclMarkPixels = (byte *)frameRevExclamationMark._frame.getPixels();
+
+					uint16 revExclMarkY = frameExclamationMark._height - 1;
+					frameRevExclMarkPixels += frameExclamationMark._width * (frameExclamationMark._height - 1);
+					for (uint16 exclMarkY = 0; exclMarkY < frameExclamationMark._height; exclMarkY++) {
+						memcpy(frameRevExclMarkPixels, frameExclMarkPixels, frameExclamationMark._width);
+						revExclMarkY--;
+						frameRevExclMarkPixels -= frameExclamationMark._width;
+						frameExclMarkPixels += frameExclamationMark._width;
+					}
+
+					frameRevExclamationMark._offset.x = frameExclamationMark._offset.x;
+					frameRevExclamationMark._offset.y = frameExclamationMark._offset.y + 1;
+
+					_font->push_back(frameRevExclamationMark);
+				}
+			}
+		}
+
+	} else {
+		// 3DO
+		switch (fontNum) {
+		case 0:
+		case 1:
+			fontFilename = "helvetica14.font";
+			break;
+		case 2:
+			fontFilename = "darts.font";
+			break;
+		default:
+			error("setFont(): unsupported 3DO font number");
+		}
+
+		// load font data
+		_font = new ImageFile3DO(fontFilename, kImageFile3DOType_Font);
+	}
+
+	_charCount = _font->size();
+
+	// Iterate through the frames to find the widest and tallest font characters
+	_fontHeight = _widestChar = 0;
+	for (uint idx = 0; idx < _charCount; ++idx) {
+		_fontHeight = MAX((uint16)_fontHeight, (*_font)[idx]._frame.h);
+		_widestChar = MAX((uint16)_widestChar, (*_font)[idx]._frame.w);
+	}
+
+	// Initialize the Y offset table for the extended character set
+	for (int idx = 0; idx < 255; ++idx) {
+		_yOffsets[idx] = 0;
+
+		if (IS_ROSE_TATTOO) {
+			if ((idx >= 129 && idx < 135) || (idx >= 136 && idx < 143) || (idx >= 147 && idx < 155) || 
+					(idx >= 156 && idx < 165))
+				_yOffsets[idx] = 1;
+			else if ((idx >= 143 && idx < 146) || idx == 165)
+				_yOffsets[idx] = 2;
+		}
+	}
+}
+
+inline byte Fonts::translateChar(byte c) {
+	switch (c) {
+	case ' ':
+		return 0; // translate to first actual character
+	case 225:
+		// This was done in the German interpreter
+		// SH1: happens, when talking to the kid in the 2nd room
+		// SH2: happens, when looking at the newspaper right at the start in the backalley
+		// Special handling for 0xE1 (German Sharp-S character)
+		if (IS_ROSE_TATTOO) {
+			return 136; // it got translated to this for SH2
+		}
+		return 135; // and this for SH1
+	default:
+		if (IS_SERRATED_SCALPEL) {
+			if (_vm->getLanguage() == Common::ES_ESP) {
+				if (_fontNumber == 1) {
+					// Special workarounds for translated game text, which was skipped because of effectively a bug
+					// This was not done in the original interpreter
+					// It seems at least the inverted exclamation mark was skipped by the original interpreter /
+					// wasn't shown at all.
+					// This character is used for example in the alley room, when talking with the inspector after
+					// searching the corpse. "[0xAD]Claro! Mi experiencia profesional revela que esta mujer fue asesinada..."
+					// The same text gets put inside Watson's journal as well and should be on page 10 right after
+					// talking with the inspector. For further study see bug #6931
+					// Inverted question mark was also skipped, but at least that character is inside the font already.
+					if (c == 0xAD) {
+						// inverted exclamation mark
+						return 0x88; // our own font character, created during setFont()
+					}
+					// Inverted question mask is 0x86 (mapped from 0x88)
+				}
+			}
+			if (c >= 0x80) { // German SH1 version did this, but not German SH2
+				c--;
+			}
+			// Spanish SH1 did this (reverse engineered code)
+			//if ((c >= 0xA0) && (c <= 0xAD) || (c == 0x82)) {
+			//	c--;
+			//}
+		}
+		assert(c > 32); // anything above space is allowed
+		return c - 33;
+	}
+}
+
+void Fonts::writeString(Surface *surface, const Common::String &str,
+		const Common::Point &pt, int overrideColor) {
+	Common::Point charPos = pt;
+
+	if (!_font)
+		return;
+
+	for (const char *curCharPtr = str.c_str(); *curCharPtr; ++curCharPtr) {
+		byte curChar = *curCharPtr;
+
+		if (curChar == ' ') {
+			charPos.x += 5; // hardcoded space
+			continue;
+		}
+		curChar = translateChar(curChar);
+
+		if (curChar < _charCount) {
+			ImageFrame &frame = (*_font)[curChar];
+			surface->transBlitFrom(frame, Common::Point(charPos.x, charPos.y + _yOffsets[curChar]), false, overrideColor);
+			charPos.x += frame._frame.w + 1;
+		} else {
+			warning("Invalid character encountered - %d", (int)curChar);
+		}
+	}
+}
+
+int Fonts::stringWidth(const Common::String &str) {
+	int width = 0;
+
+	if (!_font)
+		return 0;
+
+	for (const char *c = str.c_str(); *c; ++c)
+		width += charWidth(*c);
+
+	return width;
+}
+
+int Fonts::stringHeight(const Common::String &str) {
+	int height = 0;
+
+	if (!_font)
+		return 0;
+
+	for (const char *c = str.c_str(); *c; ++c)
+		height = MAX(height, charHeight(*c));
+
+	return height;
+}
+
+int Fonts::charWidth(unsigned char c) {
+	byte curChar;
+
+	if (!_font)
+		return 0;
+
+	if (c == ' ') {
+		return 5; // hardcoded space
+	}
+	curChar = translateChar(c);
+
+	if (curChar < _charCount)
+		return (*_font)[curChar]._frame.w + 1;
+	return 0;
+}
+
+int Fonts::charHeight(unsigned char c) {
+	byte curChar;
+
+	if (!_font)
+		return 0;
+
+	// Space is supposed to be handled like the first actual character (which is decimal 33)
+	curChar = translateChar(c);
+
+	assert(curChar < _charCount);
+	const ImageFrame &img = (*_font)[curChar];
+	return img._height + img._offset.y + 1;
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/fonts.h b/engines/sherlock/fonts.h
new file mode 100644
index 0000000000..a527cc73c0
--- /dev/null
+++ b/engines/sherlock/fonts.h
@@ -0,0 +1,105 @@
+/* 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 SHERLOCK_FONTS_H
+#define SHERLOCK_FONTS_H
+
+#include "common/rect.h"
+#include "common/platform.h"
+#include "graphics/surface.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+class ImageFile;
+class Surface;
+
+class Fonts {
+private:
+	static ImageFile *_font;
+	static byte _yOffsets[255];
+protected:
+	static SherlockEngine *_vm;
+	static int _fontNumber;
+	static int _fontHeight;
+	static int _widestChar;
+	static uint16 _charCount;
+
+	static void writeString(Surface *surface, const Common::String &str, 
+		const Common::Point &pt, int overrideColor = 0);
+
+	static inline byte translateChar(byte c);
+public:
+	/**
+	 * Initialise the font manager
+	 */
+	static void setVm(SherlockEngine *vm);
+
+	/**
+	 * Frees the font manager
+	 */
+	static void free();
+
+	/**
+	 * Set the font to use for writing text on the screen
+	 */
+	void setFont(int fontNum);
+
+	/**
+	 * Returns the width of a string in pixels
+	 */
+	int stringWidth(const Common::String &str);
+
+	/**
+	 * Returns the height of a string in pixels (i.e. the tallest displayed character)
+	 */
+	int stringHeight(const Common::String &str);
+
+	/**
+	 * Returns the width of a character in pixels
+	 */
+	int charWidth(unsigned char c);
+
+	/**
+	 * Returns the width of a character in pixels
+	 */
+	int charHeight(unsigned char c);
+
+	/**
+	 * Return the font height
+	 */
+	int fontHeight() const { return _fontHeight; }
+
+	/**
+	 * Return the width of the widest character in the font
+	 */
+	int widestChar() const { return _widestChar; }
+
+	/**
+	 * Return the currently active font number
+	 */
+	int fontNumber() const { return _fontNumber; }
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/image_file.cpp b/engines/sherlock/image_file.cpp
new file mode 100644
index 0000000000..971980a2ac
--- /dev/null
+++ b/engines/sherlock/image_file.cpp
@@ -0,0 +1,1101 @@
+/* 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 "sherlock/image_file.h"
+#include "sherlock/screen.h"
+#include "sherlock/sherlock.h"
+#include "common/debug.h"
+#include "common/memstream.h"
+
+namespace Sherlock {
+
+SherlockEngine *ImageFile::_vm;
+
+void ImageFile::setVm(SherlockEngine *vm) {
+	_vm = vm;
+}
+
+ImageFile::ImageFile() {
+}
+
+ImageFile::ImageFile(const Common::String &name, bool skipPal, bool animImages) {
+	Common::SeekableReadStream *stream = _vm->_res->load(name);
+
+	Common::fill(&_palette[0], &_palette[PALETTE_SIZE], 0);
+	load(*stream, skipPal, animImages);
+
+	delete stream;
+}
+
+ImageFile::ImageFile(Common::SeekableReadStream &stream, bool skipPal) {
+	Common::fill(&_palette[0], &_palette[PALETTE_SIZE], 0);
+	load(stream, skipPal, false);
+}
+
+ImageFile::~ImageFile() {
+	for (uint idx = 0; idx < size(); ++idx)
+		(*this)[idx]._frame.free();
+}
+
+void ImageFile::load(Common::SeekableReadStream &stream, bool skipPalette, bool animImages) {
+	loadPalette(stream);
+
+	int streamSize = stream.size();
+	while (stream.pos() < streamSize) {
+		ImageFrame frame;
+		frame._width = stream.readUint16LE() + 1;
+		frame._height = stream.readUint16LE() + 1;
+		frame._paletteBase = stream.readByte();
+
+		if (animImages) {
+			// Animation cutscene image files use a 16-bit x offset
+			frame._offset.x = stream.readUint16LE();
+			frame._rleEncoded = (frame._offset.x & 0xff) == 1;
+			frame._offset.y = stream.readByte();
+		} else {
+			// Standard image files have a separate byte for the RLE flag, and an 8-bit X offset
+			frame._rleEncoded = stream.readByte() == 1;
+			frame._offset.x = stream.readByte();
+			frame._offset.y = stream.readByte();
+		}
+
+		frame._rleEncoded = !skipPalette && frame._rleEncoded;
+
+		if (frame._paletteBase) {
+			// Nibble packed frame data
+			frame._size = (frame._width * frame._height) / 2;
+		} else if (frame._rleEncoded) {
+			// This size includes the header size, which we subtract
+			frame._size = stream.readUint16LE() - 11;
+			frame._rleMarker = stream.readByte();
+		} else {
+			// Uncompressed data
+			frame._size = frame._width * frame._height;
+		}
+
+		// Load data for frame and decompress it
+		byte *data = new byte[frame._size + 4];
+		stream.read(data, frame._size);
+		Common::fill(data + frame._size, data + frame._size + 4, 0);
+		frame.decompressFrame(data, IS_ROSE_TATTOO);
+		delete[] data;
+
+		push_back(frame);
+	}
+}
+
+void ImageFile::loadPalette(Common::SeekableReadStream &stream) {
+	// Check for palette
+	uint16 width        = stream.readUint16LE() + 1;
+	uint16 height       = stream.readUint16LE() + 1;
+	byte   paletteBase  = stream.readByte();
+	byte   rleEncoded   = stream.readByte();
+	byte   offsetX      = stream.readByte();
+	byte   offsetY      = stream.readByte();
+	uint32 palSignature = 0;
+
+	if ((width == 390) && (height == 2) && (!paletteBase) && (!rleEncoded) && (!offsetX) && (!offsetY)) {
+		// We check for these specific values
+		// We can't do "width * height", because at least the first German+Spanish menu bar is 60 x 13
+		// which is 780, which is the size of the palette. We obviously don't want to detect it as palette.
+
+		// As another security measure, we also check for the signature text
+		palSignature = stream.readUint32BE();
+		if (palSignature != MKTAG('V', 'G', 'A', ' ')) {
+			// signature mismatch, rewind
+			stream.seek(-12, SEEK_CUR);
+			return;
+		}
+		// Found palette, so read it in
+		stream.seek(8, SEEK_CUR); // Skip over the rest of the signature text "VGA palette"
+		for (int idx = 0; idx < PALETTE_SIZE; ++idx)
+			_palette[idx] = VGA_COLOR_TRANS(stream.readByte());
+	} else {
+		// Not a palette, so rewind to start of frame data for normal frame processing
+		stream.seek(-8, SEEK_CUR);
+	}
+}
+
+void ImageFrame::decompressFrame(const byte *src, bool isRoseTattoo) {
+	_frame.create(_width, _height, Graphics::PixelFormat::createFormatCLUT8());
+	byte *dest = (byte *)_frame.getPixels();
+	Common::fill(dest, dest + _width * _height, 0xff);
+
+	if (_paletteBase) {
+		// Nibble-packed
+		for (uint idx = 0; idx < _size; ++idx, ++src) {
+			*dest++ = *src & 0xF;
+			*dest++ = (*src >> 4);
+		}
+	} else if (_rleEncoded && isRoseTattoo) {
+		// Rose Tattoo run length encoding doesn't use the RLE marker byte
+		for (int yp = 0; yp < _height; ++yp) {
+			int xSize = _width;
+			while (xSize > 0) {
+				// Skip a given number of pixels
+				byte skip = *src++;
+				dest += skip;
+				xSize -= skip;
+				if (!xSize)
+					break;
+
+				// Get a run length, and copy the following number of pixels
+				int rleCount = *src++;
+				xSize -= rleCount;
+				while (rleCount-- > 0)
+					*dest++ = *src++;
+			}
+			assert(xSize == 0);
+		}
+	} else if (_rleEncoded) {
+		// RLE encoded
+		int frameSize = _width * _height;
+		while (frameSize > 0) {
+			if (*src == _rleMarker) {
+				byte rleColor = src[1];
+				byte rleCount = src[2];
+				src += 3;
+				frameSize -= rleCount;
+				while (rleCount--)
+					*dest++ = rleColor;
+			} else {
+				*dest++ = *src++;
+				--frameSize;
+			}
+		}
+		assert(frameSize == 0);
+	} else {
+		// Uncompressed frame
+		Common::copy(src, src + _width * _height, dest);
+	}
+}
+
+/*----------------------------------------------------------------*/
+
+int ImageFrame::sDrawXSize(int scaleVal) const {
+	int width = _width;
+	int scale = scaleVal == 0 ? 1 : scaleVal;
+
+	if (scaleVal >= SCALE_THRESHOLD)
+		--width;
+
+	int result = width * SCALE_THRESHOLD / scale;
+	if (scaleVal >= SCALE_THRESHOLD)
+		++result;
+
+	return result;
+}
+
+int ImageFrame::sDrawYSize(int scaleVal) const {
+	int height = _height;
+	int scale = scaleVal == 0 ? 1 : scaleVal;
+
+	if (scaleVal >= SCALE_THRESHOLD)
+		--height;
+
+	int result = height * SCALE_THRESHOLD / scale;
+	if (scaleVal >= SCALE_THRESHOLD)
+		++result;
+
+	return result;
+}
+
+int ImageFrame::sDrawXOffset(int scaleVal) const {
+	if (scaleVal == SCALE_THRESHOLD)
+		return _offset.x;
+
+	int width = _offset.x;
+	int scale = scaleVal == 0 ? 1 : scaleVal;
+
+	if (scaleVal >= SCALE_THRESHOLD)
+		--width;
+
+	int result = width * SCALE_THRESHOLD / scale;
+	if (scaleVal > SCALE_THRESHOLD)
+		++result;
+
+	return result;
+}
+
+int ImageFrame::sDrawYOffset(int scaleVal) const {
+	if (scaleVal == SCALE_THRESHOLD)
+		return _offset.y;
+
+	int height = _offset.y;
+	int scale = scaleVal == 0 ? 1 : scaleVal;
+
+	if (scaleVal >= SCALE_THRESHOLD)
+		--height;
+
+	int result = height * SCALE_THRESHOLD / scale;
+	if (scaleVal > SCALE_THRESHOLD)
+		++result;
+
+	return result;
+}
+
+// *******************************************************
+
+/*----------------------------------------------------------------*/
+
+SherlockEngine *ImageFile3DO::_vm;
+
+void ImageFile3DO::setVm(SherlockEngine *vm) {
+	_vm = vm;
+}
+
+ImageFile3DO::ImageFile3DO(const Common::String &name, ImageFile3DOType imageFile3DOType) {
+#if 0
+	Common::File *dataStream = new Common::File();
+
+	if (!dataStream->open(name)) {
+		error("unable to open %s\n", name.c_str());
+	}
+#endif
+	Common::SeekableReadStream *dataStream = _vm->_res->load(name);
+
+	switch(imageFile3DOType) {
+	case kImageFile3DOType_Animation:
+		loadAnimationFile(*dataStream);
+		break;
+	case kImageFile3DOType_Cel:
+	case kImageFile3DOType_CelAnimation:
+		load3DOCelFile(*dataStream);
+		break;
+	case kImageFile3DOType_RoomFormat:
+		load3DOCelRoomData(*dataStream);
+		break;
+	case kImageFile3DOType_Font:
+		loadFont(*dataStream);
+		break;
+	default:
+		error("unknown Imagefile-3DO-Type");
+		break;
+	}
+
+	delete dataStream;
+}
+
+ImageFile3DO::ImageFile3DO(Common::SeekableReadStream &stream, bool isRoomData) {
+	if (!isRoomData) {
+		load(stream, isRoomData);
+	} else {
+		load3DOCelRoomData(stream);
+	}
+}
+
+ImageFile3DO::~ImageFile3DO() {
+	// already done in ImageFile destructor
+	//for (uint idx = 0; idx < size(); ++idx)
+	//	(*this)[idx]._frame.free();
+}
+
+void ImageFile3DO::load(Common::SeekableReadStream &stream, bool isRoomData) {
+	uint32 headerId = 0;
+
+	if (isRoomData) {
+		load3DOCelRoomData(stream);
+		return;
+	}
+
+	headerId = stream.readUint32BE();
+	assert(!stream.eos());
+
+	// Seek back to the start
+	stream.seek(-4, SEEK_CUR);
+
+	// Identify type of file
+	switch (headerId) {
+	case MKTAG('C', 'C', 'B', ' '):
+	case MKTAG('A', 'N', 'I', 'M'):
+	case MKTAG('O', 'F', 'S', 'T'): // 3DOSplash.cel
+		// 3DO .cel (title1a.cel, etc.) or animation file (walk.anim)
+		load3DOCelFile(stream);
+		break;
+
+	default:
+		// Sherlock animation file (.3da files)
+		loadAnimationFile(stream);
+		break;
+	}
+}
+
+// 3DO uses RGB555, we use RGB565 internally so that more platforms are able to run us
+inline uint16 ImageFile3DO::convertPixel(uint16 pixel3DO) {
+	byte red   = (pixel3DO >> 10) & 0x1F;
+	byte green = (pixel3DO >> 5) & 0x1F;
+	byte blue  = pixel3DO & 0x1F;
+
+	return ((red << 11) | (green << 6) | (blue));
+}
+
+void ImageFile3DO::loadAnimationFile(Common::SeekableReadStream &stream) {
+	uint32 streamLeft = stream.size() - stream.pos();
+	uint32 celDataSize = 0;
+
+	while (streamLeft > 0) {
+		ImageFrame frame;
+
+		// We expect a basic header of 8 bytes
+		if (streamLeft < 8)
+			error("load3DOAnimationFile: expected animation header, not enough bytes");
+
+		celDataSize = stream.readUint16BE();
+
+		frame._width = stream.readUint16BE() + 1; // 2 bytes BE width
+		frame._height = stream.readByte() + 1; // 1 byte BE height
+		frame._paletteBase = 0;
+
+		frame._rleEncoded = true; // always compressed
+		if (frame._width & 0x8000) {
+			frame._width &= 0x7FFF;
+			celDataSize += 0x10000;
+		}
+
+		frame._offset.x = stream.readUint16BE();
+		frame._offset.y = stream.readByte();
+		frame._size = 0;
+		// Got header
+		streamLeft -= 8;
+
+		// cel data follows
+		if (streamLeft < celDataSize)
+			error("load3DOAnimationFile: expected cel data, not enough bytes");
+
+		// 
+		// Load data for frame and decompress it
+		byte *data = new byte[celDataSize];
+		stream.read(data, celDataSize);
+		streamLeft -= celDataSize;
+
+		// always 16 bits per pixel (RGB555)
+		decompress3DOCelFrame(frame, data, celDataSize, 16, NULL);
+
+		delete[] data;
+
+		push_back(frame);
+	}
+}
+
+static byte imagefile3DO_cel_bitsPerPixelLookupTable[8] = {
+	0, 1, 2, 4, 6, 8, 16, 0
+};
+
+// Reads a 3DO .cel/.anim file
+void ImageFile3DO::load3DOCelFile(Common::SeekableReadStream &stream) {
+	int32  streamSize = stream.size();
+	int32  chunkStartPos = 0;
+	uint32 chunkTag = 0;
+	uint32 chunkSize = 0;
+	byte  *chunkDataPtr = NULL;
+
+	// ANIM chunk (animation header for animation files)
+	bool   animFound = false;
+	uint32 animVersion = 0;
+	uint32 animType = 0;
+	uint32 animFrameCount = 1; // we expect 1 frame without an ANIM header
+	// CCB chunk (cel control block)
+	bool   ccbFound = false;
+	uint32 ccbVersion = 0;
+	uint32 ccbFlags = 0;
+	bool   ccbFlags_compressed = false;
+	uint16 ccbPPMP0 = 0;
+	uint16 ccbPPMP1 = 0;
+	uint32 ccbPRE0 = 0;
+	uint16 ccbPRE0_height = 0;
+	byte   ccbPRE0_bitsPerPixel = 0;
+	uint32 ccbPRE1 = 0;
+	uint16 ccbPRE1_width = 0;
+	uint32 ccbWidth = 0;
+	uint32 ccbHeight = 0;
+	// pixel lookup table
+	bool   plutFound = false;
+	uint32 plutCount = 0;
+	ImageFile3DOPixelLookupTable plutRGBlookupTable;
+
+	memset(&plutRGBlookupTable, 0, sizeof(plutRGBlookupTable));
+
+	while (!stream.err() && (stream.pos() < streamSize)) {
+		chunkStartPos = stream.pos();
+		chunkTag = stream.readUint32BE();
+		chunkSize = stream.readUint32BE();
+
+		if (stream.eos() || stream.err())
+			break;
+
+		if (chunkSize < 8)
+			error("load3DOCelFile: Invalid chunk size");
+
+		uint32 dataSize = chunkSize - 8;
+
+		switch (chunkTag) {
+		case MKTAG('A', 'N', 'I', 'M'):
+			// animation header
+			assert(dataSize >= 24);
+
+			if (animFound)
+				error("load3DOCelFile: multiple ANIM chunks not supported");
+
+			animFound   = true;
+			animVersion = stream.readUint32BE();
+			animType = stream.readUint32BE();
+			animFrameCount = stream.readUint32BE();
+			// UINT32 - framerate (0x2000 in walk.anim???)
+			// UINT32 - starting frame (0 for walk.anim)
+			// UINT32 - number of loops (0 for walk.anim)
+
+			if (animVersion != 0)
+				error("load3DOCelFile: Unsupported animation file version");
+			if (animType != 1)
+				error("load3DOCelFile: Only single CCB animation files are supported");
+			break;
+
+		case MKTAG('C', 'C', 'B', ' '):
+			// CEL control block
+			assert(dataSize >= 72);
+
+			if (ccbFound)
+				error("load3DOCelFile: multiple CCB chunks not supported");
+
+			ccbFound   = true;
+			ccbVersion = stream.readUint32BE();
+			ccbFlags   = stream.readUint32BE();
+			stream.skip(3 * 4); // skip over 3 pointer fields, which are used in memory only by 3DO hardware
+			stream.skip(8 * 4); // skip over 8 offset fields
+			ccbPPMP0   = stream.readUint16BE();
+			ccbPPMP1   = stream.readUint16BE();
+			ccbPRE0    = stream.readUint32BE();
+			ccbPRE1    = stream.readUint32BE();
+			ccbWidth   = stream.readUint32BE();
+			ccbHeight  = stream.readUint32BE();
+
+			if (ccbVersion != 0)
+				error("load3DOCelFile: Unsupported CCB version");
+
+			if (ccbFlags & 0x200) // bit 9
+				ccbFlags_compressed = true;
+
+			// bit 5 of ccbFlags defines how RGB-black (0, 0, 0) will get treated
+			// = false -> RGB-black is treated as transparent
+			// = true  -> RGB-black is treated as actual black
+			// atm we are always treating it as transparent
+			// it seems this bit is not set for any data of Sherlock Holmes
+
+			// PRE0 first 3 bits define how many bits per encoded pixel are used
+			ccbPRE0_bitsPerPixel = imagefile3DO_cel_bitsPerPixelLookupTable[ccbPRE0 & 0x07];
+			if (!ccbPRE0_bitsPerPixel)
+				error("load3DOCelFile: Invalid CCB PRE0 bits per pixel");
+
+			ccbPRE0_height = ((ccbPRE0 >> 6) & 0x03FF) + 1;
+			ccbPRE1_width  = (ccbPRE1 & 0x03FF) + 1;
+			assert(ccbPRE0_height == ccbHeight);
+			assert(ccbPRE1_width == ccbWidth);
+			break;
+
+		case MKTAG('P', 'L', 'U', 'T'):
+			// pixel lookup table
+			// optional, not required for at least 16-bit pixel data
+			assert(dataSize >= 6);
+
+			if (!ccbFound)
+				error("load3DOCelFile: PLUT chunk found without CCB chunk");
+			if (plutFound)
+				error("load3DOCelFile: multiple PLUT chunks currently not supported");
+
+			plutFound = true;
+			plutCount = stream.readUint32BE();
+			// table follows, each entry is 16bit RGB555
+			assert(dataSize >= 4 + (plutCount * 2)); // security check
+			assert(plutCount <= 256); // security check
+
+			assert(plutCount <= 32); // PLUT should never contain more than 32 entries
+
+			for (uint32 plutColorNr = 0; plutColorNr < plutCount; plutColorNr++) {
+				plutRGBlookupTable.pixelColor[plutColorNr] = stream.readUint16BE();
+			}
+
+			if (ccbPRE0_bitsPerPixel == 8) {
+				// In case we are getting 8-bits per pixel, we calculate the shades accordingly
+				// I'm not 100% sure if the calculation is correct. It's difficult to find information
+				// on this topic.
+				// The map uses this type of cel
+				assert(plutCount == 32); // And we expect 32 entries inside PLUT chunk
+
+				uint16 plutColorRGB = 0;
+				for (uint32 plutColorNr = 0; plutColorNr < plutCount; plutColorNr++) {
+					plutColorRGB = plutRGBlookupTable.pixelColor[plutColorNr];
+
+					// Extract RGB values
+					byte plutColorRed   = (plutColorRGB >> 10) & 0x1F;
+					byte plutColorGreen = (plutColorRGB >> 5) & 0x1F;
+					byte plutColorBlue  = plutColorRGB & 0x1F;
+
+					byte shadeMultiplier = 2;
+					for (uint32 plutShadeNr = 1; plutShadeNr < 8; plutShadeNr++) {
+						uint16 shadedColorRGB;
+						byte   shadedColorRed   = (plutColorRed * shadeMultiplier) >> 3;
+						byte   shadedColorGreen = (plutColorGreen * shadeMultiplier) >> 3;
+						byte   shadedColorBlue  = (plutColorBlue * shadeMultiplier) >> 3;
+
+						shadedColorRed = CLIP<byte>(shadedColorRed, 0, 0x1F);
+						shadedColorGreen = CLIP<byte>(shadedColorGreen, 0, 0x1F);
+						shadedColorBlue = CLIP<byte>(shadedColorBlue, 0, 0x1F);
+						shadedColorRGB = (shadedColorRed << 10) | (shadedColorGreen << 5) | shadedColorBlue;
+
+						plutRGBlookupTable.pixelColor[plutColorNr + (plutShadeNr << 5)] = shadedColorRGB;
+						shadeMultiplier++;
+					}
+				}
+			}
+			break;
+
+		case MKTAG('X', 'T', 'R', 'A'):
+			// Unknown contents, occurs right before PDAT
+			break;
+
+		case MKTAG('P', 'D', 'A', 'T'): {
+			// pixel data for one frame
+			// may be compressed or uncompressed pixels
+
+			if (ccbPRE0_bitsPerPixel != 16) {
+				// We require a pixel lookup table in case bits-per-pixel is lower than 16
+				if (!plutFound)
+					error("load3DOCelFile: bits per pixel < 16, but no pixel lookup table was found");
+			} else {
+				// But we don't like it in case bits-per-pixel is 16 and we find one
+				if (plutFound)
+					error("load3DOCelFile: bits per pixel == 16, but pixel lookup table was found as well");
+			}
+			// read data into memory
+			chunkDataPtr = new byte[dataSize];
+
+			stream.read(chunkDataPtr, dataSize);
+
+			// Set up frame
+			ImageFrame imageFrame;
+
+			imageFrame._width = ccbWidth;
+			imageFrame._height = ccbHeight;
+			imageFrame._paletteBase = 0;
+			imageFrame._offset.x = 0;
+			imageFrame._offset.y = 0;
+			imageFrame._rleEncoded = ccbFlags_compressed;
+			imageFrame._size = 0;
+
+			// Decompress/copy this frame
+			if (!plutFound) {
+				decompress3DOCelFrame(imageFrame, chunkDataPtr, dataSize, ccbPRE0_bitsPerPixel, NULL);
+			} else {
+				decompress3DOCelFrame(imageFrame, chunkDataPtr, dataSize, ccbPRE0_bitsPerPixel, &plutRGBlookupTable);
+			}
+
+			delete[] chunkDataPtr;
+
+			push_back(imageFrame);
+			break;
+		}
+
+		case MKTAG('O', 'F', 'S', 'T'): // 3DOSplash.cel
+			// unknown contents
+			break;
+
+		default:
+			error("Unsupported '%s' chunk in 3DO cel file", tag2str(chunkTag));
+		}
+
+		// Seek to end of chunk
+		stream.seek(chunkStartPos + chunkSize);
+	}
+
+	// Warning below being used to silence unused variable warnings for now
+	warning("TODO: Remove %d %d %d", animFrameCount, ccbPPMP0, ccbPPMP1);
+}
+
+// Reads 3DO .cel data (room file format)
+void ImageFile3DO::load3DOCelRoomData(Common::SeekableReadStream &stream) {
+	uint32 streamLeft = stream.size() - stream.pos();
+	uint16 roomDataHeader_size = 0;
+	byte   roomDataHeader_offsetX = 0;
+	byte   roomDataHeader_offsetY = 0;
+
+	// CCB chunk (cel control block)
+	uint32 ccbFlags = 0;
+	bool   ccbFlags_compressed = false;
+	uint16 ccbPPMP0 = 0;
+	uint16 ccbPPMP1 = 0;
+	uint32 ccbPRE0 = 0;
+	uint16 ccbPRE0_height = 0;
+	byte   ccbPRE0_bitsPerPixel = 0;
+	uint32 ccbPRE1 = 0;
+	uint16 ccbPRE1_width = 0;
+	uint32 ccbWidth = 0;
+	uint32 ccbHeight = 0;
+	// cel data
+	uint32 celDataSize = 0;
+
+	while (streamLeft > 0) {
+		// We expect at least 8 bytes basic header
+		if (streamLeft < 8)
+			error("load3DOCelRoomData: expected room data header, not enough bytes");
+
+		// 3DO sherlock holmes room data header
+		stream.skip(4); // Possibly UINT16 width, UINT16 height?!?!
+		roomDataHeader_size = stream.readUint16BE();
+		roomDataHeader_offsetX = stream.readByte();
+		roomDataHeader_offsetY = stream.readByte();
+		streamLeft -= 8;
+
+		// We expect the header size specified in the basic header to be at least a raw CCB
+		if (roomDataHeader_size < 68)
+			error("load3DOCelRoomData: header size is too small");
+		// Check, that enough bytes for CCB are available
+		if (streamLeft < 68)
+			error("load3DOCelRoomData: expected raw cel control block, not enough bytes");
+
+		// 3DO raw cel control block
+		ccbFlags   = stream.readUint32BE();
+		stream.skip(3 * 4); // skip over 3 pointer fields, which are used in memory only by 3DO hardware
+		stream.skip(8 * 4); // skip over 8 offset fields
+		ccbPPMP0   = stream.readUint16BE();
+		ccbPPMP1   = stream.readUint16BE();
+		ccbPRE0    = stream.readUint32BE();
+		ccbPRE1    = stream.readUint32BE();
+		ccbWidth   = stream.readUint32BE();
+		ccbHeight  = stream.readUint32BE();
+
+		if (ccbFlags & 0x200) // bit 9
+			ccbFlags_compressed = true;
+		
+		// PRE0 first 3 bits define how many bits per encoded pixel are used
+		ccbPRE0_bitsPerPixel = imagefile3DO_cel_bitsPerPixelLookupTable[ccbPRE0 & 0x07];
+		if (!ccbPRE0_bitsPerPixel)
+			error("load3DOCelRoomData: Invalid CCB PRE0 bits per pixel");
+
+		ccbPRE0_height = ((ccbPRE0 >> 6) & 0x03FF) + 1;
+		ccbPRE1_width  = (ccbPRE1 & 0x03FF) + 1;
+		assert(ccbPRE0_height == ccbHeight);
+		assert(ccbPRE1_width == ccbWidth);
+
+		if (ccbPRE0_bitsPerPixel != 16) {
+			// We currently support 16-bits per pixel in here
+			error("load3DOCelRoomData: bits per pixel < 16?!?!?");
+		}
+		// Got the raw CCB
+		streamLeft -= 68;
+
+		// cel data follows
+		// size field does not include the 8 byte header
+		celDataSize = roomDataHeader_size - 68;
+
+		if (streamLeft < celDataSize)
+			error("load3DOCelRoomData: expected cel data, not enough bytes");
+
+		// read data into memory
+		byte  *celDataPtr = new byte[celDataSize];
+
+		stream.read(celDataPtr, celDataSize);
+		streamLeft -= celDataSize;
+		
+		// Set up frame
+		{
+			ImageFrame imageFrame;
+
+			imageFrame._width = ccbWidth;
+			imageFrame._height = ccbHeight;
+			imageFrame._paletteBase = 0;
+			imageFrame._offset.x = roomDataHeader_offsetX;
+			imageFrame._offset.y = roomDataHeader_offsetY;
+			imageFrame._rleEncoded = ccbFlags_compressed;
+			imageFrame._size = 0;
+
+			// Decompress/copy this frame
+			decompress3DOCelFrame(imageFrame, celDataPtr, celDataSize, ccbPRE0_bitsPerPixel, NULL);
+
+			delete[] celDataPtr;
+
+			push_back(imageFrame);
+		}
+	}
+
+	// Suppress compiler warning
+	warning("ccbPPMP0 = %d, ccbPPMP1 = %d", ccbPPMP0, ccbPPMP1);
+}
+
+static uint16 imagefile3DO_cel_bitsMask[17] = {
+	0,
+	0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF,
+	0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF
+};
+
+// gets [bitCount] bits from dataPtr, going from MSB to LSB
+inline uint16 ImageFile3DO::celGetBits(const byte *&dataPtr, byte bitCount, byte &dataBitsLeft) {
+	byte   resultBitsLeft = bitCount;
+	uint16 result = 0;
+	byte   currentByte = *dataPtr;
+
+	// Get bits of current byte
+	while (resultBitsLeft) {
+		if (resultBitsLeft < dataBitsLeft) {
+			// we need less than we have left
+			result |= (currentByte >> (dataBitsLeft - resultBitsLeft)) & imagefile3DO_cel_bitsMask[resultBitsLeft];
+			dataBitsLeft -= resultBitsLeft;
+			resultBitsLeft = 0;
+
+		} else {
+			// we need as much as we have left or more
+			resultBitsLeft -= dataBitsLeft;
+			result |= (currentByte & imagefile3DO_cel_bitsMask[dataBitsLeft]) << resultBitsLeft;
+
+			// Go to next byte
+			dataPtr++;
+			dataBitsLeft = 8;
+			if (resultBitsLeft) {
+				currentByte = *dataPtr;
+			}
+		}
+	}
+	return result;
+}
+
+// decompress/copy 3DO cel data
+void ImageFile3DO::decompress3DOCelFrame(ImageFrame &frame, const byte *dataPtr, uint32 dataSize, byte bitsPerPixel, ImageFile3DOPixelLookupTable *pixelLookupTable) {
+	frame._frame.create(frame._width, frame._height, Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0));
+	uint16 *dest = (uint16 *)frame._frame.getPixels();
+	Common::fill(dest, dest + frame._width * frame._height, 0);
+
+	int frameHeightLeft = frame._height;
+	int frameWidthLeft = frame._width;
+	uint16 pixelCount = 0;
+	uint16 pixel = 0;
+
+	const  byte *srcLineStart = dataPtr;
+	const  byte *srcLineData = dataPtr;
+	byte   srcLineDataBitsLeft = 0;
+	uint16 lineDWordSize = 0;
+	uint16 lineByteSize = 0;
+
+	if (bitsPerPixel == 16) {
+		// Must not use pixel lookup table on 16-bits-per-pixel data
+		assert(!pixelLookupTable);
+	}
+
+	if (frame._rleEncoded) {
+		// compressed
+		byte   compressionType = 0;
+		byte   compressionPixels = 0;
+
+		while (frameHeightLeft > 0) {
+			frameWidthLeft = frame._width;
+
+			if (bitsPerPixel >= 8) {
+				lineDWordSize = READ_BE_UINT16(srcLineStart);
+				srcLineData = srcLineStart + 2;
+			} else {
+				lineDWordSize = *srcLineStart;
+				srcLineData = srcLineStart + 1;
+			}
+			srcLineDataBitsLeft = 8;
+
+			lineDWordSize += 2;
+			lineByteSize = lineDWordSize * 4; // calculate compressed data size in bytes for current line
+
+			// debug
+			//warning("offset %d: decoding line, size %d, bytesize %d", srcSeeker - src, dwordSize, lineByteSize);
+
+			while (frameWidthLeft > 0) {
+				// get 2 bits -> compressionType
+				// get 6 bits -> pixel count (0 = 1 pixel)
+				compressionType = celGetBits(srcLineData, 2, srcLineDataBitsLeft);
+				// 6 bits == length (0 = 1 pixel)
+				compressionPixels = celGetBits(srcLineData, 6, srcLineDataBitsLeft) + 1;
+
+				if (!compressionType) // end of line
+					break;
+
+				switch(compressionType) {
+				case 1: // simple copy
+					for (pixelCount = 0; pixelCount < compressionPixels; pixelCount++) {
+						pixel = celGetBits(srcLineData, bitsPerPixel, srcLineDataBitsLeft);
+						if (pixelLookupTable) {
+							pixel = pixelLookupTable->pixelColor[pixel];
+						}
+						*dest++ = convertPixel(pixel);
+					}
+					break;
+				case 2: // transparent
+					for (pixelCount = 0; pixelCount < compressionPixels; pixelCount++) {
+						*dest++ = 0;
+					}
+					break;
+				case 3: // duplicate pixels
+					pixel = celGetBits(srcLineData, bitsPerPixel, srcLineDataBitsLeft);
+					if (pixelLookupTable) {
+						pixel = pixelLookupTable->pixelColor[pixel];
+					}
+					pixel = convertPixel(pixel);
+					for (pixelCount = 0; pixelCount < compressionPixels; pixelCount++) {
+						*dest++ = pixel;
+					}
+					break;
+				default:
+					break;
+				}
+				frameWidthLeft -= compressionPixels;
+			}
+
+			assert(frameWidthLeft >= 0);
+
+			if (frameWidthLeft > 0) {
+				// still pixels left? skip them
+				dest += frameWidthLeft;
+			}
+
+			frameHeightLeft--;
+
+			// Seek to next line start
+			srcLineStart += lineByteSize;
+		}
+	} else {
+		// uncompressed
+		srcLineDataBitsLeft = 8;
+		lineDWordSize = ((frame._width * bitsPerPixel) + 31) >> 5;
+		lineByteSize = lineDWordSize * 4;
+		uint32 totalExpectedSize = lineByteSize * frame._height;
+
+		assert(totalExpectedSize <= dataSize); // security check
+
+		while (frameHeightLeft > 0) {
+			srcLineData = srcLineStart;
+			frameWidthLeft = frame._width;
+
+			while (frameWidthLeft > 0) {
+				pixel = celGetBits(srcLineData, bitsPerPixel, srcLineDataBitsLeft);
+				if (pixelLookupTable) {
+					pixel = pixelLookupTable->pixelColor[pixel];
+				}
+				*dest++ = convertPixel(pixel);
+
+				frameWidthLeft--;
+			}
+			frameHeightLeft--;
+
+			// Seek to next line start
+			srcLineStart += lineByteSize;
+		}
+	}
+}
+
+// Reads Sherlock Holmes 3DO font file
+void ImageFile3DO::loadFont(Common::SeekableReadStream &stream) {
+	uint32 streamSize = stream.size();
+	uint32 header_offsetWidthTable = 0;
+	uint32 header_offsetBitsTable = 0;
+	uint32 header_fontHeight = 0;
+	uint32 header_bytesPerLine = 0;
+	uint32 header_maxChar = 0;
+	uint32 header_charCount = 0;
+
+	byte  *widthTablePtr = NULL;
+	uint32 bitsTableSize = 0;
+	byte  *bitsTablePtr = NULL;
+
+	stream.skip(2); // Unknown bytes
+	stream.skip(2); // Unknown bytes (0x000E)
+	header_offsetWidthTable = stream.readUint32BE();
+	header_offsetBitsTable = stream.readUint32BE();
+	stream.skip(4); // Unknown bytes (0x00000004)
+	header_fontHeight = stream.readUint32BE();
+	header_bytesPerLine = stream.readUint32BE();
+	header_maxChar = stream.readUint32BE();
+
+	assert(header_maxChar <= 255);
+	header_charCount = header_maxChar + 1;
+
+	// Allocate memory for width table
+	widthTablePtr = new byte[header_charCount];
+
+	stream.seek(header_offsetWidthTable);
+	stream.read(widthTablePtr, header_charCount);
+
+	// Allocate memory for the bits
+	assert(header_offsetBitsTable < streamSize); // Security check
+	bitsTableSize = streamSize - header_offsetBitsTable;
+	bitsTablePtr  = new byte[bitsTableSize];
+	stream.read(bitsTablePtr, bitsTableSize);
+
+	// Now extract all characters
+	uint16       curChar = 0;
+	const byte  *curBitsLinePtr = bitsTablePtr;
+	const byte  *curBitsPtr = NULL;
+	byte         curBitsLeft = 0;
+	uint32       curCharHeightLeft = 0;
+	uint32       curCharWidthLeft = 0;
+	byte         curBits = 0;
+	byte         curBitsReversed = 0;
+	byte         curPosX = 0;
+
+	assert(bitsTableSize >= (header_maxChar * header_fontHeight * header_bytesPerLine)); // Security
+
+	// first frame needs to be "!" (33 decimal)
+	// our font code is subtracting 33 from the actual character code
+	curBitsLinePtr += (33 * (header_fontHeight * header_bytesPerLine));
+
+	for (curChar = 33; curChar < header_charCount; curChar++) {
+		// create frame
+		ImageFrame imageFrame;
+
+		imageFrame._width = widthTablePtr[curChar];
+		imageFrame._height = header_fontHeight;
+		imageFrame._paletteBase = 0;
+		imageFrame._offset.x = 0;
+		imageFrame._offset.y = 0;
+		imageFrame._rleEncoded = false;
+		imageFrame._size = 0;
+
+		// Extract pixels
+		imageFrame._frame.create(imageFrame._width, imageFrame._height, Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0));
+		uint16 *dest = (uint16 *)imageFrame._frame.getPixels();
+		Common::fill(dest, dest + imageFrame._width * imageFrame._height, 0);
+
+		curCharHeightLeft = header_fontHeight;
+		while (curCharHeightLeft) {
+			curCharWidthLeft = widthTablePtr[curChar];
+			curBitsPtr  = curBitsLinePtr;
+			curBitsLeft = 8;
+			curPosX     = 0;
+
+			while (curCharWidthLeft) {
+				if (!(curPosX & 1)) {
+					curBits = *curBitsPtr >> 4;
+				} else {
+					curBits = *curBitsPtr & 0x0F;
+					curBitsPtr++;
+				}
+				// doing this properly is complicated
+				// the 3DO has built-in anti-aliasing
+				// this here at least results in somewhat readable text
+				// TODO: make it better
+				if (curBits) {
+					curBitsReversed = (curBits >> 3) | ((curBits & 0x04) >> 1) | ((curBits & 0x02) << 1) | ((curBits & 0x01) << 3);
+					curBits = 20 - curBits;
+				}
+
+				byte curIntensity = curBits;
+				*dest = (curIntensity << 11) | (curIntensity << 6) | curIntensity;
+				dest++;
+
+				curCharWidthLeft--;
+				curPosX++;
+			}
+
+			curCharHeightLeft--;
+			curBitsLinePtr += header_bytesPerLine;
+		}
+
+		push_back(imageFrame);
+	}
+
+	// Warning below being used to silence unused variable warnings for now
+	warning("TODO: Remove %d %d", curBitsLeft, curBitsReversed);
+
+	delete[] bitsTablePtr;
+	delete[] widthTablePtr;
+}
+
+/*----------------------------------------------------------------*/
+
+StreamingImageFile::StreamingImageFile() {
+	_frameNumber = 0;
+	_stream = nullptr;
+	_flags = 0;
+	_scaleVal = 0;
+	_zPlacement = 0;
+	_compressed = false;
+	_active = false;
+}
+
+StreamingImageFile::~StreamingImageFile() {
+	close();
+}
+
+void StreamingImageFile::load(Common::SeekableReadStream *stream, bool compressed) {
+	_stream = stream;
+	_compressed = compressed;
+	_frameNumber = -1;
+	_active = true;
+}
+
+void StreamingImageFile::close() {
+	delete _stream;
+	_stream = nullptr;
+	_frameNumber = -1;
+	_active = false;
+	_imageFrame._frame.free();
+}
+
+bool StreamingImageFile::getNextFrame() {
+	// Don't proceed if we're already at the end of the stream
+	assert(_stream);
+	if (_stream->pos() >= _stream->size()) {
+		_active = false;
+		return false;
+	}
+
+	// Increment frame number
+	++_frameNumber;
+
+	// If necessary, decompress the next frame
+	Common::SeekableReadStream *frameStream = _stream;
+	if (_compressed) {
+		uint32 inSize = _stream->readUint32LE();
+		Resources::decompressLZ(*_stream, _buffer, STREAMING_BUFFER_SIZE, inSize);
+		frameStream = new Common::MemoryReadStream(_buffer, 11, DisposeAfterUse::NO);
+	}
+
+	// Load the data for the frame
+	_imageFrame._width = frameStream->readUint16LE() + 1;
+	_imageFrame._height = frameStream->readUint16LE() + 1;
+	_imageFrame._paletteBase = frameStream->readByte();
+	_imageFrame._rleEncoded = frameStream->readByte() == 1;
+	_imageFrame._offset.x = frameStream->readByte();
+	_imageFrame._offset.y = frameStream->readByte();
+	_imageFrame._size = frameStream->readUint16LE() - 11;
+	_imageFrame._rleMarker = frameStream->readByte();
+
+	// Free the previous frame
+	_imageFrame._frame.free();
+
+	// Decode the frame
+	if (_compressed) {
+		delete frameStream;
+		_imageFrame.decompressFrame(_buffer + 11, true);
+	} else {
+		byte *data = new byte[_imageFrame._size];
+		_stream->read(data, _imageFrame._size);
+		_imageFrame.decompressFrame(_buffer + 11, true);
+		delete[] data;
+	}
+
+	return true;
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/image_file.h b/engines/sherlock/image_file.h
new file mode 100644
index 0000000000..da260ab30b
--- /dev/null
+++ b/engines/sherlock/image_file.h
@@ -0,0 +1,208 @@
+/* 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 SHERLOCK_IMAGE_FILE_H
+#define SHERLOCK_IMAGE_FILE_H
+
+#include "common/array.h"
+#include "common/file.h"
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+#include "common/rect.h"
+#include "common/str.h"
+#include "common/stream.h"
+#include "graphics/surface.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+struct ImageFrame {
+	uint32 _size;
+	uint16 _width, _height;
+	int _paletteBase;
+	bool _rleEncoded;
+	Common::Point _offset;
+	byte _rleMarker;
+	Graphics::Surface _frame;
+
+	/**
+	 * Decompress a single frame for the sprite
+	 */
+	void decompressFrame(const byte *src, bool isRoseTattoo);
+
+	/**
+	 * Return the frame width adjusted by a specified scale amount
+	 */
+	int sDrawXSize(int scaleVal) const;
+
+	/**
+	 * Return the frame height adjusted by a specified scale amount
+	 */
+	int sDrawYSize(int scaleVal) const;
+
+	/**
+	 * Return the frame offset x adjusted by a specified scale amount
+	 */
+	int sDrawXOffset(int scaleVal) const;
+
+	/**
+	 * Return the frame offset y adjusted by a specified scale amount
+	 */
+	int sDrawYOffset(int scaleVal) const;
+};
+
+class ImageFile : public Common::Array<ImageFrame> {
+private:
+	static SherlockEngine *_vm;
+
+	/**
+	 * Load the data of the sprite
+	 */
+	void load(Common::SeekableReadStream &stream, bool skipPalette, bool animImages);
+
+	/**
+	 * Gets the palette at the start of the sprite file
+	 */
+	void loadPalette(Common::SeekableReadStream &stream);
+public:
+	byte _palette[256 * 3];
+public:
+	ImageFile();
+	ImageFile(const Common::String &name, bool skipPal = false, bool animImages = false);
+	ImageFile(Common::SeekableReadStream &stream, bool skipPal = false);
+	~ImageFile();
+	static void setVm(SherlockEngine *vm);
+};
+
+enum ImageFile3DOType {
+	kImageFile3DOType_Animation    = 0,
+	kImageFile3DOType_Cel          = 1,
+	kImageFile3DOType_CelAnimation = 2,
+	kImageFile3DOType_RoomFormat   = 3,
+	kImageFile3DOType_Font         = 4
+};
+
+struct ImageFile3DOPixelLookupTable {
+	uint16 pixelColor[256];
+};
+
+class ImageFile3DO : public ImageFile { // Common::Array<ImageFrame> {
+private:
+	static SherlockEngine *_vm;
+
+	/**
+	 * Load the data of the sprite
+	 */
+	void load(Common::SeekableReadStream &stream, bool isRoomData);
+
+	/**
+	 * convert pixel RGB values from RGB555 to RGB565
+	 */
+	inline uint16 convertPixel(uint16 pixel3DO);
+
+	/**
+	 * Load 3DO cel file
+	 */
+	void load3DOCelFile(Common::SeekableReadStream &stream);
+
+	/**
+	 * Load 3DO cel data (room file format)
+	 */
+	void load3DOCelRoomData(Common::SeekableReadStream &stream);
+
+	inline uint16 celGetBits(const byte *&dataPtr, byte bitCount, byte &dataBitsLeft);
+
+	/**
+	 * Decompress a single frame of a 3DO cel file
+	 */
+	void decompress3DOCelFrame(ImageFrame &frame, const byte *dataPtr, uint32 dataSize, byte bitsPerPixel, ImageFile3DOPixelLookupTable *pixelLookupTable);
+
+	/**
+	 * Load animation graphics file
+	 */
+	void loadAnimationFile(Common::SeekableReadStream &stream);
+
+	/**
+	 * Load Sherlock Holmes 3DO font file
+	 */
+	void loadFont(Common::SeekableReadStream &stream);
+
+public:
+	ImageFile3DO(const Common::String &name, ImageFile3DOType imageFile3DOType);
+	ImageFile3DO(Common::SeekableReadStream &stream, bool isRoomData = false);
+	~ImageFile3DO();
+	static void setVm(SherlockEngine *vm);
+};
+
+#define STREAMING_BUFFER_SIZE 65536
+
+class StreamingImageFile {
+private:
+	int _frameNumber;
+	Common::SeekableReadStream *_stream;
+	byte _buffer[STREAMING_BUFFER_SIZE];
+	bool _compressed;
+	bool _active;
+public:
+	ImageFrame _imageFrame;
+
+	Common::Point _position;		// Animation position
+	Common::Rect _oldBounds;		// Bounds of previous frame
+	Common::Rect _removeBounds;		// Remove area for just drawn frame
+
+	int _flags;						// Flags
+	int _scaleVal;					// Specifies the scale amount
+	int _zPlacement;				// Used by doBgAnim for determining Z order
+public:
+	StreamingImageFile();
+	~StreamingImageFile();
+
+	/**
+	 * Initialize reading of the specified stream
+	 */
+	void load(Common::SeekableReadStream *stream, bool compressed);
+
+	/**
+	 * Close the streamining image file
+	 */
+	void close();
+
+	/**
+	 * Get the next frame of the file
+	 */
+	bool getNextFrame();
+
+	/**
+	 * Returns whether there are any remaining frames or not
+	 */
+	bool active() const { return _active; }
+
+	/**
+	 * Return the current frame number
+	 */
+	int frameNumber() const { return _frameNumber; }
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/inventory.cpp b/engines/sherlock/inventory.cpp
new file mode 100644
index 0000000000..d0982542f2
--- /dev/null
+++ b/engines/sherlock/inventory.cpp
@@ -0,0 +1,246 @@
+/* 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 "sherlock/inventory.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/scalpel/scalpel_inventory.h"
+#include "sherlock/scalpel/scalpel_user_interface.h"
+#include "sherlock/tattoo/tattoo_inventory.h"
+
+namespace Sherlock {
+
+InventoryItem::InventoryItem(int requiredFlag, const Common::String &name,
+		const Common::String &description, const Common::String &examine) :
+		_requiredFlag(requiredFlag), _requiredFlag1(0), _name(name), _description(description),
+		_examine(examine), _lookFlag(0) {
+}
+
+InventoryItem::InventoryItem(int requiredFlag, const Common::String &name,
+		const Common::String &description, const Common::String &examine, const Common::String &verbName) :
+		_requiredFlag(requiredFlag), _requiredFlag1(0), _name(name), _description(description),
+		_examine(examine), _lookFlag(0) {
+	_verb._verb = verbName;
+}
+
+void InventoryItem::synchronize(Serializer &s) {
+	s.syncAsSint16LE(_requiredFlag);
+	s.syncAsSint16LE(_lookFlag);
+	s.syncString(_name);
+	s.syncString(_description);
+	s.syncString(_examine);
+	_verb.synchronize(s);
+}
+
+/*----------------------------------------------------------------*/
+
+Inventory *Inventory::init(SherlockEngine *vm) {
+	if (vm->getGameID() == GType_SerratedScalpel)
+		return new Scalpel::ScalpelInventory(vm);
+	else
+		return new Tattoo::TattooInventory(vm);
+}
+
+Inventory::Inventory(SherlockEngine *vm) : Common::Array<InventoryItem>(), _vm(vm) {
+	_invGraphicsLoaded = false;
+	_invIndex = 0;
+	_holdings = 0;
+	_invMode = INVMODE_EXIT;
+}
+
+Inventory::~Inventory() {
+	freeGraphics();
+}
+
+void Inventory::freeInv() {
+	freeGraphics();
+
+	_names.clear();
+	_invGraphicsLoaded = false;
+}
+
+void Inventory::freeGraphics() {
+	int count = _invShapes.size();
+	for (int idx = 0; idx < count; ++idx)
+		delete _invShapes[idx];
+	_invShapes.clear();
+	_invShapes.resize(count);
+
+	_invGraphicsLoaded = false;
+}
+
+void Inventory::loadGraphics() {
+	if (_invGraphicsLoaded)
+		return;
+
+	for (int idx = _invIndex; (idx < _holdings) && (idx - _invIndex) < (int)_invShapes.size(); ++idx) {
+		// Get the name of the item to be displayed, figure out its accompanying
+		// .VGS file with its picture, and then load it
+		int invNum = findInv((*this)[idx]._name);
+		Common::String filename = Common::String::format("item%02d.vgs", invNum + 1);
+
+		if (!IS_3DO) {
+			// PC
+			_invShapes[idx - _invIndex] = new ImageFile(filename);
+		} else {
+			_invShapes[idx - _invIndex] = new ImageFile3DO(filename, kImageFile3DOType_RoomFormat);
+		}
+	}
+
+	_invGraphicsLoaded = true;
+}
+
+int Inventory::findInv(const Common::String &name) {
+	for (int idx = 0; idx < (int)_names.size(); ++idx) {
+		if (name.equalsIgnoreCase(_names[idx]))
+			return idx;
+	}
+
+	// Couldn't find the desired item
+	error("Couldn't find inventory item - %s", name.c_str());
+}
+
+int Inventory::putNameInInventory(const Common::String &name) {
+	Scene &scene = *_vm->_scene;
+	int matches = 0;
+
+	for (uint idx = 0; idx < scene._bgShapes.size(); ++idx) {
+		Object &o = scene._bgShapes[idx];
+		if (name.equalsIgnoreCase(o._name) && o._type != INVALID) {
+			putItemInInventory(o);
+			++matches;
+		}
+	}
+
+	return matches;
+}
+
+int Inventory::putItemInInventory(Object &obj) {
+	Scene &scene = *_vm->_scene;
+	int matches = 0;
+	bool pickupFound = false;
+
+	if (obj._pickupFlag)
+		_vm->setFlags(obj._pickupFlag);
+
+	for (int useNum = 0; useNum < USE_COUNT; ++useNum) {
+		if (obj._use[useNum]._target.equalsIgnoreCase("*PICKUP*")) {
+			pickupFound = true;
+
+			for (int namesNum = 0; namesNum < NAMES_COUNT; ++namesNum) {
+				for (uint bgNum = 0; bgNum < scene._bgShapes.size(); ++bgNum) {
+					Object &bgObj = scene._bgShapes[bgNum];
+					if (obj._use[useNum]._names[namesNum].equalsIgnoreCase(bgObj._name)) {
+						copyToInventory(bgObj);
+						if (bgObj._pickupFlag)
+							_vm->setFlags(bgObj._pickupFlag);
+
+						if (bgObj._type == ACTIVE_BG_SHAPE || bgObj._type == NO_SHAPE || bgObj._type == HIDE_SHAPE) {
+							if (bgObj._imageFrame == nullptr || bgObj._frameNumber < 0)
+								// No shape to erase, so flag as hidden
+								bgObj._type = INVALID;
+							else
+								bgObj._type = REMOVE;
+						} else if (bgObj._type == HIDDEN) {
+							bgObj._type = INVALID;
+						}
+
+						++matches;
+					}
+				}
+			}
+		}
+	}
+
+	if (!pickupFound) {
+		// No pickup item found, so add the passed item
+		copyToInventory(obj);
+		matches = 0;
+	}
+
+	if (matches == 0) {
+		if (!pickupFound)
+			matches = 1;
+
+		if (obj._type == ACTIVE_BG_SHAPE || obj._type == NO_SHAPE || obj._type == HIDE_SHAPE) {
+			if (obj._imageFrame == nullptr || obj._frameNumber < 0)
+				// No shape to erase, so flag as hidden
+				obj._type = INVALID;
+			else
+				obj._type = REMOVE;
+		} else if (obj._type == HIDDEN) {
+			obj._type = INVALID;
+		}
+	}
+
+	return matches;
+}
+
+void Inventory::copyToInventory(Object &obj) {
+	InventoryItem invItem;
+	invItem._name = obj._name;
+	invItem._description = obj._description;
+	invItem._examine = obj._examine;
+	invItem._lookFlag = obj._lookFlag;
+	invItem._requiredFlag = obj._requiredFlag[0];
+
+	insert_at(_holdings, invItem);
+	++_holdings;
+}
+
+int Inventory::deleteItemFromInventory(const Common::String &name) {
+	int invNum = -1;
+
+	for (int idx = 0; idx < (int)size() && invNum == -1; ++idx) {
+		if (name.equalsIgnoreCase((*this)[idx]._name))
+			invNum = idx;
+	}
+
+	if (invNum == -1)
+		// Item not present
+		return 0;
+
+	// Item found, so delete it
+	remove_at(invNum);
+	--_holdings;
+
+	return 1;
+}
+
+void Inventory::synchronize(Serializer &s) {
+	s.syncAsSint16LE(_holdings);
+
+	uint count = size();
+	s.syncAsUint16LE(count);
+	if (s.isLoading()) {
+		resize(count);
+
+		// Reset inventory back to start
+		_invIndex = 0;
+	}
+
+	for (uint idx = 0; idx < size(); ++idx) {
+		(*this)[idx].synchronize(s);
+
+	}
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/inventory.h b/engines/sherlock/inventory.h
new file mode 100644
index 0000000000..057e923e5d
--- /dev/null
+++ b/engines/sherlock/inventory.h
@@ -0,0 +1,150 @@
+/* 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 SHERLOCK_INVENTORY_H
+#define SHERLOCK_INVENTORY_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/str-array.h"
+#include "sherlock/objects.h"
+#include "sherlock/resources.h"
+#include "sherlock/saveload.h"
+
+namespace Sherlock {
+
+enum InvMode {
+	INVMODE_EXIT = 0,
+	INVMODE_LOOK = 1,
+	INVMODE_USE = 2,
+	INVMODE_GIVE = 3,
+	INVMODE_FIRST = 4,
+	INVMODE_PREVIOUS = 5,
+	INVMODE_NEXT = 6,
+	INVMODE_LAST = 7,
+	INVMODE_INVALID = 8,
+	INVMODE_USE55 = 255
+};
+
+enum InvNewMode {
+	PLAIN_INVENTORY = 0, LOOK_INVENTORY_MODE = 1, USE_INVENTORY_MODE = 2,
+	GIVE_INVENTORY_MODE = 3, INVENTORY_DONT_DISPLAY = 128
+};
+
+enum InvSlamMode { SLAM_DONT_DISPLAY, SLAM_DISPLAY = 1, SLAM_SECONDARY_BUFFER };
+
+
+struct InventoryItem {
+	int _requiredFlag;
+	Common::String _name;
+	Common::String _description;
+	Common::String _examine;
+	int _lookFlag;
+
+	// Rose Tattoo fields
+	int _requiredFlag1;
+	UseType _verb;
+
+	InventoryItem() : _requiredFlag(0), _lookFlag(0), _requiredFlag1(0) {}
+	InventoryItem(int requiredFlag, const Common::String &name,
+		const Common::String &description, const Common::String &examine);
+	InventoryItem(int requiredFlag, const Common::String &name,
+		const Common::String &description, const Common::String &examine, const Common::String &verbName);
+
+	/**
+	 * Synchronize the data for an inventory item
+	 */
+	void synchronize(Serializer &s);
+};
+
+class Inventory : public Common::Array<InventoryItem> {
+protected:
+	SherlockEngine *_vm;
+	Common::StringArray _names;
+
+	/**
+	 * Copy the passed object into the inventory
+	 */
+	void copyToInventory(Object &obj);
+public:
+	Common::Array<ImageFile *> _invShapes;
+	bool _invGraphicsLoaded;
+	InvMode _invMode;
+	int _invIndex;
+	int _holdings;		// Used to hold number of visible items in active inventory.
+						// Since Inventory array also contains some special hidden items
+	/**
+	 * Free any loaded inventory graphics
+	 */
+	void freeGraphics();
+public:
+	static Inventory *init(SherlockEngine *vm);
+	Inventory(SherlockEngine *vm);
+	virtual ~Inventory();
+
+	/**
+	 * Free inventory data
+	 */
+	void freeInv();
+
+	/**
+	 * Load the list of names of graphics for the inventory
+	 */
+	void loadGraphics();
+
+	/**
+	 * Searches through the list of names that correspond to the inventory items
+	 * and returns the number that matches the passed name
+	 */
+	int findInv(const Common::String &name);
+
+	/**
+	 * Adds a shape from the scene to the player's inventory
+	 */
+	int putNameInInventory(const Common::String &name);
+
+	/**
+	 * Moves a specified item into the player's inventory If the item has a *PICKUP* use action,
+	 * then the item in the use action are added to the inventory.
+	 */
+	int putItemInInventory(Object &obj);
+
+	/**
+	 * Deletes a specified item from the player's inventory
+	 */
+	int deleteItemFromInventory(const Common::String &name);
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	void synchronize(Serializer &s);
+
+	/**
+	 * Load the list of names the inventory items correspond to, if not already loaded,
+	 * and then calls loadGraphics to load the associated graphics
+	 */
+	virtual void loadInv() = 0;
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/journal.cpp b/engines/sherlock/journal.cpp
new file mode 100644
index 0000000000..e443b6f727
--- /dev/null
+++ b/engines/sherlock/journal.cpp
@@ -0,0 +1,760 @@
+/* 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 "sherlock/journal.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/scalpel/scalpel_fixed_text.h"
+#include "sherlock/scalpel/scalpel_journal.h"
+#include "sherlock/scalpel/scalpel_talk.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_journal.h"
+
+namespace Sherlock {
+
+static const int TATTOO_LINE_SPACING[17] = {
+	21, 21, 20, 21, 20, 21, 20, 21, 20, 21, 20, 21, 20, 20, 20, 20, 21
+};
+
+/*----------------------------------------------------------------*/
+
+Journal *Journal::init(SherlockEngine *vm) {
+	if (vm->getGameID() == GType_SerratedScalpel)
+		return new Scalpel::ScalpelJournal(vm);
+	else
+		return new Tattoo::TattooJournal(vm);
+}
+
+Journal::Journal(SherlockEngine *vm) : _vm(vm) {
+	_up = _down = false;
+	_index = 0;
+	_page = 1;
+	_maxPage = 0;
+	_sub = 0;
+}
+
+bool Journal::drawJournal(int direction, int howFar) {
+	Events &events = *_vm->_events;
+	FixedText &fixedText = *_vm->_fixedText;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	int topLineY = IS_SERRATED_SCALPEL ? 37 : 103 - screen.charHeight('A');
+	int yp = topLineY;
+	int startPage = _page;
+	bool endJournal = false;
+	bool firstOccurance = true;
+	bool searchSuccessful = false;
+	bool endFlag = false;
+	int lineNum = 0;
+	int savedIndex;
+	int temp;
+	const char *matchP;
+	int width;
+
+	talk._converseNum = -1;
+	_down = true;
+
+	do {
+		// Get the number of lines for the current journal entry
+		loadJournalFile(false);
+		if (_lines.empty()) {
+			// Entry has no text, so it must be a stealth eny. Move onto further journal entries
+			// until an entry with text is found
+			if (++_index == (int)_journal.size()) {
+				endJournal = true;
+			} else {
+				_sub = 0;
+				loadJournalFile(false);
+			}
+		}
+	} while (!endJournal && _lines.empty());
+
+	// Check if there no further pages with text until the end of the journal
+	if (endJournal) {
+		// If moving forward or backwards, clear the page before printing
+		if (direction)
+			drawFrame();
+
+		if (IS_SERRATED_SCALPEL)
+			screen.gPrint(Common::Point(235, 21), COL_PEN_COLOR, fixedText.getText(Scalpel::kFixedText_Journal_Page), _page);
+		else
+			screen.gPrint(Common::Point(530, 72), COL_PEN_COLOR, fixedText.getText(Tattoo::kFixedText_Page), _page);
+
+		return false;
+	}
+
+	// If the journal page is being changed, set the wait cursor
+	if (direction)
+		events.setCursor(WAIT);
+
+	switch (direction) {
+	case 1:
+	case 4:
+		// Move backwards howFar number of lines unless either the start of the journal is reached,
+		// or a searched for keyword is found
+		do {
+			// Move backwards through the journal file a line at a time
+			if (--_sub < 0) {
+				do {
+					if (--_index < 0) {
+						_index = 0;
+						_sub = 0;
+						endJournal = true;
+					}
+					else {
+						loadJournalFile(false);
+						_sub = _lines.size() - 1;
+					}
+				} while (!endJournal && _lines.empty());
+			}
+
+			// If it's search mode, check each line for the given keyword
+			if (direction >= 3 && !_lines.empty() && !endJournal && !searchSuccessful) {
+				Common::String line = _lines[_sub];
+				line.toUppercase();
+				if (strstr(line.c_str(), _find.c_str()) != nullptr) {
+					// Found a match. Reset howFar so that the start of page that the match
+					// was found on will be displayed
+					searchSuccessful = true;
+					howFar = ((lineNum / LINES_PER_PAGE) + 1) * LINES_PER_PAGE;
+				}
+			}
+
+			++lineNum;
+		} while (lineNum < howFar && !endJournal);
+
+		if (!_index && !_sub)
+			_page = 1;
+		else
+			_page -= howFar / LINES_PER_PAGE;
+		break;
+
+	case 2:
+	case 3:
+		// Move howFar lines ahead unless the end of the journal is reached,
+		// or a searched for keyword is found
+		for (temp = 0; (temp < (howFar / LINES_PER_PAGE)) && !endJournal && !searchSuccessful; ++temp) {
+			// Handle animating mouse cursor
+			events.animateCursorIfNeeded();
+
+			lineNum = 0;
+			savedIndex = _index;
+			int savedSub = _sub;
+
+			// Move a single page ahead
+			do {
+				// If in search mode, check for keyword
+				if (direction >= 3 && _page != startPage) {
+					Common::String line = _lines[_sub];
+					line.toUppercase();
+					if (strstr(line.c_str(), _find.c_str()) != nullptr)
+						searchSuccessful = true;
+				}
+
+				// Move forwards a line at a time, unless search word was found
+				if (!searchSuccessful) {
+					if (++_sub == (int)_lines.size()) {
+						// Reached end of page
+						do {
+							if (++_index == (int)_journal.size()) {
+								_index = savedIndex;
+								_sub = savedSub;
+								loadJournalFile(false);
+								endJournal = true;
+							} else {
+								_sub = 0;
+								loadJournalFile(false);
+							}
+						} while (!endJournal && _lines.empty());
+					}
+
+					++lineNum;
+				}
+			} while ((lineNum < LINES_PER_PAGE) && !endJournal && !searchSuccessful);
+
+			if (!endJournal && !searchSuccessful)
+				// Move to next page
+				++_page;
+
+			if (searchSuccessful) {
+				// Search found, so show top of the page it was found on
+				_index = savedIndex;
+				_sub = savedSub;
+				loadJournalFile(false);
+			}
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	if (direction) {
+		events.setCursor(ARROW);
+		drawFrame();
+	}
+
+	if (IS_SERRATED_SCALPEL)
+		screen.gPrint(Common::Point(235, 21), COL_PEN_COLOR, fixedText.getText(Scalpel::kFixedText_Journal_Page), _page);
+	else
+		screen.gPrint(Common::Point(530, 72), COL_PEN_COLOR, fixedText.getText(Tattoo::kFixedText_Page), _page);
+
+	temp = _sub;
+	savedIndex = _index;
+	lineNum = 0;
+
+	do {
+		bool inc = true;
+
+		// If there wasn't any line to print at the top of the page, we won't need to
+		// increment the y position
+		if (_lines[temp].empty() && yp == topLineY)
+			inc = false;
+
+		// If there's a searched for keyword in the line, it will need to be highlighted
+		if (searchSuccessful && firstOccurance) {
+			// Check if line has the keyword
+			Common::String line = _lines[temp];
+			line.toUppercase();
+			if ((matchP = strstr(line.c_str(), _find.c_str())) != nullptr) {
+				matchP = _lines[temp].c_str() + (matchP - line.c_str());
+				firstOccurance = false;
+
+				// Print out the start of the line before the matching keyword
+				Common::String lineStart(_lines[temp].c_str(), matchP);
+				if (lineStart.hasPrefix("@")) {
+					width = screen.stringWidth(lineStart.c_str() + 1);
+					screen.gPrint(Common::Point(JOURNAL_LEFT_X, yp), COL_PEN_HIGHLIGHT, "%s", lineStart.c_str() + 1);
+				} else {
+					width = screen.stringWidth(lineStart.c_str());
+					screen.gPrint(Common::Point(JOURNAL_LEFT_X, yp), COL_PEN_COLOR, "%s", lineStart.c_str());
+				 }
+
+				// Print out the found keyword
+				Common::String lineMatch(matchP, matchP + _find.size());
+				byte fgColor = IS_SERRATED_SCALPEL ? (byte)Scalpel::INV_FOREGROUND : (byte)Tattoo::PEN_HIGHLIGHT_COLOR;
+				screen.gPrint(Common::Point(JOURNAL_LEFT_X + width, yp), fgColor, "%s", lineMatch.c_str());
+				width += screen.stringWidth(lineMatch.c_str());
+
+				// Print remainder of line
+				screen.gPrint(Common::Point(JOURNAL_LEFT_X + width, yp), COL_PEN_COLOR, "%s", matchP + _find.size());
+			} else if (_lines[temp].hasPrefix("@")) {
+				screen.gPrint(Common::Point(JOURNAL_LEFT_X, yp), COL_PEN_HIGHLIGHT, "%s", _lines[temp].c_str() + 1);
+			} else {
+				screen.gPrint(Common::Point(JOURNAL_LEFT_X, yp), COL_PEN_COLOR, "%s", _lines[temp].c_str());
+			}
+		} else {
+			if (_lines[temp].hasPrefix("@")) {
+				screen.gPrint(Common::Point(JOURNAL_LEFT_X, yp), COL_PEN_HIGHLIGHT, "%s", _lines[temp].c_str() + 1);
+			} else {
+				screen.gPrint(Common::Point(JOURNAL_LEFT_X, yp), COL_PEN_COLOR, "%s", _lines[temp].c_str());
+			}
+		}
+
+		if (++temp == (int)_lines.size()) {
+			// Move to next page
+			do {
+				if (_index < ((int)_journal.size() - 1) && lineNum < (LINES_PER_PAGE - 1)) {
+					++_index;
+					loadJournalFile(false);
+					temp = 0;
+				} else {
+					if (_index == ((int)_journal.size() - 1))
+						_down = false;
+					endFlag = true;
+				}
+			} while (!endFlag && _lines.empty());
+		}
+
+		if (inc) {
+			// Move to next line
+			yp += IS_SERRATED_SCALPEL ? 13 : TATTOO_LINE_SPACING[lineNum];
+			++lineNum;
+		}
+	} while (lineNum < LINES_PER_PAGE && !endFlag);
+
+	_index = savedIndex;
+	_up = _index || _sub;
+
+	return direction >= 3 && searchSuccessful;
+}
+
+void Journal::loadJournalFile(bool alreadyLoaded) {
+	People &people = *_vm->_people;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	JournalEntry &journalEntry = _journal[_index];
+	const byte *opcodes = talk._opcodes;
+
+	Common::String dirFilename = _directory[journalEntry._converseNum];
+	bool replyOnly = journalEntry._replyOnly;
+
+	// Get the location number from within the filename
+	Common::String locStr(dirFilename.c_str() + 4, dirFilename.c_str() + 6);
+	int newLocation = atoi(locStr.c_str());
+
+	// If not flagged as already loaded, load the conversation into script variables
+	if (!alreadyLoaded) {
+		// See if the file to be used is already loaded
+		if (journalEntry._converseNum != talk._converseNum) {
+			// Nope. Free any previously loaded talk
+			talk.freeTalkVars();
+
+			// Find the person being referred to
+			talk._talkTo = -1;
+			for (int idx = 0; idx < (int)people._characters.size(); ++idx) {
+				Common::String portrait = people._characters[idx]._portrait;
+				Common::String numStr(portrait.c_str(), portrait.c_str() + 4);
+
+				if (locStr == numStr) {
+					talk._talkTo = idx;
+					break;
+				}
+			}
+
+			// Load their talk file
+			talk.loadTalkFile(dirFilename);
+		}
+	}
+
+	if (talk[0]._statement.hasPrefix("*") || talk[0]._statement.hasPrefix("^"))
+		replyOnly = true;
+
+	// If this isn't the first journal entry, see if the previous journal entry
+	// was in the same scene to see if we need to include the scene header
+	int oldLocation = -1;
+	if (_index != 0) {
+		// Get the scene number of the prior journal entry
+		Common::String priorEntry = _directory[_journal[_index - 1]._converseNum];
+		oldLocation = atoi(Common::String(priorEntry.c_str() + 4, priorEntry.c_str() + 6).c_str());
+	}
+
+	// Start building journal string
+	Statement &statement = talk[journalEntry._statementNum];
+	Common::String journalString;
+
+	if (newLocation != oldLocation) {
+		// Add in scene title
+		journalString = "@";
+		if (IS_SERRATED_SCALPEL || newLocation - 1 < 100)
+			journalString += _locations[newLocation - 1];
+		journalString += ":";
+
+		// See if title can fit into a single line, or requires splitting on 2 lines
+		int width = screen.stringWidth(journalString.c_str() + 1);
+		if (width > JOURNAL_MAX_WIDTH) {
+			// Scan backwards from end of title to find a space between a word
+			// where the width is less than the maximum allowed for the line
+			const char *lineP = journalString.c_str() + journalString.size() - 1;
+			while (width > JOURNAL_MAX_WIDTH || *lineP != ' ')
+				width -= screen.charWidth(*lineP--);
+
+			// Split the header into two lines, and add a '@' prefix
+			// to the second line as well
+			journalString = Common::String(journalString.c_str(), lineP) + "\n@" +
+				Common::String(lineP + 1);
+		}
+
+		// Add a newline at the end of the title
+		journalString += '\n';
+	}
+
+	// If Holmes has something to say first, then take care of it
+	if (!replyOnly) {
+		// Handle the grammar
+		journalString += "Holmes ";
+		if (talk[journalEntry._statementNum]._statement.hasSuffix("?"))
+			journalString += "asked ";
+		else
+			journalString += "said to ";
+
+		if (talk._talkTo == 1) {
+			journalString += "me";
+		} else if ((talk._talkTo == 2 && IS_SERRATED_SCALPEL) || (talk._talkTo == 18 && IS_ROSE_TATTOO)) {
+			journalString += "the Inspector";
+		} else {
+			journalString += people._characters[talk._talkTo]._name;
+		}
+		journalString += ", \"";
+
+		// Add the statement
+		journalString += statement._statement;
+	}
+
+	// Handle including the reply
+	bool startOfReply = true;
+	bool ctrlSpace = false;
+	bool commentFlag = false;
+	bool commentJustPrinted = false;
+	const byte *replyP = (const byte *)statement._reply.c_str();
+	const int inspectorId = (IS_SERRATED_SCALPEL) ? 2 : 18;
+	int beforeLastSpeakerChange = journalString.size();
+	bool justChangedSpeaker = true;
+
+	while (*replyP) {
+		byte c = *replyP++;
+
+		if (IS_ROSE_TATTOO) {
+			// Ignore commented out data
+			if (c == '/' && *(replyP + 1) == '*') {
+				replyP++;	// skip *
+				while (*replyP++ != '*') {}	// empty loop on purpose
+				replyP++;	// skip /
+				c = *replyP;
+			}
+		}
+
+		// Is it a control character?
+		if (c < opcodes[0]) {
+			// Nope. Set flag for allowing control codes to insert spaces
+			ctrlSpace = true;
+			justChangedSpeaker = false;
+			assert(c >= ' ');
+
+			// Check for embedded comments
+			if (c == '{' || c == '}') {
+				// Comment characters. If we're starting a comment and there's
+				// already text displayed, add a closing quote
+				if (c == '{' && !startOfReply && !commentJustPrinted)
+					journalString += '"';
+
+				// If a reply isn't just being started, and we didn't just end
+				// a comment (which would have added a line), add a carriage return
+				if (!startOfReply && ((!commentJustPrinted && c == '{') || c == '}'))
+					journalString += '\n';
+				startOfReply = false;
+
+				// Handle setting or clearing comment state
+				if (c == '{') {
+					commentFlag = true;
+					commentJustPrinted = false;
+				} else {
+					commentFlag = false;
+					commentJustPrinted = true;
+				}
+			} else {
+				if (startOfReply) {
+					if (!replyOnly) {
+						journalString += "\"\n";
+
+						if (talk._talkTo == 1)
+							journalString += "I replied, \"";
+						else
+							journalString += "The reply was, \"";
+					} else {
+						if (talk._talkTo == 1)
+							journalString += "I";
+						else if (talk._talkTo == inspectorId)
+							journalString += "The Inspector";
+						else
+							journalString += people._characters[talk._talkTo]._name;
+
+						const byte *strP = replyP + 1;
+						byte v;
+						do {
+							v = *strP++;
+						} while (v && (v < opcodes[0]) && (v != '.') && (v != '!') && (v != '?'));
+
+						if (v == '?')
+							journalString += " asked, \"";
+						else
+							journalString += " said, \"";
+					}
+
+					startOfReply = false;
+				}
+
+				// Copy text from the place until either the reply ends, a comment
+				// {} block is started, or a control character is encountered
+				journalString += c;
+				while (*replyP && *replyP < opcodes[0] && *replyP != '{' && *replyP != '}') {
+					journalString += *replyP++;
+				}
+
+				commentJustPrinted = false;
+			}
+		} else if (c == opcodes[OP_SWITCH_SPEAKER]) {
+			if (IS_ROSE_TATTOO) {
+				// If the speaker has just changed, then no text has just been added
+				// from the last speaker, so remove the initial "Person said" text
+				if (justChangedSpeaker)
+					journalString = Common::String(journalString.c_str(), journalString.c_str() + beforeLastSpeakerChange);
+
+				justChangedSpeaker = true;
+			}
+
+			if (!startOfReply) {
+				if (!commentFlag && !commentJustPrinted)
+					journalString += "\"\n";
+
+				journalString += "Then ";
+				commentFlag = false;
+			} else if (!replyOnly) {
+				journalString += "\"\n";
+			}
+
+			startOfReply = false;
+			c = *replyP++ - 1;
+			if (IS_ROSE_TATTOO)
+				replyP++;
+
+			if (c == 0)
+				journalString += "Holmes";
+			else if (c == 1)
+				journalString += "I";
+			else if (c == inspectorId)
+				journalString += "the Inspector";
+			else
+				journalString += people._characters[c]._name;
+
+			if (IS_SERRATED_SCALPEL && _vm->getLanguage() == Common::DE_DEU)
+				Scalpel::ScalpelTalk::skipBadText(replyP);
+
+			const byte *strP = replyP;
+			byte v;
+			do {
+				v = *strP++;
+			} while (v && v < opcodes[0] && v != '.' && v != '!' && v != '?');
+
+			if (v == '?')
+				journalString += " asked, \"";
+			else
+				journalString += " said, \"";
+		} else {
+			if (IS_SERRATED_SCALPEL) {
+				// Control code, so move past it and any parameters
+				if (c == opcodes[OP_RUN_CANIMATION] ||
+					c == opcodes[OP_ASSIGN_PORTRAIT_LOCATION] ||
+					c == opcodes[OP_PAUSE] ||
+					c == opcodes[OP_PAUSE_WITHOUT_CONTROL] ||
+					c == opcodes[OP_WALK_TO_CANIMATION]) {
+					// These commands have a single parameter
+					++replyP;
+				} else if (c == opcodes[OP_ADJUST_OBJ_SEQUENCE]) {
+					replyP += (replyP[0] & 127) + replyP[1] + 2;
+				} else if (c == opcodes[OP_WALK_TO_COORDS] || c == opcodes[OP_MOVE_MOUSE]) {
+					replyP += 4;
+				} else if (c == opcodes[OP_SET_FLAG] || c == opcodes[OP_IF_STATEMENT]) {
+					replyP += 2;
+				} else if (c == opcodes[OP_SFX_COMMAND] || c == opcodes[OP_PLAY_PROLOGUE] ||
+					c == opcodes[OP_CALL_TALK_FILE]) {
+					replyP += 8;
+					break;
+				} else if (
+					c == opcodes[OP_TOGGLE_OBJECT] ||
+					c == opcodes[OP_ADD_ITEM_TO_INVENTORY] ||
+					c == opcodes[OP_SET_OBJECT] ||
+					c == opcodes[OP_DISPLAY_INFO_LINE] ||
+					c == opcodes[OP_REMOVE_ITEM_FROM_INVENTORY]) {
+					replyP += (*replyP & 127) + 1;
+				} else if (c == opcodes[OP_GOTO_SCENE]) {
+					replyP += 5;
+				} else if (c == opcodes[OP_END_TEXT_WINDOW]) {
+					journalString += "\n";
+				}
+			} else {
+				if (c == opcodes[OP_RUN_CANIMATION] ||
+					c == opcodes[OP_PAUSE] ||
+					c == opcodes[OP_MOUSE_OFF_ON] ||
+					c == opcodes[OP_SET_WALK_CONTROL] ||
+					c == opcodes[OP_PAUSE_WITHOUT_CONTROL] ||
+					c == opcodes[OP_WALK_TO_CANIMATION] ||
+					c == opcodes[OP_TURN_NPC_OFF] ||
+					c == opcodes[OP_TURN_NPC_ON] ||
+					c == opcodes[OP_RESTORE_PEOPLE_SEQUENCE])
+					++replyP;
+				else if (
+					c == opcodes[OP_SET_TALK_SEQUENCE] ||
+					c == opcodes[OP_SET_FLAG] ||
+					c == opcodes[OP_WALK_NPC_TO_CANIM] ||
+					c == opcodes[OP_WALK_HOLMES_AND_NPC_TO_CANIM] ||
+					c == opcodes[OP_NPC_PATH_LABEL] ||
+					c == opcodes[OP_PATH_GOTO_LABEL])
+					replyP += 2;
+				else if (
+					c == opcodes[OP_SET_NPC_PATH_PAUSE] ||
+					c == opcodes[OP_NPC_PATH_PAUSE_TAKING_NOTES] ||
+					c == opcodes[OP_NPC_PATH_PAUSE_LOOKING_HOLMES] ||
+					c == opcodes[OP_NPC_VERB_CANIM])
+					replyP += 3;
+				else if (
+					c == opcodes[OP_SET_SCENE_ENTRY_FLAG] ||
+					c == opcodes[OP_PATH_IF_FLAG_GOTO_LABEL])
+					replyP += 4;
+				else if (
+					c == opcodes[OP_WALK_TO_COORDS])
+					replyP += 5;
+				else if (
+					c == opcodes[OP_WALK_NPC_TO_COORDS] ||
+					c == opcodes[OP_GOTO_SCENE] ||
+					c == opcodes[OP_SET_NPC_PATH_DEST] ||
+					c == opcodes[OP_SET_NPC_POSITION])
+					replyP += 6;
+				else if (
+					c == opcodes[OP_PLAY_SONG] ||
+					c == opcodes[OP_NEXT_SONG])
+					replyP += 8;
+				else if (
+					c == opcodes[OP_CALL_TALK_FILE] ||
+					c == opcodes[OP_SET_NPC_TALK_FILE] ||
+					c == opcodes[OP_NPC_WALK_GRAPHICS])
+					replyP += 9;
+				else if (
+					c == opcodes[OP_NPC_VERB_SCRIPT])
+					replyP += 10;
+				else if (
+					c == opcodes[OP_WALK_HOLMES_AND_NPC_TO_COORDS])
+					replyP += 11;
+				else if (
+					c == opcodes[OP_NPC_VERB] ||
+					c == opcodes[OP_NPC_VERB_TARGET])
+					replyP += 14;
+				else if (
+					c == opcodes[OP_ADJUST_OBJ_SEQUENCE])
+					replyP += (replyP[0] & 127) + replyP[1] + 2;
+				else if (
+					c == opcodes[OP_TOGGLE_OBJECT] ||
+					c == opcodes[OP_ADD_ITEM_TO_INVENTORY] ||
+					c == opcodes[OP_SET_OBJECT] ||
+					c == opcodes[OP_REMOVE_ITEM_FROM_INVENTORY])
+					replyP += (*replyP & 127) + 1;
+				else if (
+					c == opcodes[OP_END_TEXT_WINDOW]) {
+					journalString += '\n';
+				} else if (
+					c == opcodes[OP_NPC_DESC_ON_OFF]) {
+					replyP++;
+					while (replyP[0] && replyP[0] != opcodes[OP_NPC_DESC_ON_OFF])
+						replyP++;
+				} else if (
+					c == opcodes[OP_SET_NPC_INFO_LINE])
+					replyP += replyP[1] + 2;
+			}
+
+			// Put a space in the output for a control character, unless it's
+			// immediately coming after another control character
+			if (ctrlSpace && c != opcodes[OP_ASSIGN_PORTRAIT_LOCATION] && c != opcodes[OP_END_TEXT_WINDOW] &&
+					!commentJustPrinted) {
+				journalString += " ";
+				ctrlSpace = false;
+			}
+		}
+	}
+
+	if (!startOfReply && !commentJustPrinted)
+		journalString += '"';
+
+	if (IS_ROSE_TATTOO && justChangedSpeaker)
+		journalString = Common::String(journalString.c_str(), journalString.c_str() + beforeLastSpeakerChange);
+
+	// Finally finished building the journal text. Need to process the text to
+	// word wrap it to fit on-screen. The resulting lines are stored in the
+	// _lines array
+	_lines.clear();
+
+	while (!journalString.empty()) {
+		const char *startP = journalString.c_str();
+
+		// If the first character is a '@' flagging a title line, then move
+		// past it, so the @ won't be included in the line width calculation
+		if (*startP == '@')
+			++startP;
+
+		// Build up chacters until a full line is found
+		int width = 0;
+		const char *endP = startP;
+		while (width < JOURNAL_MAX_WIDTH && *endP && *endP != '\n' && (endP - startP) < (JOURNAL_MAX_CHARS - 1))
+			width += screen.charWidth(*endP++);
+
+		// If word wrapping, move back to end of prior word
+		if (width >= JOURNAL_MAX_WIDTH || (endP - startP) >= (JOURNAL_MAX_CHARS - 1)) {
+			while (*--endP != ' ')
+				;
+		}
+
+		// Add in the line
+		_lines.push_back(Common::String(journalString.c_str(), endP));
+
+		// Strip line off from string being processed
+		journalString = *endP ? Common::String(endP + 1) : "";
+	}
+
+	// Add a blank line at the end of the text as long as text was present
+	if (!startOfReply) {
+		_lines.push_back("");
+	} else {
+		_lines.clear();
+	}
+}
+
+void Journal::record(int converseNum, int statementNum, bool replyOnly) {
+	int saveIndex = _index;
+	int saveSub = _sub;
+
+	if (IS_3DO) {
+		// there seems to be no journal in the 3DO version
+		return;
+	}
+
+	// Record the entry into the list
+	_journal.push_back(JournalEntry(converseNum, statementNum, replyOnly));
+	_index = _journal.size() - 1;
+
+	// Load the text for the new entry to get the number of lines it will have
+	loadJournalFile(true);
+
+	// Restore old state
+	_index = saveIndex;
+	_sub = saveSub;
+
+	// If new lines were added to the ournal, update the total number of lines
+	// the journal continues
+	if (!_lines.empty()) {
+		_maxPage += _lines.size();
+	} else {
+		// No lines in entry, so remove the new entry from the journal
+		_journal.remove_at(_journal.size() - 1);
+	}
+}
+
+
+void Journal::synchronize(Serializer &s) {
+	s.syncAsSint16LE(_index);
+	s.syncAsSint16LE(_sub);
+	s.syncAsSint16LE(_page);
+	s.syncAsSint16LE(_maxPage);
+
+	int journalCount = _journal.size();
+	s.syncAsUint16LE(journalCount);
+	if (s.isLoading())
+		_journal.resize(journalCount);
+
+	for (uint idx = 0; idx < _journal.size(); ++idx) {
+		JournalEntry &je = _journal[idx];
+
+		s.syncAsSint16LE(je._converseNum);
+		s.syncAsByte(je._replyOnly);
+		s.syncAsSint16LE(je._statementNum);
+	}
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/journal.h b/engines/sherlock/journal.h
new file mode 100644
index 0000000000..a8fec104f4
--- /dev/null
+++ b/engines/sherlock/journal.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 SHERLOCK_JOURNAL_H
+#define SHERLOCK_JOURNAL_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/rect.h"
+#include "common/str-array.h"
+#include "common/stream.h"
+#include "sherlock/saveload.h"
+
+namespace Sherlock {
+
+#define LINES_PER_PAGE (IS_SERRATED_SCALPEL ? 11 : 17)
+#define JOURNAL_MAX_WIDTH (IS_SERRATED_SCALPEL ? 230 : 422)
+#define JOURNAL_MAX_CHARS 80
+#define JOURNAL_LEFT_X (IS_SERRATED_SCALPEL ? 53 : 156)
+
+class SherlockEngine;
+
+struct JournalEntry {
+	int _converseNum;
+	bool _replyOnly;
+	int _statementNum;
+
+	JournalEntry() : _converseNum(0), _replyOnly(false), _statementNum(0) {}
+	JournalEntry(int converseNum, int statementNum, bool replyOnly = false) :
+		_converseNum(converseNum), _statementNum(statementNum), _replyOnly(replyOnly) {}
+};
+
+class Journal {
+protected:
+	SherlockEngine *_vm;
+	Common::StringArray _directory;
+	Common::StringArray _locations;
+	Common::Array<JournalEntry> _journal;
+	Common::StringArray _lines;
+	bool _up, _down;
+	int _index;
+	int _page;
+	int _maxPage;
+	int _sub;
+	Common::String _find;
+
+	Journal(SherlockEngine *vm);
+
+	/**
+	 * Loads the description for the current display index in the journal, and then
+	 * word wraps the result to prepare it for being displayed
+	 * @param alreadyLoaded		Indicates whether the journal file is being loaded for the
+	 *		first time, or being reloaded
+	 */
+	void loadJournalFile(bool alreadyLoaded);
+public:
+	static Journal *init(SherlockEngine *vm);
+	virtual ~Journal() {}
+
+	/**
+	* Displays a page of the journal at the current index
+	*/
+	bool drawJournal(int direction, int howFar);
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	void synchronize(Serializer &s);
+public:
+	/**
+	 * Draw the journal background, frame, and interface buttons
+	 */
+	virtual void drawFrame() = 0;
+
+	/**
+	 * Reset viewing position to the start of the journal
+	 */
+	virtual void resetPosition() {}
+
+	/**
+	 * Records statements that are said, in the order which they are said. The player
+	 * can then read the journal to review them
+	 */
+	virtual void record(int converseNum, int statementNum, bool replyOnly = false);
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/map.cpp b/engines/sherlock/map.cpp
new file mode 100644
index 0000000000..fbccaf244f
--- /dev/null
+++ b/engines/sherlock/map.cpp
@@ -0,0 +1,52 @@
+/* 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 "sherlock/map.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/scalpel/scalpel_map.h"
+#include "sherlock/tattoo/tattoo_map.h"
+
+namespace Sherlock {
+
+Map *Map::init(SherlockEngine *vm) {
+	if (vm->getGameID() == GType_SerratedScalpel)
+		return new Scalpel::ScalpelMap(vm);
+	else
+		return new Tattoo::TattooMap(vm);
+}
+
+Map::Map(SherlockEngine *vm) : _vm(vm) {
+	_charPoint = _oldCharPoint = 0;
+	_active = _frameChangeFlag = false;
+}
+
+void Map::synchronize(Serializer &s) {
+	s.syncAsSint32LE(_bigPos.x);
+	s.syncAsSint32LE(_bigPos.y);
+	s.syncAsSint32LE(_overPos.x);
+	s.syncAsSint16LE(_overPos.y);
+	s.syncAsSint16LE(_oldCharPoint);
+}
+
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/map.h b/engines/sherlock/map.h
new file mode 100644
index 0000000000..104f5e9c8a
--- /dev/null
+++ b/engines/sherlock/map.h
@@ -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.
+ *
+ */
+
+#ifndef SHERLOCK_MAP_H
+#define SHERLOCK_MAP_H
+
+#include "sherlock/objects.h"
+#include "sherlock/saveload.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+class Map {
+protected:
+	SherlockEngine *_vm;
+
+	Map(SherlockEngine *vm);
+public:
+	Point32 _overPos;
+	Point32 _bigPos;
+	int _charPoint, _oldCharPoint;
+	bool _active;
+	bool _frameChangeFlag;
+public:
+	static Map *init(SherlockEngine *vm);
+	virtual ~Map() {}
+
+	/**
+	 * Show the map
+	 */
+	virtual int show() = 0;
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	void synchronize(Serializer &s);
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/module.mk b/engines/sherlock/module.mk
new file mode 100644
index 0000000000..7fa7896691
--- /dev/null
+++ b/engines/sherlock/module.mk
@@ -0,0 +1,77 @@
+MODULE := engines/sherlock
+
+MODULE_OBJS = \
+	scalpel/scalpel.o \
+	scalpel/3do/movie_decoder.o \
+	scalpel/drivers/adlib.o \
+	scalpel/drivers/mt32.o \
+	scalpel/tsage/logo.o \
+	scalpel/tsage/resources.o \
+	scalpel/scalpel_darts.o \
+	scalpel/scalpel_debugger.o \
+	scalpel/scalpel_fixed_text.o \
+	scalpel/scalpel_inventory.o \
+	scalpel/scalpel_journal.o \
+	scalpel/scalpel_map.o \
+	scalpel/scalpel_people.o \
+	scalpel/scalpel_saveload.o \
+	scalpel/scalpel_scene.o \
+	scalpel/scalpel_screen.o \
+	scalpel/scalpel_talk.o \
+	scalpel/scalpel_user_interface.o \
+	scalpel/settings.o \
+	tattoo/tattoo.o \
+	tattoo/tattoo_darts.o \
+	tattoo/tattoo_debugger.o \
+	tattoo/tattoo_fixed_text.o \
+	tattoo/tattoo_inventory.o \
+	tattoo/tattoo_journal.o \
+	tattoo/tattoo_map.o \
+	tattoo/tattoo_people.o \
+	tattoo/tattoo_resources.o \
+	tattoo/tattoo_scene.o \
+	tattoo/tattoo_talk.o \
+	tattoo/tattoo_user_interface.o \
+	tattoo/widget_base.o \
+	tattoo/widget_credits.o \
+	tattoo/widget_files.o \
+	tattoo/widget_foolscap.o \
+	tattoo/widget_inventory.o \
+	tattoo/widget_lab.o \
+	tattoo/widget_options.o \
+	tattoo/widget_password.o \
+	tattoo/widget_quit.o \
+	tattoo/widget_talk.o \
+	tattoo/widget_text.o \
+	tattoo/widget_tooltip.o \
+	tattoo/widget_verbs.o \
+	animation.o \
+	debugger.o \
+	detection.o \
+	events.o \
+	fixed_text.o \
+	fonts.o \
+	image_file.o \
+	inventory.o \
+	journal.o \
+	map.o \
+	music.o \
+	objects.o \
+	people.o \
+	resources.o \
+	saveload.o \
+	scene.o \
+	screen.o \
+	sherlock.o \
+	sound.o \
+	surface.o \
+	talk.o \
+	user_interface.o
+
+# This module can be built as a plugin
+ifeq ($(ENABLE_SHERLOCK), DYNAMIC_PLUGIN)
+PLUGIN := 1
+endif
+
+# Include common rules
+include $(srcdir)/rules.mk
diff --git a/engines/sherlock/music.cpp b/engines/sherlock/music.cpp
new file mode 100644
index 0000000000..8b8f359de3
--- /dev/null
+++ b/engines/sherlock/music.cpp
@@ -0,0 +1,626 @@
+/* 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/algorithm.h"
+#include "common/config-manager.h"
+#include "common/mutex.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/music.h"
+#include "sherlock/scalpel/drivers/mididriver.h"
+// for Miles Audio (Sherlock Holmes 2)
+#include "audio/miles.h"
+// for 3DO digital music
+#include "audio/decoders/aiff.h"
+
+namespace Sherlock {
+
+#define NUM_SONGS 45
+
+/* This tells which song to play in each room, 0 = no song played */
+static const char ROOM_SONG[62] = {
+	 0, 20, 43,  6, 11,  2,  8, 15,  6, 28,
+	 6, 38,  7, 32, 16,  5,  8, 41,  9, 22,
+	10, 23,  4, 39, 19, 24, 13, 27,  0, 30,
+	 3, 21, 26, 25, 16, 29,  1,  1, 18, 12,
+	 1, 17, 17, 31, 17, 34, 36,  7, 20, 20,
+	33,  8, 44, 40, 42, 35,  0,  0,  0, 12,
+	12
+};
+
+static const char *const SONG_NAMES[NUM_SONGS] = {
+	"SINGERF",  "CHEMIST",  "TOBAC",   "EQUEST",  "MORTUARY", "DOCKS",    "LSTUDY",
+	"LORD",     "BOY",      "PERFUM1", "BAKER1",  "BAKER2",   "OPERA1",   "HOLMES",
+	"FFLAT",    "OP1FLAT",  "ZOO",     "SROOM",   "FLOWERS",  "YARD",     "TAXID",
+	"PUB1",     "VICTIM",   "RUGBY",   "DORM",    "SHERMAN",  "LAWYER",   "THEATRE",
+	"DETECT",   "OPERA4",   "POOL",    "SOOTH",   "ANNA1",    "ANNA2",    "PROLOG3",
+	"PAWNSHOP", "MUSICBOX", "MOZART1", "ROBHUNT", "PANCRAS1", "PANCRAS2", "LORDKILL",
+	"BLACKWEL", "RESCUE",   "MAP"
+};
+
+MidiParser_SH::MidiParser_SH() {
+	_ppqn = 1;
+	setTempo(16667);
+	_data = nullptr;
+	_beats = 0;
+	_lastEvent = 0;
+	_trackEnd = nullptr;
+
+	_musData     = nullptr;
+	_musDataSize = 0;
+}
+
+MidiParser_SH::~MidiParser_SH() {
+	Common::StackLock lock(_mutex);
+	unloadMusic();
+	_driver = NULL;
+}
+
+void MidiParser_SH::parseNextEvent(EventInfo &info) {
+	Common::StackLock lock(_mutex);
+
+//	warning("parseNextEvent");
+
+	// there is no delta right at the start of the music data
+	// this order is essential, otherwise notes will get delayed or even go missing
+	if (_position._playPos != _tracks[0]) {
+		info.delta = *(_position._playPos++);
+	} else {
+		info.delta = 0;
+	}
+
+	info.start = _position._playPos;
+
+	info.event = *_position._playPos++;
+	//warning("Event %x", info.event);
+	_position._runningStatus = info.event;
+
+	switch (info.command()) {
+	case 0xC: { // program change
+		int idx = *_position._playPos++;
+		info.basic.param1 = idx & 0x7f;
+		info.basic.param2 = 0;
+		}
+		break;
+	case 0xD:
+		info.basic.param1 = *_position._playPos++;
+		info.basic.param2 = 0;
+		break;
+
+	case 0xB:
+		info.basic.param1 = *_position._playPos++;
+		info.basic.param2 = *_position._playPos++;
+		info.length = 0;
+		break;
+
+	case 0x8:
+	case 0x9:
+	case 0xA:
+	case 0xE:
+		info.basic.param1 = *(_position._playPos++);
+		info.basic.param2 = *(_position._playPos++);
+		if (info.command() == 0x9 && info.basic.param2 == 0) {
+			// NoteOn with param2==0 is a NoteOff
+			info.event = info.channel() | 0x80;
+		}
+		info.length = 0;
+		break;
+	case 0xF:
+		if (info.event == 0xFF) {
+			error("SysEx META event 0xFF");
+
+			byte type = *(_position._playPos++);
+			switch(type) {
+			case 0x2F:
+				// End of Track
+				allNotesOff();
+				stopPlaying();
+				unloadMusic();
+				return;
+			case 0x51:
+				warning("TODO: 0xFF / 0x51");
+				return;
+			default:
+				warning("TODO: 0xFF / %x Unknown", type);
+				break;
+			}
+		} else if (info.event == 0xFC) {
+			// Official End-Of-Track signal
+			debugC(kDebugLevelMusic, "Music: System META event 0xFC");
+
+			byte type = *(_position._playPos++);
+			switch (type) {
+			case 0x80: // end of track, triggers looping
+				debugC(kDebugLevelMusic, "Music: META event triggered looping");
+				jumpToTick(0, true, true, false);
+				break;
+			case 0x81: // end of track, stop playing
+				debugC(kDebugLevelMusic, "Music: META event triggered music stop");
+				stopPlaying();
+				unloadMusic();
+				break;
+			default:
+				error("MidiParser_SH::parseNextEvent: Unknown META event 0xFC type %x", type);
+				break;
+			}
+		} else {
+			warning("TODO: %x / Unknown", info.event);
+			break;
+		}
+		break;
+	default:
+		warning("MidiParser_SH::parseNextEvent: Unsupported event code %x", info.event);
+		break;
+	}// switch (info.command())
+}
+
+bool MidiParser_SH::loadMusic(byte *musData, uint32 musDataSize) {
+	Common::StackLock lock(_mutex);
+
+	debugC(kDebugLevelMusic, "Music: loadMusic()");
+	unloadMusic();
+
+	_musData     = musData;
+	_musDataSize = musDataSize;
+
+	byte  *headerPtr = _musData + 12; // skip over the already checked SPACE header
+	byte  *pos       = headerPtr;
+
+	uint16 headerSize = READ_LE_UINT16(headerPtr);
+	assert(headerSize == 0x7F); // Security check
+
+	// Skip over header
+	pos += headerSize;
+
+	_lastEvent = 0;
+	_trackEnd = _musData + _musDataSize;
+
+	_numTracks = 1;
+	_tracks[0] = pos;
+	
+	_ppqn = 1;
+	setTempo(16667);
+	setTrack(0);
+
+	return true;
+}
+
+void MidiParser_SH::unloadMusic() {
+	Common::StackLock lock(_mutex);
+
+	if (_musData) {
+		delete[] _musData;
+		_musData = NULL;
+		_musDataSize = 0;
+	}
+
+	MidiParser::unloadMusic();
+}
+
+/*----------------------------------------------------------------*/
+
+Music::Music(SherlockEngine *vm, Audio::Mixer *mixer) : _vm(vm), _mixer(mixer) {
+	_midiDriver = NULL;
+	_midiParser = NULL;
+	_musicType = MT_NULL;
+	_musicPlaying = false;
+	_musicOn = false;
+	_midiOption = false;
+	_musicVolume = 0;
+	_midiMusicData = nullptr;
+
+	if (IS_3DO) {
+		// 3DO - uses digital samples for music
+		_musicOn = true;
+		return;
+	}
+
+	if (_vm->_interactiveFl)
+		_vm->_res->addToCache("MUSIC.LIB");
+
+	MidiDriver::DeviceHandle dev;
+
+	if (IS_SERRATED_SCALPEL) {
+		// Serrated Scalpel: used an internal Electronic Arts .MUS music engine
+		_midiParser = new MidiParser_SH();
+		dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_MT32);
+		_musicType = MidiDriver::getMusicType(dev);
+
+		switch (_musicType) {
+		case MT_ADLIB:
+			_midiDriver = MidiDriver_SH_AdLib_create();
+			break;
+		case MT_MT32:
+			_midiDriver = MidiDriver_MT32_create();
+			break;
+		case MT_GM:
+			if (ConfMan.getBool("native_mt32")) {
+				_midiDriver = MidiDriver_MT32_create();
+				_musicType = MT_MT32;
+			}
+			break;
+		default:
+			// Create default one
+			// I guess we shouldn't do this anymore
+			//_midiDriver = MidiDriver::createMidi(dev);
+			break;
+		}
+	} else {
+		// Rose Tattooo: seems to use Miles Audio 3
+		_midiParser = MidiParser::createParser_XMIDI();
+		dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_GM);
+		_musicType = MidiDriver::getMusicType(dev);
+
+		switch (_musicType) {
+		case MT_ADLIB:
+			// SAMPLE.AD  -> regular AdLib instrument data
+			// SAMPLE.OPL -> OPL-3 instrument data
+			// although in case of Rose Tattoo both files are exactly the same
+			_midiDriver = Audio::MidiDriver_Miles_AdLib_create("SAMPLE.AD", "SAMPLE.OPL");
+			break;
+		case MT_MT32:
+			// Sherlock Holmes 2 does not have a MT32 timbre file
+			_midiDriver = Audio::MidiDriver_Miles_MT32_create("");
+			break;
+		case MT_GM:
+			if (ConfMan.getBool("native_mt32")) {
+				_midiDriver = Audio::MidiDriver_Miles_MT32_create("");
+				_musicType = MT_MT32;
+			} else {
+				_midiDriver = MidiDriver::createMidi(dev);
+				_musicType = MT_GM;
+			}
+			break;
+		default:
+			// Do not create anything
+			break;
+		}
+	}
+
+	if (_midiDriver) {
+		int ret = _midiDriver->open();
+		if (ret == 0) {
+			// Reset is done inside our MIDI driver
+			_midiDriver->setTimerCallback(_midiParser, &_midiParser->timerCallback);
+		}
+		_midiParser->setMidiDriver(_midiDriver);
+		_midiParser->setTimerRate(_midiDriver->getBaseTempo());
+
+		if (IS_SERRATED_SCALPEL) {
+			if (_musicType == MT_MT32) {
+				// Upload patches
+				Common::SeekableReadStream *MT32driverStream = _vm->_res->load("MTHOM.DRV", "MUSIC.LIB");
+
+				if (!MT32driverStream)
+					error("Music: could not load MTHOM.DRV, critical");
+
+				byte *MT32driverData = new byte[MT32driverStream->size()];
+				int32 MT32driverDataSize = MT32driverStream->size();
+				assert(MT32driverData);
+
+				MT32driverStream->read(MT32driverData, MT32driverDataSize);
+				delete MT32driverStream;
+
+				assert(MT32driverDataSize > 12);
+				byte *MT32driverDataPtr = MT32driverData + 12;
+				MT32driverDataSize -= 12;
+
+				MidiDriver_MT32_uploadPatches(_midiDriver, MT32driverDataPtr, MT32driverDataSize);
+				delete[] MT32driverData;
+			}
+		}
+
+		_musicOn = true;
+	}
+}
+
+Music::~Music() {
+	stopMusic();
+	if (_midiDriver) {
+		_midiDriver->setTimerCallback(this, NULL);
+	}
+	if (_midiParser) {
+		_midiParser->stopPlaying();
+		delete _midiParser;
+		_midiParser = nullptr;
+	}
+	if (_midiDriver) {
+		_midiDriver->close();
+		delete _midiDriver;
+	}
+}
+
+bool Music::loadSong(int songNumber) {
+	debugC(kDebugLevelMusic, "Music: loadSong()");
+
+	if(songNumber == 100)
+		songNumber = 55;
+	else if(songNumber == 70)
+		songNumber = 54;
+
+	if((songNumber > 60) || (songNumber < 1))
+		return false;
+
+	songNumber = ROOM_SONG[songNumber];
+
+	if(songNumber == 0)
+		songNumber = 12;
+
+	if((songNumber > NUM_SONGS) || (songNumber < 1))
+		return false;
+
+	Common::String songName = Common::String(SONG_NAMES[songNumber - 1]);
+
+	freeSong();  // free any song that is currently loaded
+	stopMusic();
+
+	if (!playMusic(songName))
+		return false;
+
+	startSong();
+	return true;
+}
+
+bool Music::loadSong(const Common::String &songName) {
+	freeSong();  // free any song that is currently loaded
+	stopMusic();
+
+	if (!playMusic(songName))
+		return false;
+
+	startSong();
+	return true;
+}
+
+void Music::syncMusicSettings() {
+	_musicOn = !ConfMan.getBool("mute") && !ConfMan.getBool("music_mute");
+}
+
+bool Music::playMusic(const Common::String &name) {
+	if (!_musicOn)
+		return false;
+
+	_nextSongName = _currentSongName = name;
+	debugC(kDebugLevelMusic, "Music: playMusic('%s')", name.c_str());
+
+	if (!IS_3DO) {
+		// MIDI based
+		if (!_midiDriver)
+			return false;
+
+		Common::String midiMusicName = (IS_SERRATED_SCALPEL) ? name + ".MUS" : name + ".XMI";
+		Common::SeekableReadStream *stream = _vm->_res->load(midiMusicName, "MUSIC.LIB");
+
+		byte *midiMusicData     = new byte[stream->size()];
+		int32 midiMusicDataSize = stream->size();
+
+		stream->read(midiMusicData, midiMusicDataSize);
+		delete stream;
+
+		if (midiMusicDataSize < 14) {
+			warning("Music: not enough data in music file");
+			delete[] midiMusicData;
+			return false;
+		}
+
+		byte  *dataPos  = midiMusicData;
+		uint32 dataSize = midiMusicDataSize;
+
+		if (IS_SERRATED_SCALPEL) {
+			if (memcmp("            ", dataPos, 12)) {
+				warning("Music: expected header not found in music file");
+				delete[] midiMusicData;
+				return false;
+			}
+			dataPos += 12;
+			dataSize -= 12;
+
+			if (dataSize < 0x7F) {
+				warning("Music: expected music header not found in music file");
+				delete[] midiMusicData;
+				return false;
+			}
+
+			uint16 headerSize = READ_LE_UINT16(dataPos);
+			if (headerSize != 0x7F) {
+				warning("Music: header is not as expected");
+				delete[] midiMusicData;
+				return false;
+			}
+		} else {
+			if (memcmp("FORM", dataPos, 4)) {
+				warning("Music: expected header not found in music file");
+				delete[] midiMusicData;
+				return false;
+			}
+		}
+
+		if (IS_SERRATED_SCALPEL) {
+			// Pass the music data to the driver as well
+			// because channel mapping and a few other things inside the header
+			switch (_musicType) {
+			case MT_ADLIB:
+				MidiDriver_SH_AdLib_newMusicData(_midiDriver, dataPos, dataSize);
+				break;
+
+			case MT_MT32:
+				MidiDriver_MT32_newMusicData(_midiDriver, dataPos, dataSize);
+				break;
+
+			default:
+				// should never happen
+				break;
+			}
+		}
+
+		_midiMusicData = midiMusicData;
+		_midiParser->loadMusic(midiMusicData, midiMusicDataSize);
+	} else {
+		// 3DO: sample based
+		Audio::AudioStream *musicStream;
+		Common::String digitalMusicName = "music/" + name + "_MW22.aifc";
+
+		if (isPlaying()) {
+			_mixer->stopHandle(_digitalMusicHandle);
+		}
+
+		Common::File *digitalMusicFile = new Common::File();
+		if (!digitalMusicFile->open(digitalMusicName)) {
+			warning("playMusic: can not open 3DO music '%s'", digitalMusicName.c_str());
+			return false;
+		}
+
+		// Try to load the given file as AIFF/AIFC
+		musicStream = Audio::makeAIFFStream(digitalMusicFile, DisposeAfterUse::YES);
+		if (!musicStream) {
+			warning("playMusic: can not load 3DO music '%s'", digitalMusicName.c_str());
+			return false;
+		}
+		_mixer->playStream(Audio::Mixer::kMusicSoundType, &_digitalMusicHandle, musicStream);
+	}
+
+	_musicPlaying = true;
+	return true;
+}
+
+void Music::stopMusic() {
+	freeSong();
+}
+
+void Music::startSong() {
+	// No implementation needed for ScummVM
+}
+
+void Music::freeSong() {
+	if (!IS_3DO) {
+		if (_midiParser->isPlaying())
+			_midiParser->stopPlaying();
+
+		// Free the MIDI MUS data buffer
+		_midiParser->unloadMusic();
+	}
+
+	delete[] _midiMusicData;
+	_midiMusicData = nullptr;
+	_musicPlaying = false;
+}
+
+bool Music::isPlaying() {
+	if (!IS_3DO) {
+		// MIDI based
+		return _midiParser->isPlaying();
+	} else {
+		// 3DO: sample based
+		return _mixer->isSoundHandleActive(_digitalMusicHandle);
+	}
+}
+
+// Returns the current music position in milliseconds
+uint32 Music::getCurrentPosition() {
+	if (!IS_3DO) {
+		// MIDI based
+		return (_midiParser->getTick() * 1000) / 60; // translate tick to millisecond
+	} else {
+		// 3DO: sample based
+		return _mixer->getSoundElapsedTime(_digitalMusicHandle);
+	}
+}
+
+// This is used to wait for the music in certain situations like especially the intro
+// Note: the original game didn't do this, instead it just waited for certain amounts of time
+//       We do this, so that the intro graphics + music work together even on faster/slower hardware.
+bool Music::waitUntilMSec(uint32 msecTarget, uint32 msecMax, uint32 additionalDelay, uint32 noMusicDelay) {
+	uint32 msecCurrent = 0;
+
+	if (!isPlaying()) {
+		return _vm->_events->delay(noMusicDelay, true);
+	}
+	while (1) {
+		if (!isPlaying()) { // Music is not playing anymore -> we are done
+			if (additionalDelay > 0) {
+				if (!_vm->_events->delay(additionalDelay, true))
+					return false;
+			}
+			return true;
+		}
+
+		msecCurrent = getCurrentPosition();
+		//warning("waitUntilMSec: %lx", msecCurrent);
+
+		if ((!msecMax) || (msecCurrent <= msecMax)) {
+			if (msecCurrent >= msecTarget) {
+				if (additionalDelay > 0) {
+					if (!_vm->_events->delay(additionalDelay, true))
+						return false;
+				}
+				return true;
+			}
+		}
+		if (!_vm->_events->delay(10, true))
+			return false;
+	}
+}
+
+void Music::setMusicVolume(int volume) {
+	_musicVolume = volume;
+	_vm->_mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, volume);
+}
+
+void Music::getSongNames(Common::StringArray &songs) {
+	songs.clear();
+	if (IS_SERRATED_SCALPEL) {
+		if (IS_3DO) {
+			Common::FSDirectory gameDirectory(ConfMan.get("path"));
+			Common::FSDirectory *musicDirectory = gameDirectory.getSubDirectory("music");
+			Common::ArchiveMemberList files;
+
+			musicDirectory->listMatchingMembers(files, "*_mw22.aifc");
+
+			for (Common::ArchiveMemberList::iterator i = files.begin(); i != files.end(); ++i) {
+				Common::String name = (*i)->getName();
+				name.erase(name.size() - 10);
+				songs.push_back(name);
+			}
+		} else {
+			for (int i = 0; i < ARRAYSIZE(SONG_NAMES); i++) {
+				songs.push_back(SONG_NAMES[i]);
+			}
+		}
+	} else {
+		Common::StringArray fileList;
+		_vm->_res->getResourceNames("music.lib", fileList);
+		for (Common::StringArray::iterator i = fileList.begin(); i != fileList.end(); ++i) {
+			if ((*i).matchString("*.XMI", true)) {
+				(*i).erase((*i).size() - 4);
+				songs.push_back(*i);
+			}
+		}
+	}
+	Common::sort(songs.begin(), songs.end());
+}
+
+void Music::checkSongProgress() {
+	if (!isPlaying()) {
+		playMusic(_nextSongName);
+	}
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/music.h b/engines/sherlock/music.h
new file mode 100644
index 0000000000..186e2aa2dc
--- /dev/null
+++ b/engines/sherlock/music.h
@@ -0,0 +1,141 @@
+/* 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 SHERLOCK_MUSIC_H
+#define SHERLOCK_MUSIC_H
+
+#include "audio/midiplayer.h"
+#include "audio/midiparser.h"
+//#include "audio/mididrv.h"
+#include "sherlock/scalpel/drivers/mididriver.h"
+// for 3DO digital music
+#include "audio/audiostream.h"
+#include "audio/mixer.h"
+#include "common/mutex.h"
+#include "common/str-array.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+class MidiParser_SH : public MidiParser {
+public:
+	MidiParser_SH();
+	~MidiParser_SH();
+
+protected:
+	Common::Mutex _mutex;
+	void parseNextEvent(EventInfo &info);
+
+	uint8 _beats;
+	uint8 _lastEvent;
+	byte *_data;
+	byte *_trackEnd;
+
+public:
+	bool loadMusic(byte *musData, uint32 musSize);
+	virtual void unloadMusic();
+
+private:
+	byte  *_musData;
+	uint32 _musDataSize;
+};
+
+class Music {
+private:
+	SherlockEngine *_vm;
+	Audio::Mixer *_mixer;
+	MidiParser *_midiParser;
+	MidiDriver *_midiDriver;
+	Audio::SoundHandle _digitalMusicHandle;
+	MusicType _musicType;
+	byte *_midiMusicData;
+	
+	/**
+	 * Play the specified music resource
+	 */
+	bool playMusic(const Common::String &name);
+public:
+	bool _musicPlaying;
+	bool _musicOn;
+	int _musicVolume;
+	bool _midiOption;
+	Common::String _currentSongName, _nextSongName;
+public:
+	Music(SherlockEngine *vm, Audio::Mixer *mixer);
+	~Music();
+
+	/**
+	 * Saves sound-related settings
+	 */
+	void syncMusicSettings();
+
+	/**
+	 * Load a specified song
+	 */
+	bool loadSong(int songNumber);
+
+	/**
+	 * Load a specified song
+	 */
+	bool loadSong(const Common::String &songName);
+
+	/**
+	 * Start playing a song
+	 */
+	void startSong();
+	
+	/**
+	 * Free any currently loaded song
+	 */
+	void freeSong();
+
+	/**
+	 * Stop playing the music
+	 */
+	void stopMusic();
+	
+	bool isPlaying();
+	uint32 getCurrentPosition();
+
+	bool waitUntilMSec(uint32 msecTarget, uint32 maxMSec, uint32 additionalDelay, uint32 noMusicDelay);
+
+	/**
+	 * Sets the volume of the MIDI music with a value ranging from 0 to 127
+	 */
+	void setMusicVolume(int volume);
+
+	/**
+	 * Gets the names of all the songs in the game. Used by the debugger.
+	 */
+	void getSongNames(Common::StringArray &songs);
+
+	/**
+	 * Checks to see if the currently playing song has finished, then the music specified
+	 * in _nextSongName will be started
+	 */
+	void checkSongProgress();
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/objects.cpp b/engines/sherlock/objects.cpp
new file mode 100644
index 0000000000..0856c226f1
--- /dev/null
+++ b/engines/sherlock/objects.cpp
@@ -0,0 +1,1562 @@
+/* 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/util.h"
+#include "sherlock/objects.h"
+#include "sherlock/people.h"
+#include "sherlock/scene.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/scalpel/scalpel_map.h"
+#include "sherlock/scalpel/scalpel_people.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+#define START_FRAME 0
+
+#define NUM_ADJUSTED_WALKS 21
+
+// Distance to walk around WALK_AROUND boxes
+#define CLEAR_DIST_X 5
+#define CLEAR_DIST_Y 0
+
+#define ADJUST_COORD(COORD) \
+	if (COORD.x != -1) \
+		COORD.x *= FIXED_INT_MULTIPLIER; \
+	if (COORD.y != -1) \
+		COORD.y *= FIXED_INT_MULTIPLIER
+
+SherlockEngine *BaseObject::_vm;
+bool BaseObject::_countCAnimFrames;
+
+/*----------------------------------------------------------------*/
+
+void BaseObject::setVm(SherlockEngine *vm) {
+	_vm = vm;
+	_countCAnimFrames = false;
+}
+
+BaseObject::BaseObject() {
+	_type = INVALID;
+	_sequences = nullptr;
+	_images = nullptr;
+	_imageFrame = nullptr;
+	_sequenceNumber = 0;
+	_startSeq = 0;
+	_walkCount = 0;
+	_allow = 0;
+	_frameNumber = 0;
+	_lookFlag = 0;
+	_requiredFlag[0] = _requiredFlag[1] = 0;
+	_status = 0;
+	_misc = 0;
+	_maxFrames = 0;
+	_flags = 0;
+	_aType = OBJECT;
+	_lookFrames = 0;
+	_seqCounter = 0;
+	_lookcAnim = 0;
+	_seqStack = 0;
+	_seqTo = 0;
+	_descOffset = 0;
+	_seqCounter2 = 0;
+	_seqSize = 0;
+	_quickDraw = 0;
+	_scaleVal = 0;
+	_gotoSeq = 0;
+	_talkSeq = 0;
+	_restoreSlot = 0;
+}
+
+bool BaseObject::hasAborts() const {
+	int seqNum = _talkSeq;
+
+	// See if the object is in its regular sequence
+	bool startChecking = !seqNum || _type == CHARACTER;
+
+	uint idx = 0;
+	do
+	{
+		// Get the Frame value
+		int v = _sequences[idx++];
+
+		// See if we found an Allow Talk Interrupt Code
+		if (startChecking && v == ALLOW_TALK_CODE)
+			return true;
+
+		// If we've started checking and we've encountered another Talk or Listen Sequence Code,
+		// then we're done checking this sequence because this is where it would repeat
+		if (startChecking && (v == TALK_SEQ_CODE || v == TALK_LISTEN_CODE))
+			break;
+
+		// See if we've found the beginning of a Talk Sequence
+		if ((v == TALK_SEQ_CODE && seqNum < 128) || (v == TALK_LISTEN_CODE && seqNum >= 128)) {
+			// If checking was already on and we came across one of these codes, then there couldn't
+			// have been an Allow Talk Interrupt code in the sequence we were checking, so we're done.
+			if (startChecking)
+				break;
+
+			seqNum--;
+			// See if we're at the correct Talk Sequence Number
+			if (!(seqNum & 127))
+			{
+				// Correct Sequence, Start Checking Now
+				startChecking = true;
+			}
+		} else {
+			// Move ahead any extra because of special control codes
+			switch (v) {
+			case 0:				idx++; break;
+			case MOVE_CODE:
+			case TELEPORT_CODE:	idx += 4; break;
+			case CALL_TALK_CODE:idx += 8; break;
+			case HIDE_CODE:		idx += 2; break;
+			}
+		}
+	} while (idx < _seqSize);
+
+	return false;
+}
+
+void BaseObject::checkObject() {
+	Scene &scene = *_vm->_scene;
+	Sound &sound = *_vm->_sound;
+	Talk &talk = *_vm->_talk;
+	int checkFrame = _allow ? MAX_FRAME : FRAMES_END;
+	bool codeFound;
+
+	if (_seqTo) {
+		byte *ptr = &_sequences[_frameNumber];
+		if (*ptr == _seqTo) {
+			// The sequence is completed. Reset to normal
+			*ptr = _seqTo + (IS_ROSE_TATTOO ? 0 : SEQ_TO_CODE + 128);
+			_seqTo = 0;
+		} else {
+			// Continue doing sequence
+			if (*ptr > _seqTo)
+				*ptr -= 1;
+			else
+				*ptr += 1;
+
+			return;
+		}
+	}
+
+	++_frameNumber;
+
+	do {
+		if (!_sequences) {
+			warning("checkObject: _sequences is not set");
+			break;
+		}
+
+		// Check for end of sequence
+		codeFound = checkEndOfSequence();
+
+		if (_sequences[_frameNumber] >= 128 && _frameNumber < checkFrame) {
+			codeFound = true;
+			int v = _sequences[_frameNumber];
+
+			// Check for a Talk or Listen Sequence
+			if (IS_ROSE_TATTOO && v == ALLOW_TALK_CODE) {
+				if (_gotoSeq) {
+					setObjTalkSequence(_gotoSeq);
+					_gotoSeq = 0;
+				} else {
+					++_frameNumber;
+				}
+			} else if (IS_ROSE_TATTOO && (v == TALK_SEQ_CODE || v == TALK_LISTEN_CODE)) {
+				if (_talkSeq)
+					setObjTalkSequence(_talkSeq);
+				else
+					setObjSequence(0, false);
+			} else  if (v >= GOTO_CODE) {
+				// Goto code found
+				v -= GOTO_CODE;
+				_seqCounter2 = _seqCounter;
+				_seqStack = _frameNumber + 1;
+				setObjSequence(v, false);
+			} else if (v >= SOUND_CODE && (v < (SOUND_CODE + 30))) {
+				codeFound = true;
+				++_frameNumber;
+				v -= SOUND_CODE + (IS_SERRATED_SCALPEL ? 1 : 0);
+
+				if (sound._soundOn && !_countCAnimFrames) {
+					if (!scene._sounds[v]._name.empty() && sound._digitized)
+						sound.playLoadedSound(v, WAIT_RETURN_IMMEDIATELY);
+				}
+			} else if (v >= FLIP_CODE && v < (FLIP_CODE + 3)) {
+				// Flip code
+				codeFound = true;
+				++_frameNumber;
+				v -= FLIP_CODE;
+
+				// Alter the flipped status
+				switch (v) {
+				case 0:
+					// Clear the flag
+					_flags &= ~OBJ_FLIPPED;
+					break;
+				case 1:
+					// Set the flag
+					_flags |= OBJ_FLIPPED;
+					break;
+				case 2:
+					// Toggle the flag
+					_flags ^= OBJ_FLIPPED;
+					break;
+				default:
+					break;
+				}
+			} else if (IS_ROSE_TATTOO && v == TELEPORT_CODE) {
+				_position.x = READ_LE_UINT16(&_sequences[_frameNumber + 1]);
+				_position.y = READ_LE_UINT16(&_sequences[_frameNumber + 3]);
+
+				_frameNumber += 5;
+			} else if (IS_ROSE_TATTOO && v == CALL_TALK_CODE) {
+				Common::String filename;
+				for (int idx = 0; idx < 8; ++idx) {
+					if (_sequences[_frameNumber + 1 + idx] != 1)
+						filename += (char)_sequences[_frameNumber + 1 + idx];
+					else
+						break;
+				}
+
+				_frameNumber += 8;
+				talk.talkTo(filename);
+
+			} else if (IS_ROSE_TATTOO && v == HIDE_CODE) {
+				switch (_sequences[_frameNumber + 2]) {
+				case 1:
+					// Hide Object
+					if (scene._bgShapes[_sequences[_frameNumber + 1] - 1]._type != HIDDEN)
+						scene._bgShapes[_sequences[_frameNumber + 1] - 1].toggleHidden();
+					break;
+
+				case 2:
+					// Activate Object
+					if (scene._bgShapes[_sequences[_frameNumber + 1] - 1]._type == HIDDEN)
+						scene._bgShapes[_sequences[_frameNumber + 1] - 1].toggleHidden();
+					break;
+
+				case 3:
+					// Toggle Object
+					scene._bgShapes[_sequences[_frameNumber + 1] - 1].toggleHidden();
+					break;
+
+				default:
+					break;
+				}
+				_frameNumber += 3;
+			
+			} else {
+				v -= 128;
+
+				// 68-99 is a sequence code
+				if (v > SEQ_TO_CODE) {
+					if (IS_ROSE_TATTOO) {
+						++_frameNumber;
+						byte *p = &_sequences[_frameNumber];
+						_seqTo = *p;
+						*p = *(p - 2);
+
+						if (*p > _seqTo)
+							*p -= 1;
+						else
+							*p += 1;
+
+						--_frameNumber;
+					} else {
+						byte *p = &_sequences[_frameNumber];
+						v -= SEQ_TO_CODE;	// # from 1-32
+						_seqTo = v;
+						*p = *(p - 1);
+
+						if (*p > 128)
+							// If the high bit is set, convert to a real frame
+							*p -= (byte)(SEQ_TO_CODE - 128);
+
+						if (*p > _seqTo)
+							*p -= 1;
+						else
+							*p += 1;
+
+						// Will be incremented below to return back to original value
+						--_frameNumber;
+						v = 0;
+					}
+				} else if (IS_ROSE_TATTOO && v == 10) {
+					// Set delta for objects
+					_delta = Common::Point(READ_LE_UINT16(&_sequences[_frameNumber + 1]), 
+						READ_LE_UINT16(&_sequences[_frameNumber + 3]));
+					_noShapeSize = Common::Point(0, 0);
+					_frameNumber += 4;
+
+				} else if (v == 10) {
+					// Set delta for objects
+					Common::Point pt(_sequences[_frameNumber + 1], _sequences[_frameNumber + 2]);
+					if (pt.x > 128)
+						pt.x = (pt.x - 128) *  -1;
+					else
+						pt.x--;
+
+					if (pt.y > 128)
+						pt.y = (pt.y - 128) * -1;
+					else
+						pt.y--;
+
+					_delta = pt;
+					_frameNumber += 2;
+
+				} else if (v < USE_COUNT) {
+					for (int idx = 0; idx < NAMES_COUNT; ++idx) {
+						checkNameForCodes(_use[v]._names[idx]);
+					}
+
+					if (_use[v]._useFlag)
+						_vm->setFlags(_use[v]._useFlag);
+				}
+
+				++_frameNumber;
+			}
+		}
+	} while (codeFound);
+}
+
+bool BaseObject::checkEndOfSequence() {
+	Screen &screen = *_vm->_screen;
+	int checkFrame = _allow ? MAX_FRAME : FRAMES_END;
+	bool result = false;
+
+	if (_type == REMOVE || _type == INVALID)
+		return false;
+
+	if (_frameNumber < 0 || _frameNumber >= checkFrame || _sequences[_frameNumber] == 0) {
+		result = true;
+
+		if (_frameNumber < 0 || _frameNumber >= (checkFrame - 1)) {
+			_frameNumber = START_FRAME;
+		}  else {
+			// Determine next sequence to use
+			int seq = _sequences[_frameNumber + 1];
+
+			// If the object has been turned off, we're going nowhere
+			if (IS_ROSE_TATTOO && (_type == HIDE_SHAPE || _type == HIDDEN || _type == REMOVE))
+				return false;
+
+			if (seq == 99) {
+				--_frameNumber;
+				screen._backBuffer1.transBlitFrom(*_imageFrame, _position);
+				screen._backBuffer2.transBlitFrom(*_imageFrame, _position);
+				_type = INVALID;
+			} else if (IS_ROSE_TATTOO && _talkSeq && seq == 0) {
+				setObjTalkSequence(_talkSeq);
+			} else {
+				setObjSequence(seq, false);
+			}
+		}
+
+		if (_allow && _frameNumber == 0) {
+			// canimation just ended
+			if (_type != NO_SHAPE && _type != REMOVE) {
+				_type = REMOVE;
+
+				if (!_countCAnimFrames) {
+					// Save details before shape is removed
+					_delta.x = _imageFrame->_frame.w;
+					_delta.y = _imageFrame->_frame.h;
+					_position += _imageFrame->_offset;
+
+					// Free the images
+					delete _images;
+					_images = nullptr;
+					_imageFrame = nullptr;
+				}
+			} else {
+				_type = INVALID;
+			}
+		}
+	}
+
+	return result;
+}
+
+void BaseObject::setObjSequence(int seq, bool wait) {
+	Scene &scene = *_vm->_scene;
+	int checkFrame = _allow ? MAX_FRAME : FRAMES_END;
+
+	if (IS_ROSE_TATTOO && (seq == -1 || seq == 255))
+		// This means goto beginning
+		seq = 0;
+
+	if (seq >= 128) {
+		// Loop the sequence until the count exceeded
+		seq -= 128;
+
+		++_seqCounter;
+		if (_seqCounter >= seq) {
+			// Go to next sequence
+			if (_seqStack) {
+				_frameNumber = _seqStack;
+				_seqStack = 0;
+				_seqCounter = _seqCounter2;
+				_seqCounter2 = 0;
+				if (_frameNumber >= checkFrame)
+					_frameNumber = START_FRAME;
+
+				return;
+			}
+
+			_frameNumber += 2;
+			if (_frameNumber >= checkFrame)
+				_frameNumber = 0;
+
+			// For Rose Tattoo, save the starting frame for new sequences
+			if (IS_ROSE_TATTOO)
+				_startSeq = _frameNumber;
+
+			_seqCounter = 0;
+			if (_sequences[_frameNumber] == 0)
+				seq = _sequences[_frameNumber + 1];
+			else
+				return;
+		} else {
+			// Find beginning of sequence
+			if (IS_ROSE_TATTOO) {
+				// Use the saved start of the sequence to reset the frame
+				_frameNumber = _startSeq;
+			} else {
+				// For Scalpel, scan backwards from the end of the sequence to find its start
+				do {
+					--_frameNumber;
+				} while (_frameNumber > 0 && _sequences[_frameNumber] != 0);
+
+				if (_frameNumber != 0)
+					_frameNumber += 2;
+			}
+
+			return;
+		}
+	} else {
+		// Reset sequence counter
+		_seqCounter = 0;
+	}
+
+	int idx = 0;
+	int seqCc = 0;
+
+	while (seqCc < seq && idx < checkFrame) {
+		if (IS_SERRATED_SCALPEL) {
+			++idx;
+
+			if (_sequences[idx] == 0) {
+				++seqCc;
+				idx += 2;
+			}
+		} else {
+			byte s = _sequences[idx];
+
+			if (s == 0) {
+				++seqCc;
+				++idx;
+			} else if (s == MOVE_CODE || s == TELEPORT_CODE) {
+				idx += 4;
+			} else if (s == CALL_TALK_CODE) {
+				idx += 8;
+			} else if (s == HIDE_CODE) {
+				idx += 2;
+			}
+
+			++idx;
+		}
+	}
+
+	if (idx >= checkFrame)
+		idx = 0;
+	_frameNumber = idx;
+	_startSeq = idx;
+
+	if (wait) {
+		seqCc = idx;
+		while (_sequences[idx] != 0)
+			++idx;
+
+		idx = idx - seqCc + 2;
+		for (; idx > 0; --idx)
+			scene.doBgAnim();
+	}
+}
+
+int BaseObject::checkNameForCodes(const Common::String &name, FixedTextActionId fixedTextActionId) {
+	FixedText &fixedText = *_vm->_fixedText;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	UserInterface &ui = *_vm->_ui;
+	bool printed = false;
+
+	scene.toggleObject(name);
+
+	if (name.hasPrefix("*")) {
+		// A code was found
+		printed = true;
+		char ch = (name == "*") ? 0 : toupper(name[1]);
+
+		switch (ch) {
+		case 'C':
+			talk.talkTo(name.c_str() + 2);
+			break;
+
+		case 'T':
+		case 'B':
+		case 'F':
+		case 'W':
+			// Nothing: action was already done before canimation
+			break;
+
+		case 'G':
+		case 'A': {
+			// G: Have object go somewhere
+			// A: Add onto existing co-ordinates
+			Common::String sx(name.c_str() + 2, name.c_str() + 5);
+			Common::String sy(name.c_str() + 5, name.c_str() + 8);
+
+			if (ch == 'G')
+				_position = Common::Point(atoi(sx.c_str()), atoi(sy.c_str()));
+			else
+				_position += Common::Point(atoi(sx.c_str()), atoi(sy.c_str()));
+			break;
+		}
+
+		case 'V':
+			// Do nothing for Verb codes. This is only a flag for Inventory syntax
+			break;
+
+		default:
+			if (ch >= '0' && ch <= '9') {
+				scene._goToScene = atoi(name.c_str() + 1);
+
+				if (IS_SERRATED_SCALPEL && scene._goToScene < 97) {
+					Scalpel::ScalpelMap &map = *(Scalpel::ScalpelMap *)_vm->_map;
+					if (map[scene._goToScene].x) {
+						map._overPos.x = (map[scene._goToScene].x - 6) * FIXED_INT_MULTIPLIER;
+						map._overPos.y = (map[scene._goToScene].y + 9) * FIXED_INT_MULTIPLIER;
+					}
+				}
+
+				const char *p;
+				if ((p = strchr(name.c_str(), ',')) != nullptr) {
+					++p;
+
+					Common::String s(p, p + 3);
+					people._savedPos.x = atoi(s.c_str());
+
+					s = Common::String(p + 3, p + 6);
+					people._savedPos.y = atoi(s.c_str());
+
+					s = Common::String(p + 6, p + 9);
+					people._savedPos._facing = atoi(s.c_str());
+					if (people._savedPos._facing == 0)
+						people._savedPos._facing = 10;
+				} else if ((p = strchr(name.c_str(), '/')) != nullptr) {
+					people._savedPos = PositionFacing(1, 0, 100 + atoi(p + 1));
+				}
+			} else {
+				scene._goToScene = 100;
+			}
+
+			people[HOLMES]._position = Point32(0, 0);
+			break;
+		}
+	} else if (name.hasPrefix("!")) {
+		// Message attached to canimation
+		int messageNum = atoi(name.c_str() + 1);
+		ui._infoFlag = true;
+		ui.clearInfo();
+		Common::String errorMessage = fixedText.getActionMessage(fixedTextActionId, messageNum);
+		screen.print(Common::Point(0, INFO_LINE + 1), COL_INFO_FOREGROUND, "%s", errorMessage.c_str());
+		ui._menuCounter = 25;
+	} else if (name.hasPrefix("@")) {
+		// Message attached to canimation
+		ui._infoFlag = true;
+		ui.clearInfo();
+		screen.print(Common::Point(0, INFO_LINE + 1), COL_INFO_FOREGROUND, "%s", name.c_str() + 1);
+		printed = true;
+		ui._menuCounter = 25;
+	}
+
+	return printed;
+}
+
+/*----------------------------------------------------------------*/
+
+void Sprite::clear() {
+	_name = "";
+	_description = "";
+	_examine.clear();
+	_pickUp = "";
+	_walkSequences.clear();
+	_sequences = nullptr;
+	_images = nullptr;
+	_imageFrame = nullptr;
+	_walkCount = 0;
+	_allow = 0;
+	_frameNumber = 0;
+	_position.x = _position.y = 0;
+	_delta.x = _delta.y = 0;
+	_oldPosition.x = _oldPosition.y = 0;
+	_oldSize.x = _oldSize.y = 0;
+	_goto.x = _goto.y = 0;
+	_type = INVALID;
+	_pickUp.clear();
+	_noShapeSize.x = _noShapeSize.y = 0;
+	_status = 0;
+	_misc = 0;
+	_altImages = nullptr;
+	_altSeq = 0;
+	Common::fill(&_stopFrames[0], &_stopFrames[8], (ImageFrame *)nullptr);
+}
+
+void Sprite::setImageFrame() {
+	int frameNum = MAX(_frameNumber, 0);
+	int imageNumber = _walkSequences[_sequenceNumber][frameNum];
+	
+	if (IS_SERRATED_SCALPEL)
+		imageNumber = imageNumber + _walkSequences[_sequenceNumber][0] - 2;
+	else if (imageNumber > _maxFrames)
+		imageNumber = 1;
+
+	// Get the images to use
+	ImageFile *images = _altSeq ? _altImages : _images;
+	assert(images);
+
+	if (IS_3DO) {
+		// only do this to the image-array with 110 entries
+		// map uses another image-array and this code
+		if (images->size() == 110) {
+			// 3DO has 110 animation frames inside walk.anim
+			// PC has 55
+			// this adjusts the framenumber accordingly
+			// sort of HACK
+			imageNumber *= 2;
+		}
+	} else if (IS_ROSE_TATTOO) {
+		--imageNumber;
+	}
+
+	// Set the frame pointer
+	_imageFrame = &(*images)[imageNumber];
+}
+
+void Sprite::checkSprite() {
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	Point32 pt;
+	Common::Rect objBounds;
+	Common::Point spritePt(_position.x / FIXED_INT_MULTIPLIER, _position.y / FIXED_INT_MULTIPLIER);
+
+	if (_type != CHARACTER || (IS_SERRATED_SCALPEL && talk._talkCounter))
+		return;
+
+	pt = _walkCount ? _position + _delta : _position;
+	pt.x /= FIXED_INT_MULTIPLIER;
+	pt.y /= FIXED_INT_MULTIPLIER;
+
+	if (IS_ROSE_TATTOO) {
+		checkObject();
+
+		// For Rose Tattoo, we only do the further processing for Sherlock
+		if (this != &people[HOLMES])
+			return;
+	}
+
+	for (uint idx = 0; idx < scene._bgShapes.size() && !talk._talkToAbort; ++idx) {
+		Object &obj = scene._bgShapes[idx];
+		if (obj._aType <= PERSON || obj._type == INVALID || obj._type == HIDDEN)
+			continue;
+
+		if (obj._type == NO_SHAPE) {
+			objBounds = Common::Rect(obj._position.x, obj._position.y,
+				obj._position.x + obj._noShapeSize.x + 1, obj._position.y + obj._noShapeSize.y + 1);
+		} else {
+			int xp = obj._position.x + obj._imageFrame->_offset.x;
+			int yp = obj._position.y + obj._imageFrame->_offset.y;
+			objBounds = Common::Rect(xp, yp,
+				xp + obj._imageFrame->_frame.w + 1, yp + obj._imageFrame->_frame.h + 1);
+		}
+
+		if (objBounds.contains(pt)) {
+			if (objBounds.contains(spritePt)) {
+				// Current point is already inside the the bounds, so impact occurred
+				// on a previous call. So simply do nothing until we're clear of the box
+				switch (obj._aType) {
+				case TALK_MOVE:
+					if (_walkCount) {
+						// Holmes is moving
+						obj._type = HIDDEN;
+						obj.setFlagsAndToggles();
+						talk.talkTo(obj._use[0]._target);
+					}
+					break;
+
+				case PAL_CHANGE:
+				case PAL_CHANGE2:
+					if (_walkCount) {
+						int palStart = atoi(obj._use[0]._names[0].c_str()) * 3;
+						int palLength = atoi(obj._use[0]._names[1].c_str()) * 3;
+						int templ = atoi(obj._use[0]._names[2].c_str()) * 3;
+						if (templ == 0)
+							templ = 100;
+
+						// Ensure only valid palette change data found
+						if (palLength > 0) {
+							// Figure out how far into the shape Holmes is so that we
+							// can figure out what percentage of the original palette
+							// to set the current palette to
+							int palPercent = (pt.x - objBounds.left) * 100 / objBounds.width();
+							palPercent = palPercent * templ / 100;
+							if (obj._aType == PAL_CHANGE)
+								// Invert percentage
+								palPercent = 100 - palPercent;
+
+							for (int i = palStart; i < (palStart + palLength); ++i)
+								screen._sMap[i] = screen._cMap[i] * palPercent / 100;
+
+							events.pollEvents();
+							screen.setPalette(screen._sMap);
+						}
+					}
+					break;
+
+				case TALK:
+				case TALK_EVERY:
+					obj._type = HIDDEN;
+					obj.setFlagsAndToggles();
+					talk.talkTo(obj._use[0]._target);
+					break;
+
+				default:
+					break;
+				}
+			} else {
+				// New impact just occurred
+				switch (obj._aType) {
+				case BLANK_ZONE:
+					// A blank zone masks out all other remaining zones underneath it.
+					// If this zone is hit, exit the outer loop so we do not check anymore
+					return;
+
+				case SOLID:
+				case TALK:
+					// Stop walking
+					if (obj._aType == TALK) {
+						obj.setFlagsAndToggles();
+						talk.talkTo(obj._use[0]._target);
+					} else {
+						gotoStand();
+					}
+					break;
+
+				case TALK_EVERY:
+					if (obj._aType == TALK_EVERY) {
+						obj._type = HIDDEN;
+						obj.setFlagsAndToggles();
+						talk.talkTo(obj._use[0]._target);
+					} else {
+						gotoStand();
+					}
+					break;
+
+				case FLAG_SET:
+					obj.setFlagsAndToggles();
+					obj._type = HIDDEN;
+					break;
+
+				case WALK_AROUND:
+					if (objBounds.contains(people[HOLMES]._walkTo.front())) {
+						// Reached zone
+						gotoStand();
+					} else {
+						// Destination not within box, walk to best corner
+						Common::Point walkPos;
+
+						if (spritePt.x >= objBounds.left && spritePt.x < objBounds.right) {
+							// Impact occurred due to vertical movement. Determine whether to
+							// travel to the left or right side
+							if (_delta.x > 0)
+								// Go to right side
+								walkPos.x = objBounds.right + CLEAR_DIST_X;
+							else if (_delta.x < 0) {
+								// Go to left side
+								walkPos.x = objBounds.left - CLEAR_DIST_X;
+							} else {
+								// Going straight up or down. So choose best side
+								if (spritePt.x >= (objBounds.left + objBounds.width() / 2))
+									walkPos.x = objBounds.right + CLEAR_DIST_X;
+								else
+									walkPos.x = objBounds.left - CLEAR_DIST_X;
+							}
+
+							walkPos.y = (_delta.y >= 0) ? objBounds.top - CLEAR_DIST_Y :
+								objBounds.bottom + CLEAR_DIST_Y;
+						} else {
+							// Impact occurred due to horizontal movement
+							if (_delta.y > 0)
+								// Go to bottom of box
+								walkPos.y = objBounds.bottom + CLEAR_DIST_Y;
+							else if (_delta.y < 0)
+								// Go to top of box
+								walkPos.y = objBounds.top - CLEAR_DIST_Y;
+							else {
+								// Going straight horizontal, so choose best side
+								if (spritePt.y >= (objBounds.top + objBounds.height() / 2))
+									walkPos.y = objBounds.bottom + CLEAR_DIST_Y;
+								else
+									walkPos.y = objBounds.top - CLEAR_DIST_Y;
+							}
+
+							walkPos.x = (_delta.x >= 0) ? objBounds.left - CLEAR_DIST_X :
+								objBounds.right + CLEAR_DIST_X;
+						}
+
+						walkPos.x += people[HOLMES]._imageFrame->_frame.w / 2;
+						people[HOLMES]._walkDest = walkPos;
+						people[HOLMES]._walkTo.push(walkPos);
+						people[HOLMES].setWalking();
+					}
+					break;
+
+				case DELTA:
+					_position.x += 200;
+					break;
+
+				default:
+					break;
+				}
+			}
+		}
+	}
+}
+
+const Common::Rect Sprite::getOldBounds() const {
+	return Common::Rect(_oldPosition.x, _oldPosition.y, _oldPosition.x + _oldSize.x, _oldPosition.y + _oldSize.y);
+}
+
+/*----------------------------------------------------------------*/
+
+void WalkSequence::load(Common::SeekableReadStream &s) {
+	char buffer[9];
+	s.read(buffer, 9);
+	_vgsName = Common::String(buffer);
+	_horizFlip = s.readByte() != 0;
+
+	_sequences.resize(s.readUint16LE());
+	s.skip(4);		// Skip over pointer field of structure
+
+	s.read(&_sequences[0], _sequences.size());
+}
+
+/*----------------------------------------------------------------*/
+
+WalkSequences &WalkSequences::operator=(const WalkSequences &src) {
+	resize(src.size());
+	for (uint idx = 0; idx < size(); ++idx) {
+		const WalkSequence &wSrc = src[idx];
+		WalkSequence &wDest = (*this)[idx];
+		wDest._horizFlip = wSrc._horizFlip;
+
+		wDest._sequences.resize(wSrc._sequences.size());
+		Common::copy(&wSrc._sequences[0], &wSrc._sequences[0] + wSrc._sequences.size(), &wDest._sequences[0]);
+	}
+
+	return *this;
+}
+
+/*----------------------------------------------------------------*/
+
+ActionType::ActionType() {
+	_cAnimNum = _cAnimSpeed = 0;
+	_useFlag = 0;
+}
+
+void ActionType::load(Common::SeekableReadStream &s) {
+	char buffer[12];
+
+	_cAnimNum = s.readByte();
+	_cAnimSpeed = s.readByte();
+	if (_cAnimSpeed & 0x80)
+		_cAnimSpeed = -(_cAnimSpeed & 0x7f);
+
+	for (int idx = 0; idx < NAMES_COUNT; ++idx) {
+		s.read(buffer, 12);
+		_names[idx] = Common::String(buffer);
+	}
+}
+
+/*----------------------------------------------------------------*/
+
+UseType::UseType(): ActionType() {
+}
+
+void UseType::load(Common::SeekableReadStream &s, bool isRoseTattoo) {
+	char buffer[12];
+
+	if (isRoseTattoo) {
+		s.read(buffer, 12);
+		_verb = Common::String(buffer);
+	}
+
+	ActionType::load(s);
+
+	_useFlag = s.readSint16LE();
+
+	if (!isRoseTattoo)
+		s.skip(6);
+
+	s.read(buffer, 12);
+	_target = Common::String(buffer);
+}
+
+void UseType::load3DO(Common::SeekableReadStream &s) {
+	char buffer[12];
+
+	_cAnimNum = s.readByte();
+	_cAnimSpeed = s.readByte();
+	if (_cAnimSpeed & 0x80)
+		_cAnimSpeed = -(_cAnimSpeed & 0x7f);
+
+	for (int idx = 0; idx < NAMES_COUNT; ++idx) {
+		s.read(buffer, 12);
+		_names[idx] = Common::String(buffer);
+	}
+
+	_useFlag = s.readSint16BE();
+
+	s.skip(6);
+
+	s.read(buffer, 12);
+	_target = Common::String(buffer);
+}
+
+void UseType::synchronize(Serializer &s) {
+	s.syncString(_verb);
+	s.syncAsSint16LE(_cAnimNum);
+	s.syncAsSint16LE(_cAnimSpeed);
+	s.syncAsSint16LE(_useFlag);
+
+	for (int idx = 0; idx < 4; ++idx)
+		s.syncString(_names[idx]);
+	s.syncString(_target);
+}
+
+/*----------------------------------------------------------------*/
+
+Object::Object(): BaseObject() {
+	_sequenceOffset = 0;
+	_pickup = 0;
+	_defaultCommand = 0;
+	_pickupFlag = 0;
+}
+
+void Object::load(Common::SeekableReadStream &s, bool isRoseTattoo) {
+	char buffer[41];
+	s.read(buffer, 12);
+	_name = Common::String(buffer);
+	s.read(buffer, 41);
+	_description = Common::String(buffer);
+
+	_examine.clear();
+	_sequences = nullptr;
+	_images = nullptr;
+	_imageFrame = nullptr;
+
+	s.skip(4);
+	_sequenceOffset = s.readUint16LE();
+	s.seek(10, SEEK_CUR);
+
+	_walkCount = s.readByte();
+	_allow = s.readByte();
+	_frameNumber = s.readSint16LE();
+	_sequenceNumber = s.readSint16LE();
+	_position.x = s.readSint16LE();
+	_position.y = s.readSint16LE();
+	_delta.x = s.readSint16LE();
+	_delta.y = s.readSint16LE();
+	_type = (SpriteType)s.readUint16LE();
+	_oldPosition.x = s.readSint16LE();
+	_oldPosition.y = s.readSint16LE();
+	_oldSize.x = s.readUint16LE();
+	_oldSize.y = s.readUint16LE();
+	
+	_goto.x = s.readSint16LE();
+	_goto.y = s.readSint16LE();
+	if (!isRoseTattoo) {
+		_goto.x = _goto.x * FIXED_INT_MULTIPLIER / 100;
+		_goto.y = _goto.y * FIXED_INT_MULTIPLIER / 100;
+	}
+
+	_pickup = isRoseTattoo ? 0 : s.readByte();
+	_defaultCommand = isRoseTattoo ? 0 : s.readByte();
+	_lookFlag = s.readSint16LE();
+	_pickupFlag = isRoseTattoo ? 0 : s.readSint16LE();
+	_requiredFlag[0] = s.readSint16LE();
+	_noShapeSize.x = s.readUint16LE();
+	_noShapeSize.y = s.readUint16LE();
+	_status = s.readUint16LE();
+	_misc = s.readByte();
+	_maxFrames = s.readUint16LE();
+	_flags = s.readByte();
+
+	if (!isRoseTattoo)
+		_aOpen.load(s);
+
+	_aType = (AType)s.readByte();
+	_lookFrames = s.readByte();
+	_seqCounter = s.readByte();
+	if (isRoseTattoo) {
+		_lookPosition.x = s.readUint16LE() * FIXED_INT_MULTIPLIER;
+		_lookPosition.y = s.readSint16LE() * FIXED_INT_MULTIPLIER;
+	} else {
+		_lookPosition.x = s.readUint16LE() * FIXED_INT_MULTIPLIER / 100;
+		_lookPosition.y = s.readByte() * FIXED_INT_MULTIPLIER;
+	}
+	_lookPosition._facing = s.readByte();
+	_lookcAnim = s.readByte();
+
+	if (!isRoseTattoo)
+		_aClose.load(s);
+
+	_seqStack = s.readByte();
+	_seqTo = s.readByte();
+	_descOffset = s.readUint16LE();
+	_seqCounter2 = s.readByte();
+	_seqSize = s.readUint16LE();
+
+	if (isRoseTattoo) {
+		for (int idx = 0; idx < 6; ++idx)
+			_use[idx].load(s, true);
+
+		_quickDraw = s.readByte();
+		_scaleVal = s.readUint16LE();
+		_requiredFlag[1] = s.readSint16LE();
+		_gotoSeq = s.readByte();
+		_talkSeq = s.readByte();
+		_restoreSlot = s.readByte();
+	} else {
+		s.skip(1);
+		_aMove.load(s);
+		s.skip(8);
+
+		for (int idx = 0; idx < 4; ++idx)
+			_use[idx].load(s, false);
+	}
+	//warning("object %s, useAnim %d", _name.c_str(), _use[0]._cAnimNum);
+}
+
+void Object::load3DO(Common::SeekableReadStream &s) {
+	int32 streamStartPos = s.pos();
+	char buffer[41];
+
+	_examine.clear();
+	_sequences = nullptr;
+	_images = nullptr;
+	_imageFrame = nullptr;
+
+	// on 3DO all of this data is reordered!!!
+	// it seems that possibly the 3DO compiler reordered the global struct
+	// 3DO size for 1 object is 588 bytes
+	s.skip(4);
+	_sequenceOffset = s.readUint16LE(); // weird that this seems to be LE
+	s.seek(10, SEEK_CUR);
+
+	// Offset 16
+	_frameNumber = s.readSint16BE();
+	_sequenceNumber = s.readSint16BE();
+	_position.x = s.readSint16BE();
+	_position.y = s.readSint16BE();
+	_delta.x = s.readSint16BE();
+	_delta.y = s.readSint16BE();
+	_type = (SpriteType)s.readUint16BE();
+	_oldPosition.x = s.readSint16BE();
+	_oldPosition.y = s.readSint16BE();
+	_oldSize.x = s.readUint16BE();
+	_oldSize.y = s.readUint16BE();
+	
+	_goto.x = s.readSint16BE();
+	_goto.y = s.readSint16BE();
+	_goto.x = _goto.x * FIXED_INT_MULTIPLIER / 100;
+	_goto.y = _goto.y * FIXED_INT_MULTIPLIER / 100;
+
+	// Offset 42
+	warning("pos %d", s.pos());
+
+	// Unverified
+	_lookFlag = s.readSint16BE();
+	_pickupFlag = s.readSint16BE();
+	_requiredFlag[0] = s.readSint16BE();
+	_noShapeSize.x = s.readUint16BE();
+	_noShapeSize.y = s.readUint16BE();
+	_status = s.readUint16BE();
+	// Unverified END
+
+	_maxFrames = s.readUint16BE();
+	// offset 56
+	_lookPosition.x = s.readUint16BE() * FIXED_INT_MULTIPLIER / 100;
+	// offset 58
+	_descOffset = s.readUint16BE();
+	_seqSize = s.readUint16BE();
+
+	s.skip(2); // boundary filler
+
+	// 288 bytes
+	for (int idx = 0; idx < 4; ++idx) {
+		_use[idx].load3DO(s);
+		s.skip(2); // Filler
+	}
+
+	// 158 bytes
+	_aOpen.load(s); // 2 + 12*4 bytes = 50 bytes
+	s.skip(2); // Boundary filler
+	_aClose.load(s);
+	s.skip(2); // Filler
+	_aMove.load(s);
+	s.skip(2); // Filler
+
+	// offset 508
+	// 3DO: name is at the end
+	s.read(buffer, 12);
+	_name = Common::String(buffer);
+	s.read(buffer, 41);
+	_description = Common::String(buffer);
+
+	// Unverified
+	_walkCount = s.readByte();
+	_allow = s.readByte();
+	_pickup = s.readByte();
+	_defaultCommand = s.readByte();
+	// Unverified END
+
+	// Probably those here?!?!
+	_misc = s.readByte();
+	_flags = s.readByte();
+
+	// Unverified
+	_aType = (AType)s.readByte();
+	_lookFrames = s.readByte();
+	_seqCounter = s.readByte();
+	// Unverified END
+
+	_lookPosition.y = s.readByte() * FIXED_INT_MULTIPLIER;
+	_lookPosition._facing = s.readByte();
+
+	// Unverified
+	_lookcAnim = s.readByte();
+	_seqStack = s.readByte();
+	_seqTo = s.readByte();
+	_seqCounter2 = s.readByte();
+	// Unverified END
+
+	s.skip(12); // Unknown
+
+	//warning("object %s, offset %d", _name.c_str(), streamPos);
+	//warning("object %s, lookPosX %d, lookPosY %d", _name.c_str(), _lookPosition.x, _lookPosition.y);
+	//warning("object %s, defCmd %d", _name.c_str(), _defaultCommand);
+	int32 dataSize = s.pos() - streamStartPos;
+	assert(dataSize == 588);
+}
+
+void Object::toggleHidden() {
+	if (_type != HIDDEN && _type != HIDE_SHAPE && _type != INVALID) {
+		if (_seqTo != 0)
+			_sequences[_frameNumber] = _seqTo + SEQ_TO_CODE + 128;
+		_seqTo = 0;
+
+		if (_images == nullptr || _images->size() == 0)
+			// No shape to erase, so flag as hidden
+			_type = HIDDEN;
+		else
+			// Otherwise, flag it to be hidden after it gets erased
+			_type = HIDE_SHAPE;
+	} else if (_type != INVALID) {
+		if (_seqTo != 0)
+			_sequences[_frameNumber] = _seqTo + SEQ_TO_CODE + 128;
+		_seqTo = 0;
+
+		_seqCounter = _seqCounter2 = 0;
+		_seqStack = 0;
+		_frameNumber = -1;
+
+		if (_images == nullptr || _images->size() == 0) {
+			_type = NO_SHAPE;
+		} else {
+			_type = ACTIVE_BG_SHAPE;
+			int idx = _sequences[0];
+			if (idx >= _maxFrames)
+				// Turn on: set up first frame
+				idx = 0;
+
+			_imageFrame = &(*_images)[idx];
+		}
+	}
+}
+
+void Object::setObjTalkSequence(int seq) {
+	Talk &talk = *_vm->_talk;
+
+	// See if we're supposed to restore the object's sequence from the talk sequence stack
+	if (seq == -1) {
+		if (_seqTo != 0)
+			_sequences[_frameNumber] = _seqTo;
+
+		talk.pullSequence(_restoreSlot);
+		return;
+	}
+
+	assert(_type != CHARACTER);
+
+	talk.pushSequenceEntry(this);
+	int talkSeqNum = seq;
+
+	// Find where the talk sequence data begins in the object
+	int idx = 0;
+	for (;;) {
+		// Get the Frame value
+		byte f = _sequences[idx++];
+
+		// See if we've found the beginning of a Talk Sequence
+		if ((f == TALK_SEQ_CODE && seq < 128) || (f == TALK_LISTEN_CODE && seq > 128)) {
+			--seq;
+
+			// See if we're at the correct Talk Sequence Number
+			if (!(seq & 127))
+			{
+				// Correct Sequence, Start Talking Here
+				if (_seqTo != 0)
+					_sequences[_frameNumber] = _seqTo;
+				_frameNumber = idx;
+				_seqTo = 0;
+				_seqStack = 0;
+				_seqCounter = 0;
+				_seqCounter2 = 0;
+				_talkSeq = talkSeqNum;
+				break;
+			}
+		} else {
+			// Move ahead any extra because of special control codes
+			switch (f) {
+			case 0: idx++; break;
+			case MOVE_CODE:
+			case TELEPORT_CODE: idx += 4; break;
+			case CALL_TALK_CODE: idx += 8; break;
+			case HIDE_CODE: idx += 2; break;
+			}
+		}
+
+		// See if we're out of sequence data
+		if (idx >= (int)_seqSize)
+			break;
+	}
+}
+
+void Object::setFlagsAndToggles() {
+	Scene &scene = *_vm->_scene;
+	Talk &talk = *_vm->_talk;
+
+	for (int useIdx = 0; useIdx < USE_COUNT; ++useIdx) {
+		if (_use[useIdx]._useFlag) {
+			if (!_vm->readFlags(_use[useIdx]._useFlag))
+				_vm->setFlags(_use[useIdx]._useFlag);
+		}
+
+		if (_use[useIdx]._cAnimSpeed) {
+			if (_use[useIdx]._cAnimNum == 0)
+				// 0 is really a 10
+				scene.startCAnim(9, _use[useIdx]._cAnimSpeed);
+			else
+				scene.startCAnim(_use[useIdx]._cAnimNum - 1, _use[useIdx]._cAnimSpeed);
+		}
+
+		if (!talk._talkToAbort) {
+			for (int idx = 0; idx < NAMES_COUNT; ++idx)
+				scene.toggleObject(_use[useIdx]._names[idx]);
+		}
+	}
+}
+
+void Object::adjustObject() {
+	if (_type == REMOVE)
+		return;
+
+	if (IS_ROSE_TATTOO && (_delta.x || _delta.y)) {
+		// The shape position is in pixels, and the delta is in fixed integer amounts
+		int t;
+		_noShapeSize.x += _delta.x;
+		t = _noShapeSize.x / (FIXED_INT_MULTIPLIER / 10);
+		_noShapeSize.x -= t * (FIXED_INT_MULTIPLIER / 10);
+		_position.x += t;
+
+		_noShapeSize.y += _delta.y;
+		t = _noShapeSize.y / (FIXED_INT_MULTIPLIER / 10);
+		_noShapeSize.y -= t * (FIXED_INT_MULTIPLIER / 10);
+		_position.y += t;
+	} else if (IS_SERRATED_SCALPEL) {
+		// The delta is in whole pixels, so simply adjust the position with it
+		_position += _delta;
+	}
+
+	if (_position.y > LOWER_LIMIT)
+		_position.y = LOWER_LIMIT;
+
+	if (_type != NO_SHAPE) {
+		int frame = _frameNumber;
+		if (frame == -1)
+			frame = 0;
+
+		int imgNum = _sequences[frame];
+		if (imgNum > _maxFrames)
+			imgNum = 1;
+
+		_imageFrame = &(*_images)[imgNum - 1];
+	}
+}
+
+int Object::pickUpObject(FixedTextActionId fixedTextActionId) {
+	FixedText &fixedText = *_vm->_fixedText;
+	Inventory &inv = *_vm->_inventory;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	UserInterface &ui = *_vm->_ui;
+	int pickup = _pickup & 0x7f;
+	bool printed = false;
+	int numObjects = 0;
+
+	if (pickup == 99) {
+		for (int idx = 0; idx < NAMES_COUNT && !talk._talkToAbort; ++idx) {
+			if (checkNameForCodes(_use[0]._names[idx], kFixedTextAction_Invalid)) {
+				if (!talk._talkToAbort)
+					printed = true;
+			}
+		}
+
+		return 0;
+	}
+
+	if (!pickup || (pickup > 50 && pickup <= 80)) {
+		int message = _pickup;
+		if (message > 50)
+			message -= 50;
+
+		ui._infoFlag = true;
+		ui.clearInfo();
+		Common::String errorMessage = fixedText.getActionMessage(fixedTextActionId, message);
+		screen.print(Common::Point(0, INFO_LINE + 1), COL_INFO_FOREGROUND, "%s", errorMessage.c_str());
+		ui._menuCounter = 30;
+	} else {
+		// Pick it up
+		bool takeFlag = true;
+		if ((_pickup & 0x80) == 0) {
+			// Play an animation
+			if (pickup > 80) {
+				takeFlag = false;		// Don't pick it up
+				scene.startCAnim(pickup - 81, 1);
+				if (_pickupFlag)
+					_vm->setFlags(_pickupFlag);
+			} else {
+				scene.startCAnim(pickup - 1, 1);
+				if (!talk._talkToAbort) {
+					// Erase the shape
+					_type = _type == NO_SHAPE ? INVALID : REMOVE;
+				}
+			}
+
+			if (talk._talkToAbort)
+				return 0;
+		} else {
+			// Play generic pickup sequence
+			// Original moved cursor position here
+			people[HOLMES].goAllTheWay();
+			ui._menuCounter = 25;
+			ui._temp1 = 1;
+		}
+
+		for (int idx = 0; idx < NAMES_COUNT && !talk._talkToAbort; ++idx) {
+			if (checkNameForCodes(_use[0]._names[idx], kFixedTextAction_Invalid)) {
+				if (!talk._talkToAbort)
+					printed = true;
+			}
+		}
+		if (talk._talkToAbort)
+			return 0;
+
+		// Add the item to the player's inventory
+		if (takeFlag)
+			numObjects = inv.putItemInInventory(*this);
+
+		if (!printed) {
+			ui._infoFlag = true;
+			ui.clearInfo();
+
+			Common::String itemName = _description;
+			itemName.setChar(tolower(itemName[0]), 0);
+			screen.print(Common::Point(0, INFO_LINE + 1), COL_INFO_FOREGROUND, "Picked up %s", itemName.c_str());
+			ui._menuCounter = 25;
+		}
+	}
+
+	return numObjects;
+}
+
+const Common::Rect Object::getNewBounds() const {
+	Point32 pt = _position;
+	if (_imageFrame)
+		pt += _imageFrame->_offset;
+
+	return Common::Rect(pt.x, pt.y, pt.x + frameWidth(), pt.y + frameHeight());
+}
+
+const Common::Rect Object::getNoShapeBounds() const {
+	return Common::Rect(_position.x, _position.y,
+		_position.x + _noShapeSize.x, _position.y + _noShapeSize.y);
+}
+
+const Common::Rect Object::getOldBounds() const {
+	return Common::Rect(_oldPosition.x, _oldPosition.y,
+		_oldPosition.x + _oldSize.x, _oldPosition.y + _oldSize.y);
+}
+
+/*----------------------------------------------------------------*/
+
+void CAnim::load(Common::SeekableReadStream &s, bool isRoseTattoo, uint32 dataOffset) {
+	char buffer[12];
+	s.read(buffer, 12);
+	_name = Common::String(buffer);
+
+	if (isRoseTattoo) {
+		Common::fill(&_sequences[0], &_sequences[30], 0);
+		_dataSize = s.readUint32LE();
+	} else {
+		s.read(_sequences, 30);
+	}
+
+	_position.x = s.readSint16LE();
+	_position.y = s.readSint16LE();
+	
+	if (isRoseTattoo) {
+		_flags = s.readByte();
+		_scaleVal = s.readSint16LE();
+	} else {
+		_dataSize = s.readUint32LE();
+		_type = (SpriteType)s.readUint16LE();
+		_flags = s.readByte();
+	}
+
+	_goto[0].x = s.readSint16LE();
+	_goto[0].y = s.readSint16LE();
+	_goto[0]._facing = s.readSint16LE();
+	ADJUST_COORD(_goto[0]);
+
+	if (isRoseTattoo) {
+		// Get Goto position and facing for second NPC
+		_goto[1].x = s.readSint16LE();
+		_goto[1].y = s.readSint16LE();
+		_goto[1]._facing = s.readSint16LE();
+		ADJUST_COORD(_goto[1]);
+	} else if (_goto[0].x != -1) {
+		// For Serrated Scalpel, adjust the loaded co-ordinates
+		_goto[0].x = _goto[0].x / 100;
+		_goto[0].y = _goto[0].y / 100;
+	}
+
+	_teleport[0].x = s.readSint16LE();
+	_teleport[0].y = s.readSint16LE();
+	_teleport[0]._facing = s.readSint16LE();
+	ADJUST_COORD(_teleport[0]);
+
+	if (isRoseTattoo) {
+		// Get Teleport position and facing for second NPC
+		_teleport[1].x = s.readSint16LE();
+		_teleport[1].y = s.readSint16LE();
+		_teleport[1]._facing = s.readSint16LE();
+		ADJUST_COORD(_teleport[1]);
+	} else if (_teleport[0].x != -1) {
+		// For Serrated Scalpel, adjust the loaded co-ordinates
+		_teleport[0].x = _teleport[0].x / 100;
+		_teleport[0].y = _teleport[0].y / 100;
+	}
+
+	// Save offset of data, which is actually inside another table inside the room data file
+	// This table is at offset 44 for Serrated Scalpel
+	// TODO: find it for the other game
+	_dataOffset = dataOffset;
+}
+
+void CAnim::load3DO(Common::SeekableReadStream &s, uint32 dataOffset) {
+	// this got reordered on 3DO
+	// maybe it was the 3DO compiler
+
+	_dataSize = s.readUint32BE();
+	// Save offset of data, which is inside another table inside the room data file
+	_dataOffset = dataOffset;
+
+	_position.x = s.readSint16BE();
+	_position.y = s.readSint16BE();
+
+	_type = (SpriteType)s.readUint16BE();
+
+	_goto[0].x = s.readSint16BE();
+	_goto[0].y = s.readSint16BE();
+	_goto[0]._facing = s.readSint16BE();
+
+	_teleport[0].x = s.readSint16BE();
+	_teleport[0].y = s.readSint16BE();
+	_teleport[0]._facing = s.readSint16BE();
+
+	char buffer[12];
+	s.read(buffer, 12);
+	_name = Common::String(buffer);
+
+	s.read(_sequences, 30);
+	_flags = s.readByte();
+
+	s.skip(3); // Filler
+
+	_goto[0].x = _goto[0].x * FIXED_INT_MULTIPLIER / 100;
+	_goto[0].y = _goto[0].y * FIXED_INT_MULTIPLIER / 100;
+	_teleport[0].x = _teleport[0].x * FIXED_INT_MULTIPLIER / 100;
+	_teleport[0].y = _teleport[0].y * FIXED_INT_MULTIPLIER / 100;
+}
+
+/*----------------------------------------------------------------*/
+
+SceneImage::SceneImage() {
+	_images = nullptr;
+	_maxFrames = 0;
+	_filesize = 0;
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/objects.h b/engines/sherlock/objects.h
new file mode 100644
index 0000000000..38b02aeae8
--- /dev/null
+++ b/engines/sherlock/objects.h
@@ -0,0 +1,477 @@
+/* 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 SHERLOCK_OBJECTS_H
+#define SHERLOCK_OBJECTS_H
+
+#include "common/scummsys.h"
+#include "common/rect.h"
+#include "common/str-array.h"
+#include "common/str.h"
+#include "sherlock/image_file.h"
+#include "sherlock/fixed_text.h"
+#include "sherlock/saveload.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+enum ObjectAllow {
+	ALLOW_MOVE = 1, ALLOW_OPEN = 2, ALLOW_CLOSE = 4
+};
+
+enum SpriteType {
+	INVALID = 0,
+	CHARACTER = 1,
+	CURSOR = 2,
+	STATIC_BG_SHAPE = 3,		// Background shape that doesn't animate
+	ACTIVE_BG_SHAPE = 4,		// Background shape that animates
+	REMOVE = 5,					// Object should be removed next frame
+	NO_SHAPE = 6,				// Background object with no shape
+	HIDDEN = 7,					// Hidden backgruond object
+	HIDE_SHAPE = 8,				// Object needs to be hidden
+
+	// Rose Tattoo
+	HIDDEN_CHARACTER = 128
+};
+
+enum AType {
+	OBJECT		= 0,
+	PERSON		= 1,
+	SOLID		= 2,
+	TALK		= 3,  // Standard talk zone
+	FLAG_SET	= 4,
+	DELTA		= 5,
+	WALK_AROUND	= 6,
+	TALK_EVERY	= 7,  // Talk zone that turns on every room visit
+	TALK_MOVE	= 8,  // Talk zone that only activates when Holmes moves
+	PAL_CHANGE	= 9,  // Changes the palette down so that it gets darker
+	PAL_CHANGE2	= 10, // Same as PAL_CHANGE, except that it goes up
+	SCRIPT_ZONE	= 11, // If this is clicked in, it is activated
+	BLANK_ZONE	= 12, // This masks out other objects when entered
+	NOWALK_ZONE = 13  // Player cannot walk here
+};
+
+// Different levels for sprites to be at
+enum {
+	BEHIND = 0, NORMAL_BEHIND = 1, NORMAL_FORWARD = 2, FORWARD = 3
+};
+
+#define MAX_HOLMES_SEQUENCE 16
+#define MAX_FRAME 30
+#define FIXED_INT_MULTIPLIER 1000
+
+// code put into sequences to defines 1-10 type seqs
+#define SEQ_TO_CODE 67
+#define FLIP_CODE (64 + 128)
+#define SOUND_CODE (34 + 128)
+#define HIDE_CODE (7+128)		// Code for hiding/unhiding an object from a Sequence
+#define CALL_TALK_CODE (8+128)	// Code for call a Talk File from a Sequence
+#define TELEPORT_CODE (9+128)	// Code for setting Teleport Data (X,Y)
+#define MOVE_CODE (10+128)		// Code for setting Movement Delta (X,Y)
+
+#define GOTO_CODE 228
+#define TALK_SEQ_CODE 252		// Code specifying start of talk sequence frames in a Sequence
+#define TALK_LISTEN_CODE 251	// Code specifying start of talk listen frames in a Sequence
+#define ALLOW_TALK_CODE 250 
+
+#define UPPER_LIMIT 0
+#define LOWER_LIMIT (IS_SERRATED_SCALPEL ? CONTROLS_Y : SHERLOCK_SCREEN_HEIGHT)
+#define LEFT_LIMIT 0
+#define RIGHT_LIMIT SHERLOCK_SCREEN_WIDTH
+
+class Point32 {
+public:
+	int x;
+	int y;
+
+	Point32() : x(0), y(0) {}
+	Point32(int x1, int y1) : x(x1), y(y1) {}
+	Point32(const Common::Point &pt) : x(pt.x), y(pt.y) {}
+
+	bool operator==(const Point32 &p) const { return x == p.x && y == p.y; }
+	bool operator!=(const Point32 &p) const { return x != p.x || y != p.y; }
+	Point32 operator+(const Point32 &delta) const { return Point32(x + delta.x, y + delta.y); }
+	Point32 operator-(const Point32 &delta) const { return Point32(x - delta.x, y - delta.y); }
+	operator Common::Point() { return Common::Point(x, y); }
+
+	void operator+=(const Point32 &delta) { x += delta.x; y += delta.y; }
+	void operator-=(const Point32 &delta) { x -= delta.x; y -= delta.y; }
+};
+
+class PositionFacing : public Point32 {
+public:
+	int _facing;
+
+	PositionFacing() : Point32(), _facing(0) {}
+	PositionFacing(int xp, int yp, int theFacing) : Point32(xp, yp), _facing(theFacing) {}
+	PositionFacing &operator=(const Point32 &pt) { 
+		x = pt.x; y = pt.y;
+		return *this;
+	}
+};
+
+struct WalkSequence {
+	Common::String _vgsName;
+	bool _horizFlip;
+	Common::Array<byte> _sequences;
+
+	WalkSequence() : _horizFlip(false) {}
+	const byte &operator[](int idx) { return _sequences[idx]; }
+
+	/**
+	 * Load data for the sequence from a stream
+	 */
+	void load(Common::SeekableReadStream &s);
+};
+
+class WalkSequences : public Common::Array < WalkSequence > {
+public:
+	WalkSequences &operator=(const WalkSequences &src);
+};
+
+enum { REVERSE_DIRECTION = 0x80 };
+#define NAMES_COUNT 4
+
+struct ActionType {
+	int _cAnimNum;
+	int _cAnimSpeed;
+	Common::String _names[NAMES_COUNT];
+	int _useFlag;					// Which flag USE will set (if any)
+
+	ActionType();
+
+	/**
+	 * Load the data for the action
+	 */
+	void load(Common::SeekableReadStream &s);
+};
+
+struct UseType: public ActionType {
+	Common::String _target;
+	Common::String _verb;
+
+	UseType();
+
+	/**
+	 * Load the data for the UseType
+	 */
+	void load(Common::SeekableReadStream &s, bool isRoseTattoo);
+	void load3DO(Common::SeekableReadStream &s);
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	void synchronize(Serializer &s);
+};
+
+class BaseObject {
+protected:
+	static SherlockEngine *_vm;
+protected:
+	/**
+	* This will check to see if the object has reached the end of a sequence.
+	* If it has, it switch to whichever next sequence should be started.
+	* @returns		true if the end of a sequence was reached
+	*/
+	bool checkEndOfSequence();
+
+	/**
+	 * Scans through the sequences array and finds the designated sequence.
+	 * It then sets the frame number of the start of that sequence
+	 */
+	void setObjSequence(int seq, bool wait);
+public:
+	static bool _countCAnimFrames;
+public:
+	SpriteType _type;				// Type of object/sprite
+	Common::String _description;	// Description lines
+	byte *_sequences;				// Holds animation sequences
+	ImageFile *_images;				// Sprite images
+	ImageFrame *_imageFrame;		// Pointer to shape in the images
+	int _sequenceNumber;			// Sequence being used
+	int _startSeq;					// Frame sequence starts at
+	int _walkCount;					// Walk counter
+	int _allow;						// Allowed UI commands
+	int _frameNumber;				// Frame number in rame sequence to draw
+	Point32 _position;				// Current position
+	Point32 _delta;					// Momvement amount
+	Common::Point _oldPosition;		// Old position
+	Common::Point _oldSize;			// Image's old size
+	Point32 _goto;					// Walk destination
+
+	int _lookFlag;					// Which flag LOOK   will set (if any)
+	int _requiredFlag[2];			// Object will be hidden if not set
+	Common::Point _noShapeSize;		// Size of a NO_SHAPE
+	int _status;					// Status (open/closed, moved/not)
+	int8 _misc;						// Misc field -- use varies with type
+	int _maxFrames;					// Number of frames
+	int _flags;						// Tells if object can be walked behind
+	AType _aType;					// Tells if this is an object, person, talk, etc.
+	int _lookFrames;				// How many frames to play of the look anim before pausing
+	int _seqCounter;				// How many times this sequence has been executed
+	PositionFacing _lookPosition;	// Where to walk when examining object
+	int _lookcAnim;
+	int _seqStack;					// Allows gosubs to return to calling frame
+	int _seqTo;						// Allows 1-5, 8-3 type sequences encoded in 2 bytes
+	uint _descOffset;					// Tells where description starts in DescText
+	int _seqCounter2;				// Counter of calling frame sequence
+	uint _seqSize;					// Tells where description starts
+	UseType _use[6];				// Serrated Scalpel uses 4, Rose Tattoo 6
+	int _quickDraw;					// Flag telling whether to use quick draw routine or not
+	int _scaleVal;					// Tells how to scale the sprite
+	int _gotoSeq;					// Used by Talk to tell which sequence to goto when able
+	int _talkSeq;					// Tells which talk sequence currently in use (Talk or Listen)
+	int _restoreSlot;				// Used when talk returns to the previous sequence
+public:
+	BaseObject();
+	virtual ~BaseObject() {}
+	static void setVm(SherlockEngine *vm);
+
+	/**
+	 * Returns true if the the object has an Allow Talk Code in the sequence that it's
+	 * currently running, specified by the _talkSeq field of the object. If it's 0,
+	 * then it's a regular sequence. If it's not 0 but below 128, then it's a Talk Sequence.
+	 * If it's above 128, then it's one of the Listen sequences.
+	 */
+	bool hasAborts() const;
+
+	/**
+	 * Check the state of the object
+	 */
+	void checkObject();
+
+	/**
+	 * Checks for codes
+	 * @param name		The name to check for codes
+	 * @param messages	Provides a lookup list of messages that can be printed
+	 * @returns		0 if no codes are found, 1 if codes were found
+	 */
+	int checkNameForCodes(const Common::String &name, FixedTextActionId fixedTextActionId = kFixedTextAction_Invalid);
+
+	/**
+	 * Adjusts the frame and sequence variables of a sprite that corresponds to the current speaker
+	 * so that it points to the beginning of the sequence number's talk sequence in the object's
+	 * sequence buffer
+	 * @param seq	Which sequence to use (if there's more than 1)
+	 * @remarks		1: First talk seq, 2: second talk seq, etc.
+	 */
+	virtual void setObjTalkSequence(int seq) {}
+};
+
+class Sprite: public BaseObject {
+public:
+	Common::String _name;
+	Common::String _examine;			// Examine in-depth description
+	Common::String _pickUp;				// Message for if you can't pick up object
+
+	WalkSequences _walkSequences;		// Holds animation sequences
+	Common::Point _noShapeSize;			// Size of a NO_SHAPE
+	int _status;						// Status: open/closed, moved/not moved
+	int8 _misc;							// Miscellaneous use
+
+	// Rose Tattoo fields
+	ImageFrame *_stopFrames[8];			// Stop/rest frame for each direction
+	ImageFile *_altImages;				// Images used for alternate NPC sequences
+	int _altSeq;						// Which of the sequences the alt graphics apply to (0: main, 1=NPC seq)
+	int _centerWalk;					// Flag telling the walk code to offset the walk destination
+	Common::Point _adjust;				// Fine tuning adjustment to position when drawn
+	int _oldWalkSequence;
+public:
+	Sprite(): BaseObject() { clear(); }
+	virtual ~Sprite() {}
+
+	static void setVm(SherlockEngine *vm) { _vm = vm; }
+
+	/**
+	* Reset the data for the sprite
+	*/
+	void clear();
+
+	/**
+	* Updates the image frame poiner for the sprite
+	*/
+	void setImageFrame();
+
+	/**
+	* Checks the sprite's position to see if it's collided with any special objects
+	*/
+	void checkSprite();
+
+	/**
+	 * Adjusts the frame and sequence variables of a sprite that corresponds to the current speaker
+	 * so that it points to the beginning of the sequence number's talk sequence in the object's
+	 * sequence buffer
+	 * @param seq	Which sequence to use (if there's more than 1)
+	 * @remarks		1: First talk seq, 2: second talk seq, etc.
+	 */
+	virtual void setObjTalkSequence(int seq) {}
+
+	/**
+	* Return frame width
+	*/
+	int frameWidth() const { return _imageFrame ? _imageFrame->_frame.w : 0; }
+
+	/**
+	* Return frame height
+	*/
+	int frameHeight() const { return _imageFrame ? _imageFrame->_frame.h : 0; }
+
+	/**
+	 * Returns the old bounsd for the sprite from the previous frame
+	 */
+	const Common::Rect getOldBounds() const;
+
+	/**
+	 * This adjusts the sprites position, as well as it's animation sequence:
+	 */
+	virtual void adjustSprite() = 0;
+
+	/**
+	 * Bring a moving character using the sprite to a standing position
+	 */
+	virtual void gotoStand() = 0;
+
+	/**
+	 * Set the variables for moving a character from one poisition to another
+	 * in a straight line
+	 */
+	virtual void setWalking() = 0;
+};
+
+enum { OBJ_BEHIND = 1, OBJ_FLIPPED = 2, OBJ_FORWARD = 4, TURNON_OBJ = 0x20, TURNOFF_OBJ = 0x40 };
+#define USE_COUNT 4
+
+class Object: public BaseObject {
+public:
+	Common::String _name;			// Name
+	Common::String _examine;		// Examine in-depth description
+	int _sequenceOffset;
+	int _pickup;
+	int _defaultCommand;			// Default right-click command
+
+	// Serrated Scalpel fields
+	int _pickupFlag;				// Which flag PICKUP will set (if any)
+	ActionType _aOpen;				// Holds data for moving object
+	ActionType _aClose;
+	ActionType _aMove;
+
+	Object();
+	virtual ~Object() {}
+
+	/**
+	 * Load the data for the object
+	 */
+	void load(Common::SeekableReadStream &s, bool isRoseTattoo);
+	void load3DO(Common::SeekableReadStream &s);
+
+	/**
+	 * Toggle the type of an object between hidden and active
+	 */
+	void toggleHidden();
+
+	/**
+	 * Handle setting any flags associated with the object
+	 */
+	void setFlagsAndToggles();
+
+	/**
+	 * Adjusts the sprite's position and animation sequence, advancing by 1 frame.
+	 * If the end of the sequence is reached, the appropriate action is taken.
+	 */
+	void adjustObject();
+
+	/**
+	 * Handles trying to pick up an object. If allowed, plays an y necessary animation for picking
+	 * up the item, and then adds it to the player's inventory
+	 */
+	int pickUpObject(FixedTextActionId fixedTextActionId = kFixedTextAction_Invalid);
+
+	/**
+	 * Return the frame width
+	 */
+	int frameWidth() const { return _imageFrame ? _imageFrame->_frame.w : 0; }
+
+	/**
+	 * Return the frame height
+	 */
+	int frameHeight() const { return _imageFrame ? _imageFrame->_frame.h : 0; }
+
+	/**
+	 * Returns the current bounds for the sprite
+	 */
+	const Common::Rect getNewBounds() const;
+
+	/**
+	 * Returns the bounds for a sprite without a shape
+	 */
+	const Common::Rect getNoShapeBounds() const;
+
+	/**
+	 * Returns the old bounsd for the sprite from the previous frame
+	 */
+	const Common::Rect getOldBounds() const;
+
+	/**
+	 * Adjusts the frame and sequence variables of a sprite that corresponds to the current speaker
+	 * so that it points to the beginning of the sequence number's talk sequence in the object's
+	 * sequence buffer
+	 * @param seq	Which sequence to use (if there's more than 1)
+	 * @remarks		1: First talk seq, 2: second talk seq, etc.
+	 */
+	virtual void setObjTalkSequence(int seq);
+};
+
+struct CAnim {
+	Common::String _name;			// Name
+	Common::Point _position;		// Position
+	int _dataSize;					// Size of uncompressed animation data
+	uint32 _dataOffset;				// offset within room file of animation data
+	int _flags;						// Tells if can be walked behind
+	PositionFacing _goto[2];		// Position Holmes (and NPC in Rose Tattoo) should walk to before anim starts
+	PositionFacing _teleport[2];	// Location Holmes (and NPC) shoul teleport to after playing canim
+
+	// Scalpel specific
+	byte _sequences[MAX_FRAME];		// Animation sequences
+	SpriteType _type;
+
+	// Rose Tattoo specific
+	int _scaleVal;					// How much the canim is scaled
+
+	/**
+	 * Load the data for the animation
+	 */
+	void load(Common::SeekableReadStream &s, bool isRoseTattoo, uint32 dataOffset);
+	void load3DO(Common::SeekableReadStream &s, uint32 dataOffset);
+};
+
+struct SceneImage {
+	ImageFile *_images;				// Object images
+	int _maxFrames;					// How many frames in object
+	int _filesize;					// File size
+
+	SceneImage();
+} ;
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/people.cpp b/engines/sherlock/people.cpp
new file mode 100644
index 0000000000..8057e26204
--- /dev/null
+++ b/engines/sherlock/people.cpp
@@ -0,0 +1,305 @@
+/* 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 "sherlock/people.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/scalpel/scalpel_people.h"
+#include "sherlock/tattoo/tattoo_people.h"
+
+namespace Sherlock {
+
+// Characer animation sequences
+static const uint8 CHARACTER_SEQUENCES[MAX_HOLMES_SEQUENCE][MAX_FRAME] = {
+	{ 29, 1, 2, 3, 4, 5, 6, 7, 0 },		// Walk Right
+	{ 22, 1, 2, 3, 4, 5, 6, 7, 0 },		// Walk Down
+	{ 29, 1, 2, 3, 4, 5, 6, 7, 0 },		// Walk Left
+	{ 15, 1, 2, 3, 4, 5, 6, 7, 0 },		// Walk Up
+	{ 42, 1, 2, 3, 4, 5, 0 },			// Goto Stand Right
+	{ 47, 1, 2, 3, 4, 5, 0 },			// Goto Stand Down
+	{ 42, 1, 2, 3, 4, 5, 0 },			// Goto Stand Left
+	{ 36, 1, 0 },						// Goto Stand Up
+	{ 8, 1, 2, 3, 4, 5, 6, 7, 0 },		// Walk Up Right
+	{ 1, 1, 2, 3, 4, 5, 6, 7, 0 },		// Walk Down Right
+	{ 8, 1, 2, 3, 4, 5, 6, 7, 0 },		// Walk Up Left
+	{ 1, 1, 2, 3, 4, 5, 6, 7, 0 },		// Walk Down Left
+	{ 37, 1, 2, 3, 4, 5, 0 },			// Goto Stand Up Right
+	{ 37, 1, 2, 3, 4, 5, 0 },			// Goto Stand Up Left
+	{ 52, 1, 2, 3, 4, 0 },				// Goto Stand Down Right
+	{ 52, 1, 2, 3, 4, 0 }				// Goto Stand Down Left
+};
+
+// Rose Tattoo walk image libraries
+// Walk resources within WALK.LIB
+const char *const WALK_LIB_NAMES[NUM_IN_WALK_LIB] = {
+	"SVGAWALK.VGS",
+	"COATWALK.VGS",
+	"WATSON.VGS",
+	"NOHAT.VGS",
+	"TUPRIGHT.VGS",
+	"TRIGHT.VGS",
+	"TDOWNRG.VGS",
+	"TWUPRIGH.VGS",
+	"TWRIGHT.VGS",
+	"TWDOWNRG.VGS"
+};
+
+/*----------------------------------------------------------------*/
+
+Person::Person() : Sprite() {
+	_walkLoaded = false;
+	_oldWalkSequence = -1;
+	_srcZone = _destZone = 0;
+}
+
+void Person::goAllTheWay() {
+	Scene &scene = *_vm->_scene;
+	Common::Point srcPt = getSourcePoint();
+
+	// Get the zone the player is currently in
+	_srcZone = scene.whichZone(srcPt);
+	if (_srcZone == -1)
+		_srcZone = scene.closestZone(srcPt);
+
+	// Get the zone of the destination
+	_destZone = scene.whichZone(_walkDest);
+	if (_destZone == -1) {
+		_destZone = scene.closestZone(_walkDest);
+
+		// Check for any restriction of final destination position
+		_walkDest = _vm->_people->restrictToZone(_destZone, _walkDest);
+	}
+
+	// Only do a walk if both zones are acceptable
+	if (_srcZone == -2 || _destZone == -2)
+		return;
+
+	// If the start and dest zones are the same, walk directly to the dest point
+	if (_srcZone == _destZone) {
+		setWalking();
+	} else {
+		// Otherwise a path needs to be formed from the path information
+		int i = scene._walkDirectory[_srcZone][_destZone];
+
+		// See if we need to use a reverse path
+		if (i == -1)
+			i = scene._walkDirectory[_destZone][_srcZone];
+
+		const WalkArray &points = scene._walkPoints[i];
+
+		// See how many points there are between the src and dest zones
+		if (!points._pointsCount || points._pointsCount == -1) {
+			// There are none, so just walk to the new zone
+			setWalking();
+		} else {
+			// There are points, so set up a multi-step path between points
+			// to reach the given destination
+			_walkTo.clear();
+
+			if (scene._walkDirectory[_srcZone][_destZone] != -1) {
+				for (int idx = (int)points.size() - 1; idx >= 0; --idx)
+					_walkTo.push(points[idx]);
+			} else {
+				for (int idx = 0; idx < (int)points.size(); ++idx) {
+					_walkTo.push(points[idx]);
+				}
+			}
+
+			// Final position
+			_walkTo.push(_walkDest);
+
+			// Start walking
+			_walkDest = _walkTo.pop();
+			setWalking();
+		}
+	}
+}
+
+/*----------------------------------------------------------------*/
+
+People *People::init(SherlockEngine *vm) {
+	if (vm->getGameID() == GType_SerratedScalpel)
+		return new Scalpel::ScalpelPeople(vm);
+	else
+		return new Tattoo::TattooPeople(vm);
+}
+
+People::People(SherlockEngine *vm) : _vm(vm) {
+	_holmesOn = true;
+	_allowWalkAbort = true;
+	_portraitLoaded = false;
+	_portraitsOn = true;
+	_clearingThePortrait = false;
+	_talkPics = nullptr;
+	_portraitSide = 0;
+	_speakerFlip = false;
+	_holmesFlip = false;
+	_holmesQuotient = 0;
+	_savedPos = Point32(-1, -1);
+	_savedPos._facing = -1;
+	_forceWalkReload = false;
+	_useWalkLib = false;
+	_walkControl = 0;
+
+	_portrait._sequences = new byte[32];
+}
+
+People::~People() {
+	for (uint idx = 0; idx < _data.size(); ++idx) {
+		if (_data[idx]->_walkLoaded)
+			delete _data[idx]->_images;
+		delete _data[idx];
+	}
+
+	delete _talkPics;
+	delete[] _portrait._sequences;
+}
+
+void People::reset() {
+	SaveManager &saves = *_vm->_saves;
+	Talk &talk = *_vm->_talk;
+	_data[HOLMES]->_description = "Sherlock Holmes!";
+
+	// Note: Serrated Scalpel only uses a single Person slot for Sherlock.. Watson is handled by scene sprites
+	int count = IS_SERRATED_SCALPEL ? 1 : MAX_CHARACTERS;
+	for (int idx = 0; idx < count; ++idx) {
+		Person &p = *_data[idx];
+
+		if (IS_SERRATED_SCALPEL) {
+			p._type = _holmesOn ? CHARACTER : HIDDEN;
+			if (!saves._justLoaded)
+				p._position = Point32(100 * FIXED_INT_MULTIPLIER, 110 * FIXED_INT_MULTIPLIER);
+		} else if (!talk._scriptMoreFlag && !saves._justLoaded) {
+			p._type = (idx == 0) ? CHARACTER : INVALID;
+			p._position = Point32(36 * FIXED_INT_MULTIPLIER, 29 * FIXED_INT_MULTIPLIER);
+			p._use[0]._verb = "";
+			p._use[1]._verb = "";
+		}
+
+		p._sequenceNumber = IS_SERRATED_SCALPEL ? (int)Scalpel::STOP_DOWNRIGHT : (int)Tattoo::STOP_DOWNRIGHT;
+		p._imageFrame = nullptr;
+		p._frameNumber = 1;
+		p._startSeq = 0;
+		p._delta = Point32(0, 0);
+		p._oldPosition = Common::Point(0, 0);
+		p._oldSize = Common::Point(0, 0);
+		p._misc = 0;
+		p._pickUp = "";
+		p._allow = 0;
+		p._noShapeSize = Common::Point(0, 0);
+		p._goto = Common::Point(0, 0);
+		p._status = 0;
+		p._seqTo = 0;
+		p._seqCounter = p._seqCounter2 = 0;
+		p._seqStack = 0;
+		p._gotoSeq = p._talkSeq = 0;
+		p._restoreSlot = 0;
+		p._startSeq = 0;
+		p._altImages = nullptr;
+		p._altSeq = 0;
+		p._centerWalk = true;
+		p._adjust = Common::Point(0, 0);
+
+		// Load the default walk sequences
+		p._walkCount = 0;
+		p._walkTo.clear();
+		p._oldWalkSequence = -1;
+		p._walkSequences.clear();
+		if (IS_SERRATED_SCALPEL) {
+			p._walkSequences.resize(MAX_HOLMES_SEQUENCE);
+			for (int seqIdx = 0; seqIdx < MAX_HOLMES_SEQUENCE; ++seqIdx) {
+				p._walkSequences[seqIdx]._sequences.clear();
+
+				const byte *pSrc = &CHARACTER_SEQUENCES[seqIdx][0];
+				do {
+					p._walkSequences[seqIdx]._sequences.push_back(*pSrc);
+				} while (*pSrc++);
+			}
+		}
+	}
+}
+
+bool People::freeWalk() {
+	bool result = false;
+
+	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+		if (_data[idx]->_walkLoaded) {
+			delete _data[idx]->_images;
+			_data[idx]->_images = nullptr;
+			
+			_data[idx]->_walkLoaded = false;
+			result = true;
+		}
+	}
+
+	return result;
+}
+
+int People::findSpeaker(int speaker) {
+	Scene &scene = *_vm->_scene;
+	const char *portrait = _characters[speaker]._portrait;
+
+	for (int idx = 0; idx < (int)scene._bgShapes.size(); ++idx) {
+		Object &obj = scene._bgShapes[idx];
+
+		if (obj._type == ACTIVE_BG_SHAPE) {
+			Common::String name(obj._name.c_str(), obj._name.c_str() + 4);
+
+			if (name.equalsIgnoreCase(portrait)
+				&& obj._name[4] >= '0' && obj._name[4] <= '9')
+				return idx;
+		}
+	}
+
+	return -1;
+}
+
+void People::clearTalking() {
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+
+	if (_portraitsOn) {
+		Common::Point pt = _portrait._position;
+		int width, height;
+		_portrait._imageFrame = _talkPics ? &(*_talkPics)[0] : (ImageFrame *)nullptr;
+
+		// Flag portrait for removal, and save the size of the frame to use erasing it
+		_portrait._type = REMOVE;
+		_portrait._delta.x = width = _portrait.frameWidth();
+		_portrait._delta.y = height = _portrait.frameHeight();
+
+		delete _talkPics;
+		_talkPics = nullptr;
+
+		// Flag to let the talk code know not to interrupt on the next doBgAnim
+		_clearingThePortrait = true;
+		scene.doBgAnim();
+		_clearingThePortrait = false;
+
+		screen.slamArea(pt.x, pt.y, width, height);
+
+		if (!talk._talkToAbort)
+			_portraitLoaded = false;
+	}
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/people.h b/engines/sherlock/people.h
new file mode 100644
index 0000000000..c47d45145a
--- /dev/null
+++ b/engines/sherlock/people.h
@@ -0,0 +1,184 @@
+/* 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 SHERLOCK_PEOPLE_H
+#define SHERLOCK_PEOPLE_H
+
+#include "common/scummsys.h"
+#include "common/queue.h"
+#include "sherlock/objects.h"
+#include "sherlock/saveload.h"
+
+namespace Sherlock {
+
+enum PeopleId {
+	HOLMES			= 0,
+	WATSON			= 1,
+	MAX_NPC_PATH	= 200
+};
+
+enum {
+	MAP_UP = 1, MAP_UPRIGHT = 2, MAP_RIGHT = 1, MAP_DOWNRIGHT = 4,
+	MAP_DOWN = 5, MAP_DOWNLEFT = 6, MAP_LEFT = 2, MAP_UPLEFT = 8
+};
+
+#define NUM_IN_WALK_LIB 10
+extern const char *const WALK_LIB_NAMES[10];
+
+#define MAX_CHARACTERS (IS_SERRATED_SCALPEL ? 1 : 6)
+
+struct PersonData {
+	const char *_name;
+	const char *_portrait;
+	const byte *_stillSequences;
+	const byte *_talkSequences;
+
+	PersonData(const char *name, const char *portrait, const byte *stillSequences, const byte *talkSequences) :
+		_name(name), _portrait(portrait), _stillSequences(stillSequences), _talkSequences(talkSequences) {}
+};
+
+class Person : public Sprite {
+protected:
+	/**
+	 * Get the source position for a character potentially affected by scaling
+	 */
+	virtual Common::Point getSourcePoint() const = 0;
+public:
+	Common::Queue<Common::Point> _walkTo;
+	int _srcZone, _destZone;
+	bool _walkLoaded;
+	Common::String _portrait;
+	Common::Point _walkDest;
+	Common::String _npcName;
+
+	// Rose Tattoo fields
+	Common::String _walkVGSName;		// Name of walk library person is using
+public:
+	Person();
+	virtual ~Person() {}
+
+	/**
+	 * Called to set the character walking to the current cursor location.
+	 * It uses the zones and the inter-zone points to determine a series
+	 * of steps to walk to get to that position.
+	 */
+	void goAllTheWay();
+
+	/**
+	 * Walk to the co-ordinates passed, and then face the given direction
+	 */
+	virtual void walkToCoords(const Point32 &destPos, int destDir) = 0;
+
+	/**
+	 * Center the visible screen so that the person is in the center of the screen
+	 */
+	virtual void centerScreenOnPerson() {}
+};
+
+class SherlockEngine;
+
+class People {
+protected:
+	SherlockEngine *_vm;
+	Common::Array<Person *> _data;
+
+	People(SherlockEngine *vm);
+public:
+	Common::Array<PersonData> _characters;
+	ImageFile *_talkPics;
+	PositionFacing _savedPos;
+	bool _holmesOn;
+	bool _portraitLoaded;
+	bool _portraitsOn;
+	Object _portrait;
+	bool _clearingThePortrait;
+	bool _allowWalkAbort;
+	int _portraitSide;
+	bool _speakerFlip;
+	bool _holmesFlip;
+	int _holmesQuotient;
+	bool _forceWalkReload;
+	bool _useWalkLib;
+
+	int _walkControl;
+public:
+	static People *init(SherlockEngine *vm);
+	virtual ~People();
+
+	Person &operator[](PeopleId id) { return *_data[id]; }
+	Person &operator[](int idx) { return *_data[idx]; }
+
+	/**
+	 * Reset the player data
+	 */
+	void reset();
+
+	/**
+	 * If the walk data has been loaded, then it will be freed
+	 */
+	bool freeWalk();
+
+	/**
+	 * Turn off any currently active portraits, and removes them from being drawn
+	 */
+	void clearTalking();
+
+	/**
+	* Finds the scene background object corresponding to a specified speaker
+	*/
+	virtual int findSpeaker(int speaker);
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	virtual void synchronize(Serializer &s) = 0;
+
+	/**
+	 * Change the sequence of the scene background object associated with the current speaker.
+	 */
+	virtual void setTalkSequence(int speaker, int sequenceNum = 1) = 0;
+
+	/**
+	 * Load the walking images for Sherlock
+	 */
+	virtual bool loadWalk() = 0;
+
+	/**
+	 * Restrict passed point to zone using Sherlock's positioning rules
+	 */
+	virtual const Common::Point restrictToZone(int zoneId, const Common::Point &destPos) = 0;
+
+	/**
+	 * If the specified speaker is a background object, it will set it so that it uses 
+	 * the Listen Sequence (specified by the sequence number). If the current sequence 
+	 * has an Allow Talk Code in it, the _gotoSeq field will be set so that the object 
+	 * begins listening as soon as it hits the Allow Talk Code. If there is no Abort Code, 
+	 * the Listen Sequence will begin immediately.
+	 * @param speaker		Who is speaking
+	 * @param sequenceNum	Which listen sequence to use
+	 */
+	virtual void setListenSequence(int speaker, int sequenceNum = 1) = 0;
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/resources.cpp b/engines/sherlock/resources.cpp
new file mode 100644
index 0000000000..c4093048bd
--- /dev/null
+++ b/engines/sherlock/resources.cpp
@@ -0,0 +1,399 @@
+/* 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 "sherlock/resources.h"
+#include "sherlock/screen.h"
+#include "sherlock/sherlock.h"
+#include "common/debug.h"
+#include "common/memstream.h"
+
+namespace Sherlock {
+
+Cache::Cache(SherlockEngine *vm) : _vm(vm) {
+}
+
+bool Cache::isCached(const Common::String &filename) const {
+	return _resources.contains(filename);
+}
+
+void Cache::load(const Common::String &name) {
+	// First check if the entry already exists
+	if (_resources.contains(name))
+		return;
+
+	// Open the file for reading
+	Common::File f;
+	if (!f.open(name))
+		error("Could not read file - %s", name.c_str());
+
+	load(name, f);
+
+	f.close();
+}
+
+void Cache::load(const Common::String &name, Common::SeekableReadStream &stream) {
+	// First check if the entry already exists
+	if (_resources.contains(name))
+		return;
+
+	int32 signature = stream.readUint32BE();
+	stream.seek(0);
+
+	// Allocate a new cache entry
+	_resources[name] = CacheEntry();
+	CacheEntry &cacheEntry = _resources[name];
+
+	// Check whether the file is compressed
+	if (signature == MKTAG('L', 'Z', 'V', 26)) {
+		// It's compressed, so decompress the file and store its data in the cache entry
+		Common::SeekableReadStream *decompressed = _vm->_res->decompress(stream);
+		cacheEntry.resize(decompressed->size());
+		decompressed->read(&cacheEntry[0], decompressed->size());
+
+		delete decompressed;
+	} else {
+		// It's not, so read the raw data of the file into the cache entry
+		cacheEntry.resize(stream.size());
+		stream.read(&cacheEntry[0], stream.size());
+	}
+}
+
+Common::SeekableReadStream *Cache::get(const Common::String &filename) const {
+	// Return a memory stream that encapsulates the data
+	const CacheEntry &cacheEntry = _resources[filename];
+	return new Common::MemoryReadStream(&cacheEntry[0], cacheEntry.size());
+}
+
+/*----------------------------------------------------------------*/
+
+Resources::Resources(SherlockEngine *vm) : _vm(vm), _cache(vm) {
+	_resourceIndex = -1;
+
+	if (_vm->_interactiveFl) {
+		if (!IS_3DO) {
+			addToCache("vgs.lib");
+			addToCache("talk.lib");
+			addToCache("journal.txt");
+
+			if (IS_SERRATED_SCALPEL) {
+				addToCache("sequence.txt");
+				addToCache("portrait.lib");
+			} else {
+				addToCache("walk.lib");
+			}
+		} else {
+			// 3DO
+
+			// ITEM data from VGS.LIB is in ITEM.LIB
+			addToCache("item.lib");
+
+			// talk.lib - resources themselves seem to be the same, although a few texts were slightly changed
+			addToCache("talk.lib");
+
+			// remaining files are missing
+			// portraits were replaced with FMV
+		}
+	}
+}
+
+void Resources::addToCache(const Common::String &filename) {
+	// Return immediately if the library has already been loaded
+	if (_indexes.contains(filename))
+		return;
+	
+	_cache.load(filename);
+
+	// Check to see if the file is a library
+	Common::SeekableReadStream *stream = load(filename);
+	uint32 header = stream->readUint32BE();
+
+	if (header == MKTAG('L', 'I', 'B', 26))
+		loadLibraryIndex(filename, stream, false);
+	else if (header == MKTAG('L', 'I', 'C', 26))
+		loadLibraryIndex(filename, stream, true);
+
+	delete stream;
+}
+
+void Resources::addToCache(const Common::String &filename, const Common::String &libFilename) {
+	// Get the resource
+	Common::SeekableReadStream *stream = load(filename, libFilename);
+
+	_cache.load(filename, *stream);
+
+	delete stream;
+}
+
+void Resources::addToCache(const Common::String &filename, Common::SeekableReadStream &stream) {
+	_cache.load(filename, stream);
+}
+
+Common::SeekableReadStream *Resources::load(const Common::String &filename) {
+	// First check if the file is directly in the cache
+	if (_cache.isCached(filename))
+		return _cache.get(filename);
+
+	// Secondly, iterate through any loaded library file looking for a resource
+	// that has the same name
+	for (LibraryIndexes::iterator i = _indexes.begin(); i != _indexes.end(); ++i) {
+		if (i->_value.contains(filename)) {
+			// Get a stream reference to the given library file
+			Common::SeekableReadStream *stream = load(i->_key);
+			LibraryEntry &entry = i->_value[filename];
+			_resourceIndex = entry._index;
+
+			stream->seek(entry._offset);
+			Common::SeekableReadStream *resStream = stream->readStream(entry._size);
+			decompressIfNecessary(resStream);
+
+			delete stream;
+			return resStream;
+		}
+	}
+
+	// At this point, fall back on a physical file with the given name
+	Common::File f;
+	if (!f.open(filename))
+		error("Could not load file - %s", filename.c_str());
+
+	Common::SeekableReadStream *stream = f.readStream(f.size());
+	f.close();
+	decompressIfNecessary(stream);
+
+	return stream;
+}
+
+void Resources::decompressIfNecessary(Common::SeekableReadStream *&stream) {
+	bool isCompressed = stream->readUint32BE() == MKTAG('L', 'Z', 'V', 26);
+
+	if (isCompressed) {
+		int outSize = stream->readUint32LE();
+		Common::SeekableReadStream *newStream = decompressLZ(*stream, outSize);
+		delete stream;
+		stream = newStream;
+	} else {
+		stream->seek(-4, SEEK_CUR);
+	}
+}
+
+Common::SeekableReadStream *Resources::load(const Common::String &filename, const Common::String &libraryFile,
+		bool suppressErrors) {
+	// Open up the library for access
+	Common::SeekableReadStream *libStream = load(libraryFile);
+
+	// Check if the library has already had its index read, and if not, load it
+	if (!_indexes.contains(libraryFile))
+		loadLibraryIndex(libraryFile, libStream, false);
+	LibraryIndex &libIndex = _indexes[libraryFile];
+
+	// Handle if resource is not present
+	if (!libIndex.contains(filename)) {
+		if (!suppressErrors)
+			error("Could not find resource - %s", filename.c_str());
+
+		delete libStream;
+		return nullptr;
+	}
+
+	// Extract the data for the specified resource and return it
+	LibraryEntry &entry = libIndex[filename];
+	libStream->seek(entry._offset);
+	Common::SeekableReadStream *stream = libStream->readStream(entry._size);
+	decompressIfNecessary(stream);
+
+	delete libStream;
+	return stream;
+}
+
+bool Resources::exists(const Common::String &filename) const {
+	Common::File f;
+	return f.exists(filename) || _cache.isCached(filename);
+}
+
+void Resources::loadLibraryIndex(const Common::String &libFilename,
+		Common::SeekableReadStream *stream, bool isNewStyle) {
+	uint32 offset, nextOffset;
+
+	// Return immediately if the library has already been loaded
+	if (_indexes.contains(libFilename))
+		return;
+
+	// Create an index entry
+	_indexes[libFilename] = LibraryIndex();
+	LibraryIndex &index = _indexes[libFilename];
+
+	// Read in the number of resources
+	stream->seek(4);
+	int count = 0;
+
+	if (!IS_3DO) {
+		// PC
+		count = stream->readUint16LE();
+
+		if (isNewStyle)
+			stream->seek((count + 1) * 8, SEEK_CUR);
+
+		// Loop through reading in the entries
+		for (int idx = 0; idx < count; ++idx) {
+			// Read the name of the resource
+			char resName[13];
+			stream->read(resName, 13);
+			resName[12] = '\0';
+
+			// Read the offset
+			offset = stream->readUint32LE();
+
+			if (idx == (count - 1)) {
+				nextOffset = stream->size();
+			} else {
+				// Read the size by jumping forward to read the next entry's offset
+				stream->seek(13, SEEK_CUR);
+				nextOffset = stream->readUint32LE();
+				stream->seek(-17, SEEK_CUR);
+			}
+
+			// Add the entry to the index
+			index[resName] = LibraryEntry(idx, offset, nextOffset - offset);
+		}
+
+	} else {
+		// 3DO
+		count = stream->readUint16BE();
+
+		// 3DO header
+		// Loop through reading in the entries
+
+		// Read offset of first entry
+		offset = stream->readUint32BE();
+
+		for (int idx = 0; idx < count; ++idx) {
+
+			// Read the name of the resource
+			char resName[13];
+			stream->read(resName, 13);
+			resName[12] = '\0';
+
+			stream->skip(3); // filler
+
+			if (idx == (count - 1)) {
+				nextOffset = stream->size();
+			} else {
+				// Read the offset of the next entry
+				nextOffset = stream->readUint32BE();
+			}
+
+			// Add the entry to the index
+			index[resName] = LibraryEntry(idx, offset, nextOffset - offset);
+
+			// use next offset as current offset
+			offset = nextOffset;
+		}
+	}
+}
+
+int Resources::resourceIndex() const {
+	return _resourceIndex;
+}
+
+void Resources::getResourceNames(const Common::String &libraryFile, Common::StringArray &names) {
+	addToCache(libraryFile);
+	LibraryIndex &libIndex = _indexes[libraryFile];
+	for (LibraryIndex::iterator i = libIndex.begin(); i != libIndex.end(); ++i) {
+		names.push_back(i->_key);
+	}
+}
+
+Common::SeekableReadStream *Resources::decompress(Common::SeekableReadStream &source) {
+	// This variation can't be used by Rose Tattoo, since compressed resources include the input size,
+	// not the output size. Which means their decompression has to be done via passed buffers
+	assert(IS_SERRATED_SCALPEL);
+
+	uint32 id = source.readUint32BE();
+	assert(id == MKTAG('L', 'Z', 'V', 0x1A));
+
+	uint32 outputSize = source.readUint32LE();
+	return decompressLZ(source, outputSize);
+}
+
+Common::SeekableReadStream *Resources::decompress(Common::SeekableReadStream &source, uint32 outSize) {
+	int inSize = IS_ROSE_TATTOO ? source.readSint32LE() : -1;
+	byte *outBuffer = (byte *)malloc(outSize);
+	Common::MemoryReadStream *outStream = new Common::MemoryReadStream(outBuffer, outSize, DisposeAfterUse::YES);
+
+	decompressLZ(source, outBuffer, outSize, inSize);
+
+	return outStream;
+}
+
+void Resources::decompress(Common::SeekableReadStream &source, byte *buffer, uint32 outSize) {
+	int inputSize = IS_ROSE_TATTOO ? source.readSint32LE() : -1;
+
+	decompressLZ(source, buffer, outSize, inputSize);
+}
+
+Common::SeekableReadStream *Resources::decompressLZ(Common::SeekableReadStream &source, uint32 outSize) {
+	byte *dataOut = (byte *)malloc(outSize);
+	decompressLZ(source, dataOut, outSize, -1);
+
+	return new Common::MemoryReadStream(dataOut, outSize, DisposeAfterUse::YES);
+}
+
+void Resources::decompressLZ(Common::SeekableReadStream &source, byte *outBuffer, int32 outSize, int32 inSize) {
+	byte lzWindow[4096];
+	uint16 lzWindowPos;
+	uint16 cmd;
+
+	byte *outBufferEnd = outBuffer + outSize;
+	int endPos = source.pos() + inSize;
+
+	memset(lzWindow, 0xFF, 0xFEE);
+	lzWindowPos = 0xFEE;
+	cmd = 0;
+
+	do {
+		cmd >>= 1;
+		if (!(cmd & 0x100))
+			cmd = source.readByte() | 0xFF00;
+
+		if (cmd & 1) {
+			byte literal = source.readByte();
+			*outBuffer++ = literal;
+			lzWindow[lzWindowPos] = literal;
+			lzWindowPos = (lzWindowPos + 1) & 0x0FFF;
+		} else {
+			int copyPos, copyLen;
+			copyPos = source.readByte();
+			copyLen = source.readByte();
+			copyPos = copyPos | ((copyLen & 0xF0) << 4);
+			copyLen = (copyLen & 0x0F) + 3;
+			while (copyLen--) {
+				byte literal = lzWindow[copyPos];
+				copyPos = (copyPos + 1) & 0x0FFF;
+				*outBuffer++ = literal;
+				lzWindow[lzWindowPos] = literal;
+				lzWindowPos = (lzWindowPos + 1) & 0x0FFF;
+			}
+		}
+	} while ((outSize == -1 || outBuffer < outBufferEnd) && (inSize == -1 || source.pos() < endPos));
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/resources.h b/engines/sherlock/resources.h
new file mode 100644
index 0000000000..99d58a51b1
--- /dev/null
+++ b/engines/sherlock/resources.h
@@ -0,0 +1,176 @@
+/* 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 SHERLOCK_RESOURCES_H
+#define SHERLOCK_RESOURCES_H
+
+#include "common/array.h"
+#include "common/file.h"
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+#include "common/rect.h"
+#include "common/str.h"
+#include "common/str-array.h"
+#include "common/stream.h"
+#include "graphics/surface.h"
+
+namespace Sherlock {
+
+typedef Common::Array<byte> CacheEntry;
+typedef Common::HashMap<Common::String, CacheEntry, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> CacheHash;
+
+struct LibraryEntry {
+	uint32 _offset, _size;
+	int _index;
+
+	LibraryEntry() : _index(0), _offset(0), _size(0) {}
+	LibraryEntry(int index, uint32 offset, uint32 size) :
+		_index(index), _offset(offset), _size(size) {}
+};
+typedef Common::HashMap<Common::String, LibraryEntry, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> LibraryIndex;
+typedef Common::HashMap<Common::String, LibraryIndex, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> LibraryIndexes;
+
+class SherlockEngine;
+
+class Cache {
+private:
+	SherlockEngine *_vm;
+	CacheHash _resources;
+public:
+	Cache(SherlockEngine *_vm);
+
+	/**
+	 * Returns true if a given file is currently being cached
+	 */
+	bool isCached(const Common::String &filename) const;
+
+	/**
+	 * Loads a file into the cache if it's not already present, and returns it.
+	 * If the file is LZW compressed, automatically decompresses it and loads
+	 * the uncompressed version into memory
+	 */
+	void load(const Common::String &name);
+
+	/**
+	 * Load a cache entry based on a passed stream
+	 */
+	void load(const Common::String &name, Common::SeekableReadStream &stream);
+
+	/**
+	 * Get a file from the cache
+	 */
+	Common::SeekableReadStream *get(const Common::String &filename) const;
+};
+
+class Resources {
+private:
+	SherlockEngine *_vm;
+	Cache _cache;
+	LibraryIndexes _indexes;
+	int _resourceIndex;
+
+	/**
+	 * Reads in the index from a library file, and caches its index for later use
+	 */
+	void loadLibraryIndex(const Common::String &libFilename, Common::SeekableReadStream *stream, bool isNewStyle);
+public:
+	Resources(SherlockEngine *vm);
+
+	/**
+	 * Adds the specified file to the cache. If it's a library file, takes care of
+	 * loading its index for future use
+	 */
+	void addToCache(const Common::String &filename);
+	
+	/**
+	 * Adds a resource from a library file to the cache
+	 */
+	void addToCache(const Common::String &filename, const Common::String &libFilename);
+	
+	/**
+	 * Adds a given stream to the cache under the given name
+	 */
+	void addToCache(const Common::String &filename, Common::SeekableReadStream &stream);
+
+	bool isInCache(const Common::String &filename) const { return _cache.isCached(filename); }
+
+	/**
+	 * Checks the passed stream, and if is compressed, deletes it and replaces it with its uncompressed data
+	 */
+	void decompressIfNecessary(Common::SeekableReadStream *&stream);
+
+	/**
+	 * Returns a stream for a given file
+	 */
+	Common::SeekableReadStream *load(const Common::String &filename);
+
+	/**
+	 * Loads a specific resource from a given library file
+	 */
+	Common::SeekableReadStream *load(const Common::String &filename, const Common::String &libraryFile, bool suppressErrors = false);
+
+	/**
+	 * Returns true if the given file exists on disk or in the cache
+	 */
+	bool exists(const Common::String &filename) const;
+
+	/**
+	 * Returns the index of the last loaded resource in its given library file.
+	 * This will be used primarily when loading talk files, so the engine can
+	 * update the given conversation number in the journal
+	 */
+	int resourceIndex() const;
+
+	/**
+	 * Produces a list of all resource names within a file. Used by the debugger.
+	 */
+	void getResourceNames(const Common::String &libraryFile, Common::StringArray &names);
+
+	/**
+	 * Decompresses LZW compressed data
+	 */
+	Common::SeekableReadStream *decompress(Common::SeekableReadStream &source);
+
+	/**
+	 * Decompresses LZW compressed data
+	 */
+	Common::SeekableReadStream *decompress(Common::SeekableReadStream &source, uint32 outSize);
+
+	/**
+	 * Decompresses LZW compressed data
+	 */
+	void decompress(Common::SeekableReadStream &source, byte *buffer, uint32 outSize);
+
+	/**
+	 * Decompresses LZW compressed data
+	 */
+	static Common::SeekableReadStream *decompressLZ(Common::SeekableReadStream &source, uint32 outSize);
+
+	/**
+	 * Decompresses LZW compressed data
+	 */
+	static void decompressLZ(Common::SeekableReadStream &source, byte *outBuffer, int32 outSize, int32 inSize);
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/saveload.cpp b/engines/sherlock/saveload.cpp
new file mode 100644
index 0000000000..f32552c7ea
--- /dev/null
+++ b/engines/sherlock/saveload.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 "sherlock/saveload.h"
+#include "sherlock/surface.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/scalpel/scalpel_saveload.h"
+#include "sherlock/tattoo/widget_files.h"
+#include "common/system.h"
+#include "graphics/scaler.h"
+#include "graphics/thumbnail.h"
+
+namespace Sherlock {
+
+const char *const EMPTY_SAVEGAME_SLOT = "-EMPTY-";
+static const char *const SAVEGAME_STR = "SHLK";
+#define SAVEGAME_STR_SIZE 4
+
+/*----------------------------------------------------------------*/
+
+SaveManager *SaveManager::init(SherlockEngine *vm, const Common::String &target) {
+	if (vm->getGameID() == GType_SerratedScalpel)
+		return new Scalpel::ScalpelSaveManager(vm, target);
+	else
+		return new Tattoo::WidgetFiles(vm, target);
+}
+
+SaveManager::SaveManager(SherlockEngine *vm, const Common::String &target) :
+		_vm(vm), _target(target) {
+	_saveThumb = nullptr;
+	_justLoaded = false;
+	_savegameIndex = 0;
+}
+
+SaveManager::~SaveManager() {
+	if (_saveThumb) {
+		_saveThumb->free();
+		delete _saveThumb;
+	}
+}
+
+void SaveManager::createSavegameList() {
+	Screen &screen = *_vm->_screen;
+
+	_savegames.clear();
+	for (int idx = 0; idx < MAX_SAVEGAME_SLOTS; ++idx)
+		_savegames.push_back(EMPTY_SAVEGAME_SLOT);
+
+	SaveStateList saveList = getSavegameList(_target);
+	for (uint idx = 0; idx < saveList.size(); ++idx) {
+		int slot = saveList[idx].getSaveSlot();
+		if (slot >= 0 && slot < MAX_SAVEGAME_SLOTS)
+			_savegames[slot] = saveList[idx].getDescription();
+	}
+
+	// Ensure the names will fit on the screen
+	for (uint idx = 0; idx < _savegames.size(); ++idx) {
+		int width = screen.stringWidth(_savegames[idx]) + 24;
+		if (width > 308) {
+			// It won't fit in, so remove characters until it does
+			do {
+				width -= screen.charWidth(_savegames[idx].lastChar());
+				_savegames[idx].deleteLastChar();
+			} while (width > 300);
+		}
+	}
+}
+
+SaveStateList SaveManager::getSavegameList(const Common::String &target) {
+	Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+	Common::StringArray filenames;
+	Common::String saveDesc;
+	Common::String pattern = Common::String::format("%s.0??", target.c_str());
+	SherlockSavegameHeader header;
+
+	filenames = saveFileMan->listSavefiles(pattern);
+	sort(filenames.begin(), filenames.end());   // Sort to get the files in numerical order
+
+	SaveStateList saveList;
+	for (Common::StringArray::const_iterator file = filenames.begin(); file != filenames.end(); ++file) {
+		const char *ext = strrchr(file->c_str(), '.');
+		int slot = ext ? atoi(ext + 1) : -1;
+
+		if (slot >= 0 && slot < MAX_SAVEGAME_SLOTS) {
+			Common::InSaveFile *in = g_system->getSavefileManager()->openForLoading(*file);
+
+			if (in) {
+				if (!readSavegameHeader(in, header))
+					continue;
+
+				saveList.push_back(SaveStateDescriptor(slot, header._saveName));
+
+				header._thumbnail->free();
+				delete header._thumbnail;
+				delete in;
+			}
+		}
+	}
+
+	return saveList;
+}
+
+bool SaveManager::readSavegameHeader(Common::InSaveFile *in, SherlockSavegameHeader &header) {
+	char saveIdentBuffer[SAVEGAME_STR_SIZE + 1];
+	header._thumbnail = nullptr;
+
+	// Validate the header Id
+	in->read(saveIdentBuffer, SAVEGAME_STR_SIZE + 1);
+	if (strncmp(saveIdentBuffer, SAVEGAME_STR, SAVEGAME_STR_SIZE))
+		return false;
+
+	header._version = in->readByte();
+	if (header._version < MINIMUM_SAVEGAME_VERSION || header._version > CURRENT_SAVEGAME_VERSION)
+		return false;
+
+	// Read in the string
+	header._saveName.clear();
+	char ch;
+	while ((ch = (char)in->readByte()) != '\0') header._saveName += ch;
+
+	// Get the thumbnail
+	header._thumbnail = Graphics::loadThumbnail(*in);
+	if (!header._thumbnail)
+		return false;
+
+	// Read in save date/time
+	header._year = in->readSint16LE();
+	header._month = in->readSint16LE();
+	header._day = in->readSint16LE();
+	header._hour = in->readSint16LE();
+	header._minute = in->readSint16LE();
+	header._totalFrames = in->readUint32LE();
+
+	return true;
+}
+
+void SaveManager::writeSavegameHeader(Common::OutSaveFile *out, SherlockSavegameHeader &header) {
+	// Write out a savegame header
+	out->write(SAVEGAME_STR, SAVEGAME_STR_SIZE + 1);
+
+	out->writeByte(CURRENT_SAVEGAME_VERSION);
+
+	// Write savegame name
+	out->write(header._saveName.c_str(), header._saveName.size());
+	out->writeByte('\0');
+
+	// Handle the thumbnail. If there's already one set by the game, create one
+	if (!_saveThumb)
+		createThumbnail();
+	Graphics::saveThumbnail(*out, *_saveThumb);
+
+	_saveThumb->free();
+	delete _saveThumb;
+	_saveThumb = nullptr;
+
+	// Write out the save date/time
+	TimeDate td;
+	g_system->getTimeAndDate(td);
+	out->writeSint16LE(td.tm_year + 1900);
+	out->writeSint16LE(td.tm_mon + 1);
+	out->writeSint16LE(td.tm_mday);
+	out->writeSint16LE(td.tm_hour);
+	out->writeSint16LE(td.tm_min);
+	out->writeUint32LE(_vm->_events->getFrameCounter());
+}
+
+void SaveManager::createThumbnail() {
+	if (_saveThumb) {
+		_saveThumb->free();
+		delete _saveThumb;
+	}
+
+	_saveThumb = new Graphics::Surface();
+
+	if (!IS_3DO) {
+		uint8 thumbPalette[PALETTE_SIZE];
+		_vm->_screen->getPalette(thumbPalette);
+		::createThumbnail(_saveThumb, (const byte *)_vm->_screen->getPixels(), SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT, thumbPalette);
+	} else {
+		::createThumbnailFromScreen(_saveThumb);
+	}
+}
+
+void SaveManager::loadGame(int slot) {
+	Events &events = *_vm->_events;
+	Common::InSaveFile *saveFile = g_system->getSavefileManager()->openForLoading(
+		generateSaveName(slot));
+	if (!saveFile)
+		return;
+
+	// Load the savaegame header
+	SherlockSavegameHeader header;
+	if (!readSavegameHeader(saveFile, header))
+		error("Invalid savegame");
+
+	if (header._thumbnail) {
+		header._thumbnail->free();
+		delete header._thumbnail;
+	}
+
+	// Synchronize the savegame data
+	Serializer s(saveFile, nullptr);
+	s.setSaveVersion(header._version);
+	synchronize(s);
+
+	delete saveFile;
+	events.clearEvents();
+}
+
+void SaveManager::saveGame(int slot, const Common::String &name) {
+	Events &events = *_vm->_events;
+	Common::OutSaveFile *out = g_system->getSavefileManager()->openForSaving(
+		generateSaveName(slot));
+
+	SherlockSavegameHeader header;
+	header._saveName = name;
+	writeSavegameHeader(out, header);
+
+	// Synchronize the savegame data
+	Serializer s(nullptr, out);
+	s.setSaveVersion(CURRENT_SAVEGAME_VERSION);
+	synchronize(s);
+
+	out->finalize();
+	delete out;
+	events.clearEvents();
+}
+
+Common::String SaveManager::generateSaveName(int slot) {
+	return Common::String::format("%s.%03d", _target.c_str(), slot);
+}
+
+void SaveManager::synchronize(Serializer &s) {
+	Inventory &inv = *_vm->_inventory;
+	Journal &journal = *_vm->_journal;
+	Map &map = *_vm->_map;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+
+	int oldFont = screen.fontNumber();
+
+	inv.synchronize(s);
+	journal.synchronize(s);
+	people.synchronize(s);
+	map.synchronize(s);
+	scene.synchronize(s);
+	screen.synchronize(s);
+	talk.synchronize(s);
+	_vm->synchronize(s);
+
+	if (screen.fontNumber() != oldFont)
+		journal.resetPosition();
+
+	_justLoaded = s.isLoading();
+}
+
+bool SaveManager::isSlotEmpty(int slot) const {
+	return _savegames[slot].equalsIgnoreCase(EMPTY_SAVEGAME_SLOT);
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/saveload.h b/engines/sherlock/saveload.h
new file mode 100644
index 0000000000..f4f3e7cfd9
--- /dev/null
+++ b/engines/sherlock/saveload.h
@@ -0,0 +1,150 @@
+/* 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 SHERLOCK_SAVELOAD_H
+#define SHERLOCK_SAVELOAD_H
+
+#include "common/scummsys.h"
+#include "common/savefile.h"
+#include "common/serializer.h"
+#include "common/str-array.h"
+#include "engines/savestate.h"
+#include "graphics/surface.h"
+
+namespace Sherlock {
+
+#define MAX_SAVEGAME_SLOTS 99
+#define ONSCREEN_FILES_COUNT 5
+
+enum {
+	CURRENT_SAVEGAME_VERSION = 4,
+	MINIMUM_SAVEGAME_VERSION = 4
+};
+
+enum SaveMode { SAVEMODE_NONE = 0, SAVEMODE_LOAD = 1, SAVEMODE_SAVE = 2 };
+
+extern const char *const EMPTY_SAVEGAME_SLOT;
+
+struct SherlockSavegameHeader {
+	uint8 _version;
+	Common::String _saveName;
+	Graphics::Surface *_thumbnail;
+	int _year, _month, _day;
+	int _hour, _minute;
+	int _totalFrames;
+};
+
+class SherlockEngine;
+
+
+/**
+ * Derived serializer class with extra synchronization types
+ */
+class Serializer : public Common::Serializer {
+public:
+	Serializer(Common::SeekableReadStream *in, Common::WriteStream *out) : Common::Serializer(in, out) {}
+
+	/**
+	 * New method to allow setting the version
+	 */
+	void setSaveVersion(byte version) { _version = version; }
+};
+
+class SaveManager {
+protected:
+	SherlockEngine *_vm;
+	Common::String _target;
+	Graphics::Surface *_saveThumb;
+
+	/**
+	 * Build up a savegame list, with empty slots given an explicit Empty message
+	 */
+	void createSavegameList();
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	void synchronize(Serializer &s);
+public:
+	Common::StringArray _savegames;
+	int _savegameIndex;
+	bool _justLoaded;
+public:
+	static SaveManager *init(SherlockEngine *vm, const Common::String &target);
+	SaveManager(SherlockEngine *vm, const Common::String &target);
+	virtual ~SaveManager();
+
+	/**
+	 * Creates a thumbnail for the current on-screen contents
+	 */
+	void createThumbnail();
+
+	/**
+	 * Load a list of savegames
+	 */
+	static SaveStateList getSavegameList(const Common::String &target);
+
+	/**
+	 * Support method that generates a savegame name
+	 * @param slot		Slot number
+	 */
+	Common::String generateSaveName(int slot);
+
+	/**
+	 * Write out the header information for a savegame
+	 */
+	void writeSavegameHeader(Common::OutSaveFile *out, SherlockSavegameHeader &header);
+
+	/**
+	 * Read in the header information for a savegame
+	 */
+	static bool readSavegameHeader(Common::InSaveFile *in, SherlockSavegameHeader &header);
+
+	/**
+	 * Return the index of the button the mouse is over, if any
+	 */
+	int getHighlightedButton() const;
+
+	/**
+	 * Handle highlighting buttons
+	 */
+	void highlightButtons(int btnIndex);
+
+	/**
+	 * Load the game in the specified slot
+	 */
+	void loadGame(int slot);
+	
+	/**
+	 * Save the game in the specified slot with the given name
+	 */
+	void saveGame(int slot, const Common::String &name);
+
+	/**
+	 * Returns true if the given save slot is empty
+	 */
+	bool isSlotEmpty(int slot) const;
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/3do/movie_decoder.cpp b/engines/sherlock/scalpel/3do/movie_decoder.cpp
new file mode 100644
index 0000000000..da4d08ca47
--- /dev/null
+++ b/engines/sherlock/scalpel/3do/movie_decoder.cpp
@@ -0,0 +1,467 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/stream.h"
+#include "common/textconsole.h"
+
+#include "audio/audiostream.h"
+#include "audio/decoders/raw.h"
+#include "audio/decoders/3do.h"
+
+#include "sherlock/scalpel/3do/movie_decoder.h"
+#include "image/codecs/cinepak.h"
+
+// for Test-Code
+#include "common/system.h"
+#include "common/events.h"
+#include "common/keyboard.h"
+#include "engines/engine.h"
+#include "engines/util.h"
+#include "graphics/palette.h"
+#include "graphics/pixelformat.h"
+#include "graphics/surface.h"
+
+namespace Sherlock {
+
+Scalpel3DOMovieDecoder::Scalpel3DOMovieDecoder()
+	: _stream(0), _videoTrack(0), _audioTrack(0) {
+	_streamVideoOffset = 0;
+	_streamAudioOffset = 0;
+}
+
+Scalpel3DOMovieDecoder::~Scalpel3DOMovieDecoder() {
+	close();
+}
+
+bool Scalpel3DOMovieDecoder::loadStream(Common::SeekableReadStream *stream) {
+	uint32 videoSubType    = 0;
+	uint32 videoCodecTag   = 0;
+	uint32 videoHeight     = 0;
+	uint32 videoWidth      = 0;
+	uint32 videoFrameCount = 0;
+	uint32 audioSubType    = 0;
+	uint32 audioCodecTag   = 0;
+	uint32 audioChannels   = 0;
+	uint32 audioSampleRate = 0;
+
+	close();
+
+	_stream = stream;
+	_streamVideoOffset = 0;
+	_streamAudioOffset = 0;
+
+	// Look for packets that we care about
+	static const int maxPacketCheckCount = 20;
+	for (int i = 0; i < maxPacketCheckCount; i++) {
+		uint32 chunkTag = _stream->readUint32BE();
+		uint32 chunkSize = _stream->readUint32BE() - 8;
+
+		// Bail out if done
+		if (_stream->eos())
+			break;
+
+		uint32 dataStartOffset = _stream->pos();
+
+		switch (chunkTag) {
+		case MKTAG('F','I','L','M'): {
+			// See if this is a FILM header
+			_stream->skip(4); // time stamp (based on 240 per second)
+			_stream->skip(4); // Unknown 0x00000000
+			videoSubType = _stream->readUint32BE();
+
+			switch (videoSubType) {
+			case MKTAG('F', 'H', 'D', 'R'):
+				// FILM header found
+				if (_videoTrack) {
+					warning("Sherlock 3DO movie: Multiple FILM headers found");
+					close();
+					return false;
+				}
+				_stream->readUint32BE();
+				videoCodecTag = _stream->readUint32BE();
+				videoHeight = _stream->readUint32BE();
+				videoWidth = _stream->readUint32BE();
+				_stream->skip(4); // time scale
+				videoFrameCount = _stream->readUint32BE();
+
+				_videoTrack = new StreamVideoTrack(videoWidth, videoHeight, videoCodecTag, videoFrameCount);
+				addTrack(_videoTrack);
+				break;
+
+			case MKTAG('F', 'R', 'M', 'E'):
+				break;
+
+			default:
+				warning("Sherlock 3DO movie: Unknown subtype inside FILM packet");
+				close();
+				return false;
+			}
+			break;
+		}
+
+		case MKTAG('S','N','D','S'): {
+			_stream->skip(8);
+			audioSubType = _stream->readUint32BE();
+
+			switch (audioSubType) {
+			case MKTAG('S', 'H', 'D', 'R'):
+				// Audio header
+
+				// Bail if we already have a track
+				if (_audioTrack) {
+					warning("Sherlock 3DO movie: Multiple SNDS headers found");
+					close();
+					return false;
+				}
+
+				// OK, this is the start of a audio stream
+				_stream->readUint32BE(); // Version, always 0x00000000
+				_stream->readUint32BE(); // Unknown 0x00000008 ?!
+				_stream->readUint32BE(); // Unknown 0x00007500
+				_stream->readUint32BE(); // Unknown 0x00004000
+				_stream->readUint32BE(); // Unknown 0x00000000
+				_stream->readUint32BE(); // Unknown 0x00000010
+				audioSampleRate = _stream->readUint32BE();			
+				audioChannels = _stream->readUint32BE();
+				audioCodecTag = _stream->readUint32BE();
+				_stream->readUint32BE(); // Unknown 0x00000004 compression ratio?
+				_stream->readUint32BE(); // Unknown 0x00000A2C
+
+				_audioTrack = new StreamAudioTrack(audioCodecTag, audioSampleRate, audioChannels);
+				addTrack(_audioTrack);
+				break;
+
+			case MKTAG('S', 'S', 'M', 'P'):
+				// Audio data
+				break;
+			default:
+				warning("Sherlock 3DO movie: Unknown subtype inside FILM packet");
+				close();
+				return false;
+			}
+			break;
+		}
+
+		case MKTAG('C','T','R','L'):
+		case MKTAG('F','I','L','L'): // filler chunk, fills to certain boundary
+		case MKTAG('D','A','C','Q'):
+		case MKTAG('J','O','I','N'): // add cel data (not used in sherlock)
+			// Ignore these chunks
+			break;
+
+		case MKTAG('S','H','D','R'):
+			// Happens for EA logo, seems to be garbage data right at the start of the file
+			break;
+
+		default:
+			warning("Unknown chunk-tag '%s' inside Sherlock 3DO movie", tag2str(chunkTag));
+			close();
+			return false;
+		}
+
+		if ((_videoTrack) && (_audioTrack))
+			break;
+
+		// Seek to next chunk
+		_stream->seek(dataStartOffset + chunkSize);
+	}
+
+	// Bail if we didn't find video + audio
+	if ((!_videoTrack) || (!_audioTrack)) {
+		close();
+		return false;
+	}
+
+	// Rewind back to the beginning
+	_stream->seek(0);
+
+	return true;
+}
+
+void Scalpel3DOMovieDecoder::close() {
+	Video::VideoDecoder::close();
+
+	delete _stream; _stream = 0;
+	_videoTrack = 0;
+}
+
+// We try to at least decode 1 frame
+// and also try to get at least 0.5 seconds of audio queued up
+void Scalpel3DOMovieDecoder::readNextPacket() {
+	uint32 currentMovieTime = getTime();
+	uint32 wantedAudioQueued  = currentMovieTime + 500; // always try to be 0.500 seconds in front of movie time
+
+	int32 chunkOffset     = 0;
+	int32 dataStartOffset = 0;
+	int32 nextChunkOffset = 0;
+	uint32 chunkTag       = 0;
+	uint32 chunkSize      = 0;
+
+	uint32 videoSubType   = 0;
+	uint32 videoTimeStamp = 0;
+	uint32 videoFrameSize = 0;
+	uint32 audioSubType   = 0;
+	uint32 audioBytes     = 0;
+	bool videoGotFrame = false;
+	bool videoDone     = false;
+	bool audioDone     = false;
+
+	// Seek to smallest stream offset
+	if (_streamVideoOffset <= _streamAudioOffset) {
+		_stream->seek(_streamVideoOffset);
+	} else {
+		_stream->seek(_streamAudioOffset);
+	}
+
+	if (wantedAudioQueued <= _audioTrack->getTotalAudioQueued()) {
+		// already got enough audio queued up
+		audioDone = true;
+	}
+
+	while (1) {
+		chunkOffset = _stream->pos();
+		assert(chunkOffset >= 0);
+
+		// Read chunk header
+		chunkTag = _stream->readUint32BE();
+		chunkSize = _stream->readUint32BE() - 8;
+
+		// Calculate offsets
+		dataStartOffset = _stream->pos();
+		assert(dataStartOffset >= 0);
+		nextChunkOffset = dataStartOffset + chunkSize;
+
+		//warning("offset %lx - tag %lx", dataStartOffset, tag);
+
+		if (_stream->eos())
+			break;
+
+		switch (chunkTag) {
+		case MKTAG('F','I','L','M'):
+			videoTimeStamp = _stream->readUint32BE();
+			_stream->skip(4); // Unknown
+			videoSubType = _stream->readUint32BE();
+
+			switch (videoSubType) {
+			case MKTAG('F', 'H', 'D', 'R'):
+				// Ignore video header
+				break;
+
+			case MKTAG('F', 'R', 'M', 'E'):
+				// Found frame data
+				if (_streamVideoOffset <= chunkOffset) {
+					// We are at an offset that is still relevant to video decoding
+					if (!videoDone) {
+						if (!videoGotFrame) {
+							// We haven't decoded any frame yet, so do so now
+							_stream->readUint32BE();
+							videoFrameSize = _stream->readUint32BE();
+							_videoTrack->decodeFrame(_stream->readStream(videoFrameSize), videoTimeStamp);
+
+							_streamVideoOffset = nextChunkOffset;
+							videoGotFrame = true;
+
+						} else {
+							// Already decoded a frame, so get timestamp of follow-up frame
+							// and then we are done with video
+
+							// Calculate next frame time
+							// 3DO clock time for movies runs at 240Hh, that's why timestamps are based on 240.
+							uint32 currentFrameStartTime = _videoTrack->getNextFrameStartTime();
+							uint32 nextFrameStartTime = videoTimeStamp * 1000 / 240;
+							assert(currentFrameStartTime <= nextFrameStartTime);
+							_videoTrack->setNextFrameStartTime(nextFrameStartTime);
+
+							// next time we want to start at the current chunk
+							_streamVideoOffset = chunkOffset;
+							videoDone = true;
+						}
+					}
+				}
+				break;
+
+			default:
+				error("Sherlock 3DO movie: Unknown subtype inside FILM packet");
+				break;
+			}
+			break;
+
+		case MKTAG('S','N','D','S'):
+			_stream->skip(8);
+			audioSubType = _stream->readUint32BE();
+
+			switch (audioSubType) {
+			case MKTAG('S', 'H', 'D', 'R'):
+				// Ignore the audio header
+				break;
+
+			case MKTAG('S', 'S', 'M', 'P'):
+				// Got audio chunk
+				if (_streamAudioOffset <= chunkOffset) {
+					// We are at an offset that is still relevant to audio decoding
+					if (!audioDone) {
+						audioBytes = _stream->readUint32BE();
+						_audioTrack->queueAudio(_stream, audioBytes);
+
+						_streamAudioOffset = nextChunkOffset;
+						if (wantedAudioQueued <= _audioTrack->getTotalAudioQueued()) {
+							// Got enough audio
+							audioDone = true;
+						}
+					}
+				}
+				break;
+
+			default:
+				error("Sherlock 3DO movie: Unknown subtype inside SNDS packet");
+				break;
+			}
+			break;
+
+		case MKTAG('C','T','R','L'):
+		case MKTAG('F','I','L','L'): // filler chunk, fills to certain boundary
+		case MKTAG('D','A','C','Q'):
+		case MKTAG('J','O','I','N'): // add cel data (not used in sherlock)
+			// Ignore these chunks
+			break;
+
+		case MKTAG('S','H','D','R'):
+			// Happens for EA logo, seems to be garbage data right at the start of the file
+			break;
+
+		default:
+			error("Unknown chunk-tag '%s' inside Sherlock 3DO movie", tag2str(chunkTag));
+		}
+
+		// Always seek to end of chunk
+		// Sometimes not all of the chunk is filled with audio
+		_stream->seek(nextChunkOffset);
+
+		if ((videoDone) && (audioDone)) {
+			return;
+		}
+	}
+}
+
+Scalpel3DOMovieDecoder::StreamVideoTrack::StreamVideoTrack(uint32 width, uint32 height, uint32 codecTag, uint32 frameCount) {
+	_width = width;
+	_height = height;
+	_frameCount = frameCount;
+	_curFrame = -1;
+	_nextFrameStartTime = 0;
+
+	// Create the Cinepak decoder, if we're using it
+	if (codecTag == MKTAG('c', 'v', 'i', 'd'))
+		_codec = new Image::CinepakDecoder();
+	else
+		error("Unsupported Sherlock 3DO movie video codec tag '%s'", tag2str(codecTag));
+}
+
+Scalpel3DOMovieDecoder::StreamVideoTrack::~StreamVideoTrack() {
+	delete _codec;
+}
+
+bool Scalpel3DOMovieDecoder::StreamVideoTrack::endOfTrack() const {
+	return getCurFrame() >= getFrameCount() - 1;
+}
+
+Graphics::PixelFormat Scalpel3DOMovieDecoder::StreamVideoTrack::getPixelFormat() const {
+	return _codec->getPixelFormat();
+}
+
+void Scalpel3DOMovieDecoder::StreamVideoTrack::decodeFrame(Common::SeekableReadStream *stream, uint32 videoTimeStamp) {
+	_surface = _codec->decodeFrame(*stream);
+	_curFrame++;
+}
+
+Scalpel3DOMovieDecoder::StreamAudioTrack::StreamAudioTrack(uint32 codecTag, uint32 sampleRate, uint32 channels) {
+	switch (codecTag) {
+	case MKTAG('A','D','P','4'):
+	case MKTAG('S','D','X','2'):
+		// ADP4 + SDX2 are both allowed
+		break;
+
+	default:
+		error("Unsupported Sherlock 3DO movie audio codec tag '%s'", tag2str(codecTag));
+	}
+
+	_totalAudioQueued = 0; // currently 0 milliseconds queued
+
+	_codecTag    = codecTag;
+	_sampleRate  = sampleRate;
+	switch (channels) {
+	case 1:
+		_stereo = false;
+		break;
+	case 2:
+		_stereo = true;
+		break;
+	default:
+		error("Unsupported Sherlock 3DO movie audio channels %d", channels);
+	}
+
+	_audioStream = Audio::makeQueuingAudioStream(sampleRate, _stereo);
+
+	// reset audio decoder persistent spaces
+	memset(&_ADP4_PersistentSpace, 0, sizeof(_ADP4_PersistentSpace));
+	memset(&_SDX2_PersistentSpace, 0, sizeof(_SDX2_PersistentSpace));
+}
+
+Scalpel3DOMovieDecoder::StreamAudioTrack::~StreamAudioTrack() {
+	delete _audioStream;
+//	free(_ADP4_PersistentSpace);
+//	free(_SDX2_PersistentSpace);
+}
+
+void Scalpel3DOMovieDecoder::StreamAudioTrack::queueAudio(Common::SeekableReadStream *stream, uint32 size) {
+	Common::SeekableReadStream *compressedAudioStream = 0;
+	Audio::RewindableAudioStream *audioStream = 0;
+	uint32 audioLengthMSecs = 0;
+
+	// Read the specified chunk into memory
+	compressedAudioStream = stream->readStream(size);
+
+	switch(_codecTag) {
+	case MKTAG('A','D','P','4'):
+		audioStream = Audio::make3DO_ADP4AudioStream(compressedAudioStream, _sampleRate, _stereo, &audioLengthMSecs, DisposeAfterUse::YES, &_ADP4_PersistentSpace);
+		break;
+	case MKTAG('S','D','X','2'):
+		audioStream = Audio::make3DO_SDX2AudioStream(compressedAudioStream, _sampleRate, _stereo, &audioLengthMSecs, DisposeAfterUse::YES, &_SDX2_PersistentSpace);
+		break;
+	default:
+		break;
+	}
+	if (audioStream) {
+		_totalAudioQueued += audioLengthMSecs;
+		_audioStream->queueAudioStream(audioStream, DisposeAfterUse::YES);
+	} else {
+		// in case there was an error
+		delete compressedAudioStream;
+	}
+}
+
+Audio::AudioStream *Scalpel3DOMovieDecoder::StreamAudioTrack::getAudioStream() const {
+	return _audioStream;
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/3do/movie_decoder.h b/engines/sherlock/scalpel/3do/movie_decoder.h
new file mode 100644
index 0000000000..73b125443b
--- /dev/null
+++ b/engines/sherlock/scalpel/3do/movie_decoder.h
@@ -0,0 +1,124 @@
+/* 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 SHERLOCK_SCALPEL_3DO_MOVIE_DECODER_H
+#define SHERLOCK_SCALPEL_3DO_MOVIE_DECODER_H
+
+#include "common/rect.h"
+#include "video/video_decoder.h"
+#include "audio/decoders/3do.h"
+
+namespace Audio {
+class QueuingAudioStream;
+}
+
+namespace Common {
+class SeekableReadStream;
+}
+
+namespace Image {
+class Codec;
+}
+
+namespace Sherlock {
+
+class Scalpel3DOMovieDecoder : public Video::VideoDecoder {
+public:
+	Scalpel3DOMovieDecoder();
+	~Scalpel3DOMovieDecoder();
+
+	bool loadStream(Common::SeekableReadStream *stream);
+	void close();
+
+protected:
+	void readNextPacket();
+
+private:
+	int32 _streamVideoOffset; /* current stream offset for video decoding */
+	int32 _streamAudioOffset; /* current stream offset for audio decoding */
+
+private:
+	class StreamVideoTrack : public VideoTrack  {
+	public:
+		StreamVideoTrack(uint32 width, uint32 height, uint32 codecTag, uint32 frameCount);
+		~StreamVideoTrack();
+
+		bool endOfTrack() const;
+
+		uint16 getWidth() const { return _width; }
+		uint16 getHeight() const { return _height; }
+		Graphics::PixelFormat getPixelFormat() const;
+		int getCurFrame() const { return _curFrame; }
+		int getFrameCount() const { return _frameCount; }
+		void setNextFrameStartTime(uint32 nextFrameStartTime) { _nextFrameStartTime = nextFrameStartTime; }
+		uint32 getNextFrameStartTime() const { return _nextFrameStartTime; }
+		const Graphics::Surface *decodeNextFrame() { return _surface; }
+
+		void decodeFrame(Common::SeekableReadStream *stream, uint32 videoTimeStamp);
+
+	private:
+		const Graphics::Surface *_surface;
+
+		int _curFrame;
+		uint32 _frameCount;
+		uint32 _nextFrameStartTime;
+
+		Image::Codec *_codec;
+		uint16 _width, _height;
+	};
+
+	class StreamAudioTrack : public AudioTrack {
+	public:
+		StreamAudioTrack(uint32 codecTag, uint32 sampleRate, uint32 channels);
+		~StreamAudioTrack();
+
+		void queueAudio(Common::SeekableReadStream *stream, uint32 size);
+
+	protected:
+		Audio::AudioStream *getAudioStream() const;
+
+	private:
+		Audio::QueuingAudioStream *_audioStream;
+		uint32 _totalAudioQueued; /* total amount of milliseconds of audio, that we queued up already */
+
+	public:
+		uint32 getTotalAudioQueued() const { return _totalAudioQueued; }
+
+	private:
+		int16 decodeSample(uint8 dataNibble);
+
+		uint32 _codecTag;
+		uint16 _sampleRate;
+		bool   _stereo;
+
+		Audio::audio_3DO_ADP4_PersistentSpace _ADP4_PersistentSpace;
+		Audio::audio_3DO_SDX2_PersistentSpace _SDX2_PersistentSpace;
+	};
+
+	Common::SeekableReadStream *_stream;
+	StreamVideoTrack *_videoTrack;
+	StreamAudioTrack *_audioTrack;
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/drivers/adlib.cpp b/engines/sherlock/scalpel/drivers/adlib.cpp
new file mode 100644
index 0000000000..29a39f0c39
--- /dev/null
+++ b/engines/sherlock/scalpel/drivers/adlib.cpp
@@ -0,0 +1,646 @@
+/* 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 "sherlock/sherlock.h"
+#include "sherlock/scalpel/drivers/mididriver.h"
+
+#include "common/file.h"
+#include "common/system.h"
+#include "common/textconsole.h"
+
+#include "audio/fmopl.h"
+#include "audio/softsynth/emumidi.h"
+
+namespace Sherlock {
+
+#define SHERLOCK_ADLIB_VOICES_COUNT 9
+#define SHERLOCK_ADLIB_NOTES_COUNT 96
+
+byte operator1Register[SHERLOCK_ADLIB_VOICES_COUNT] = {
+	0x00, 0x01, 0x02, 0x08, 0x09, 0x0A, 0x10, 0x11, 0x12
+};
+
+byte operator2Register[SHERLOCK_ADLIB_VOICES_COUNT] = {
+	0x03, 0x04, 0x05, 0x0B, 0x0C, 0x0D, 0x13, 0x14, 0x15
+};
+
+struct percussionChannelEntry {
+	byte requiredNote;
+	byte replacementNote;
+};
+
+// hardcoded, dumped from ADHOM.DRV
+const percussionChannelEntry percussionChannelTable[SHERLOCK_ADLIB_VOICES_COUNT] = {
+	{ 0x00, 0x00 },
+	{ 0x00, 0x00 },
+	{ 0x00, 0x00 },
+	{ 0x00, 0x00 },
+	{ 0x00, 0x00 },
+	{ 0x00, 0x00 },
+	{ 0x24, 0x0C },
+	{ 0x38, 0x01 },
+	{ 0x26, 0x1E }
+};
+
+struct InstrumentEntry {
+	byte reg20op1;
+	byte reg40op1;
+	byte reg60op1;
+	byte reg80op1;
+	byte regE0op1;
+	byte reg20op2;
+	byte reg40op2;
+	byte reg60op2;
+	byte reg80op2;
+	byte regE0op2;
+	byte regC0;
+	byte frequencyAdjust;
+};
+
+// hardcoded, dumped from ADHOM.DRV
+const InstrumentEntry instrumentTable[] = {
+	{ 0x71, 0x89, 0x51, 0x11, 0x00, 0x61, 0x23, 0x42, 0x15, 0x01, 0x02, 0xF4 },
+	{ 0x22, 0x20, 0x97, 0x89, 0x00, 0xA2, 0x1F, 0x70, 0x07, 0x00, 0x0A, 0xF4 },
+	{ 0x70, 0x1A, 0x64, 0x13, 0x00, 0x20, 0x1F, 0x53, 0x46, 0x00, 0x0E, 0xF4 },
+	{ 0xB6, 0x4A, 0xB6, 0x32, 0x00, 0x11, 0x2B, 0xD1, 0x31, 0x00, 0x0E, 0xE8 },
+	{ 0x71, 0x8B, 0x51, 0x11, 0x00, 0x61, 0x20, 0x32, 0x35, 0x01, 0x02, 0xF4 },
+	{ 0x71, 0x8A, 0x51, 0x11, 0x00, 0x61, 0x20, 0x32, 0x25, 0x01, 0x02, 0xF4 },
+	{ 0x23, 0x0F, 0xF4, 0x04, 0x02, 0x2F, 0x25, 0xF0, 0x43, 0x00, 0x06, 0xE8 },
+	{ 0x71, 0x1C, 0x71, 0x03, 0x00, 0x21, 0x1F, 0x54, 0x17, 0x00, 0x0E, 0xF4 },
+	{ 0x71, 0x8A, 0x6E, 0x17, 0x00, 0x25, 0x27, 0x6B, 0x0E, 0x00, 0x02, 0xF4 },
+	{ 0x71, 0x1D, 0x81, 0x03, 0x00, 0x21, 0x1F, 0x64, 0x17, 0x00, 0x0E, 0xF4 },
+	{ 0x01, 0x4B, 0xF1, 0x50, 0x00, 0x01, 0x23, 0xD2, 0x76, 0x00, 0x06, 0xF4 },
+	{ 0x2F, 0xCA, 0xF8, 0xE5, 0x00, 0x21, 0x1F, 0xC0, 0xFF, 0x00, 0x00, 0xF4 },
+	{ 0x29, 0xCD, 0xF0, 0x91, 0x00, 0x21, 0x1F, 0xE0, 0x86, 0x00, 0x02, 0xF4 },
+	{ 0x24, 0xD0, 0xF0, 0x01, 0x00, 0x21, 0x1F, 0xE0, 0x86, 0x00, 0x02, 0xF4 },
+	{ 0x23, 0xC8, 0xF0, 0x01, 0x00, 0x21, 0x1F, 0xE0, 0x86, 0x00, 0x02, 0xF4 },
+	{ 0x64, 0xC9, 0xB0, 0x01, 0x00, 0x61, 0x1F, 0xF0, 0x86, 0x00, 0x02, 0xF4 },
+	{ 0x33, 0x85, 0xA1, 0x10, 0x00, 0x15, 0x9F, 0x72, 0x23, 0x00, 0x08, 0xF4 },
+	{ 0x31, 0x85, 0xA1, 0x10, 0x00, 0x15, 0x9F, 0x73, 0x33, 0x00, 0x08, 0xF4 },
+	{ 0x31, 0x81, 0xA1, 0x30, 0x00, 0x16, 0x9F, 0xC2, 0x74, 0x00, 0x08, 0xF4 },
+	{ 0x03, 0x8A, 0xF0, 0x7B, 0x00, 0x02, 0x9F, 0xF4, 0x7B, 0x00, 0x08, 0xF4 },
+	{ 0x03, 0x8A, 0xF0, 0x7B, 0x00, 0x01, 0x9F, 0xF4, 0x7B, 0x00, 0x08, 0xF4 },
+	{ 0x23, 0x8A, 0xF2, 0x7B, 0x00, 0x01, 0x9F, 0xF4, 0x7B, 0x00, 0x08, 0xF4 },
+	{ 0x32, 0x80, 0x01, 0x10, 0x00, 0x12, 0x9F, 0x72, 0x33, 0x00, 0x08, 0xF4 },
+	{ 0x32, 0x80, 0x01, 0x10, 0x00, 0x14, 0x9F, 0x73, 0x33, 0x00, 0x08, 0xF4 },
+	{ 0x31, 0x16, 0x73, 0x8E, 0x00, 0x21, 0x1F, 0x80, 0x9E, 0x00, 0x0E, 0xF4 },
+	{ 0x30, 0x16, 0x73, 0x7E, 0x00, 0x21, 0x1F, 0x80, 0x9E, 0x00, 0x0E, 0x00 },
+	{ 0x31, 0x94, 0x33, 0x73, 0x00, 0x21, 0x1F, 0xA0, 0x97, 0x00, 0x0E, 0xF4 },
+	{ 0x31, 0x94, 0xD3, 0x73, 0x00, 0x21, 0x20, 0xA0, 0x97, 0x00, 0x0E, 0xF4 },
+	{ 0x31, 0x45, 0xF1, 0x53, 0x00, 0x32, 0x1F, 0xF2, 0x27, 0x00, 0x06, 0xF4 },
+	{ 0x13, 0x0C, 0xF2, 0x01, 0x00, 0x15, 0x2F, 0xF2, 0xB6, 0x00, 0x08, 0xF4 },
+	{ 0x11, 0x0C, 0xF2, 0x01, 0x00, 0x11, 0x1F, 0xF2, 0xB6, 0x00, 0x08, 0xF4 },
+	{ 0x11, 0x0A, 0xFE, 0x04, 0x00, 0x11, 0x1F, 0xF2, 0xBD, 0x00, 0x08, 0xF4 },
+	{ 0x16, 0x4D, 0xFA, 0x11, 0x00, 0xE1, 0x20, 0xF1, 0xF1, 0x00, 0x08, 0xF4 },
+	{ 0x16, 0x40, 0xBA, 0x11, 0x00, 0xF1, 0x20, 0x24, 0x31, 0x00, 0x08, 0xF4 },
+	{ 0x61, 0xA7, 0x72, 0x8E, 0x00, 0xE1, 0x9F, 0x50, 0x1A, 0x00, 0x02, 0xF4 },
+	{ 0x18, 0x4D, 0x32, 0x13, 0x00, 0xE1, 0x20, 0x51, 0xE3, 0x00, 0x08, 0xF4 },
+	{ 0x17, 0xC0, 0x12, 0x41, 0x00, 0x31, 0x9F, 0x13, 0x31, 0x00, 0x06, 0xF4 },
+	{ 0x03, 0x8F, 0xF5, 0x55, 0x00, 0x21, 0x9F, 0xF3, 0x33, 0x00, 0x00, 0xF4 },
+	{ 0x13, 0x4D, 0xFA, 0x11, 0x00, 0xE1, 0x20, 0xF1, 0xF1, 0x00, 0x08, 0xF4 },
+	{ 0x11, 0x43, 0x20, 0x15, 0x00, 0xF1, 0x20, 0x31, 0xF8, 0x00, 0x08, 0xF4 },
+	{ 0x11, 0x03, 0x82, 0x97, 0x00, 0xE4, 0x60, 0xF0, 0xF2, 0x00, 0x08, 0xF4 },
+	{ 0x05, 0x40, 0xD1, 0x53, 0x00, 0x14, 0x1F, 0x51, 0x71, 0x00, 0x06, 0xF4 },
+	{ 0xF1, 0x01, 0x77, 0x17, 0x00, 0x21, 0x1F, 0x81, 0x18, 0x00, 0x02, 0xF4 },
+	{ 0xF1, 0x18, 0x32, 0x11, 0x00, 0xE1, 0x1F, 0xF1, 0x13, 0x00, 0x00, 0xF4 },
+	{ 0x73, 0x48, 0xF1, 0x53, 0x00, 0x71, 0x1F, 0xF1, 0x06, 0x00, 0x08, 0xF4 },
+	{ 0x71, 0x8D, 0x71, 0x11, 0x00, 0x61, 0x5F, 0x72, 0x15, 0x00, 0x06, 0xF4 },
+	{ 0xD7, 0x4F, 0xF2, 0x61, 0x00, 0xD2, 0x1F, 0xF1, 0xB2, 0x00, 0x08, 0xF4 },
+	{ 0x01, 0x11, 0xF0, 0xFF, 0x00, 0x01, 0x1F, 0xF0, 0xF8, 0x00, 0x0A, 0xF4 },
+	{ 0x31, 0x8B, 0x41, 0x11, 0x00, 0x61, 0x1F, 0x22, 0x13, 0x00, 0x06, 0xF4 },
+	{ 0x71, 0x1C, 0x71, 0x03, 0x00, 0x21, 0x1F, 0x64, 0x07, 0x00, 0x0E, 0xF4 },
+	{ 0x31, 0x8B, 0x41, 0x11, 0x00, 0x61, 0x1F, 0x32, 0x15, 0x00, 0x02, 0xF4 },
+	{ 0x71, 0x1C, 0xFD, 0x13, 0x00, 0x21, 0x1F, 0xE7, 0xD6, 0x00, 0x0E, 0xF4 },
+	{ 0x71, 0x1C, 0x51, 0x03, 0x00, 0x21, 0x1F, 0x54, 0x67, 0x00, 0x0E, 0xF4 },
+	{ 0x71, 0x1C, 0x51, 0x03, 0x00, 0x21, 0x1F, 0x54, 0x17, 0x00, 0x0E, 0xF4 },
+	{ 0x71, 0x1C, 0x54, 0x15, 0x00, 0x21, 0x1F, 0x53, 0x49, 0x00, 0x0E, 0xF4 },
+	{ 0x71, 0x56, 0x51, 0x03, 0x00, 0x61, 0x1F, 0x54, 0x17, 0x00, 0x0E, 0xF4 },
+	{ 0x71, 0x1C, 0x51, 0x03, 0x00, 0x21, 0x1F, 0x54, 0x17, 0x00, 0x0E, 0xF4 },
+	{ 0x02, 0x29, 0xF5, 0x75, 0x00, 0x01, 0x9F, 0xF2, 0xF3, 0x00, 0x00, 0xF4 },
+	{ 0x02, 0x29, 0xF0, 0x75, 0x00, 0x01, 0x9F, 0xF4, 0x33, 0x00, 0x00, 0xF4 },
+	{ 0x01, 0x49, 0xF1, 0x53, 0x00, 0x11, 0x1F, 0xF1, 0x74, 0x00, 0x06, 0xF4 },
+	{ 0x01, 0x89, 0xF1, 0x53, 0x00, 0x11, 0x1F, 0xF1, 0x74, 0x00, 0x06, 0xF4 },
+	{ 0x02, 0x89, 0xF1, 0x53, 0x00, 0x11, 0x1F, 0xF1, 0x74, 0x00, 0x06, 0xF4 },
+	{ 0x02, 0x80, 0xF1, 0x53, 0x00, 0x11, 0x1F, 0xF1, 0x74, 0x00, 0x06, 0xF4 },
+	{ 0x01, 0x40, 0xF1, 0x53, 0x00, 0x08, 0x5F, 0xF1, 0x53, 0x00, 0x00, 0xF4 },
+	{ 0x21, 0x15, 0xD3, 0x2C, 0x00, 0x21, 0x9F, 0xC3, 0x2C, 0x00, 0x0A, 0xF4 },
+	{ 0x01, 0x18, 0xD4, 0xF2, 0x00, 0x21, 0x9F, 0xC4, 0x8A, 0x00, 0x0A, 0xF4 },
+	{ 0x01, 0x4E, 0xF0, 0x7B, 0x00, 0x11, 0x1F, 0xF4, 0xC8, 0x00, 0x04, 0xF4 },
+	{ 0x01, 0x44, 0xF0, 0xAB, 0x00, 0x11, 0x1F, 0xF3, 0xAB, 0x00, 0x04, 0xF4 },
+	{ 0x53, 0x0E, 0xF4, 0xC8, 0x00, 0x11, 0x1F, 0xF1, 0xBB, 0x00, 0x04, 0xF4 },
+	{ 0x53, 0x0B, 0xF2, 0xC8, 0x00, 0x11, 0x1F, 0xF2, 0xC5, 0x00, 0x04, 0xF4 },
+	{ 0x21, 0x15, 0xB4, 0x4C, 0x00, 0x21, 0x1F, 0x94, 0xAC, 0x00, 0x0A, 0xF4 },
+	{ 0x21, 0x15, 0x94, 0x1C, 0x00, 0x21, 0x1F, 0x64, 0xAC, 0x00, 0x0A, 0xF4 },
+	{ 0x22, 0x1B, 0x97, 0x89, 0x00, 0xA2, 0x1F, 0x70, 0x07, 0x00, 0x0A, 0xF4 },
+	{ 0x21, 0x19, 0x77, 0xBF, 0x00, 0xA1, 0x9F, 0x60, 0x2A, 0x00, 0x06, 0xF4 },
+	{ 0xA1, 0x13, 0xD6, 0xAF, 0x00, 0xE2, 0x9F, 0x60, 0x2A, 0x00, 0x02, 0xF4 },
+	{ 0xA2, 0x1D, 0x95, 0x24, 0x00, 0xE2, 0x9F, 0x60, 0x2A, 0x00, 0x02, 0xF4 },
+	{ 0x32, 0x9A, 0x51, 0x19, 0x00, 0x61, 0x9F, 0x60, 0x39, 0x00, 0x0C, 0xF4 },
+	{ 0xA4, 0x12, 0xF4, 0x30, 0x00, 0xE2, 0x9F, 0x60, 0x2A, 0x00, 0x02, 0xF4 },
+	{ 0x21, 0x16, 0x63, 0x0E, 0x00, 0x21, 0x1F, 0x63, 0x0E, 0x00, 0x0C, 0xF4 },
+	{ 0x31, 0x16, 0x63, 0x0A, 0x00, 0x21, 0x1F, 0x63, 0x0B, 0x00, 0x0C, 0xF4 },
+	{ 0x21, 0x1B, 0x63, 0x0A, 0x00, 0x21, 0x1F, 0x63, 0x0B, 0x00, 0x0C, 0xF4 },
+	{ 0x20, 0x1B, 0x63, 0x0A, 0x00, 0x21, 0x1F, 0x63, 0x0B, 0x00, 0x0C, 0xF4 },
+	{ 0x32, 0x1C, 0x82, 0x18, 0x00, 0x61, 0x9F, 0x60, 0x07, 0x00, 0x0C, 0xF4 },
+	{ 0x32, 0x18, 0x61, 0x14, 0x00, 0xE1, 0x9F, 0x72, 0x16, 0x00, 0x0C, 0xF4 },
+	{ 0x31, 0xC0, 0x77, 0x17, 0x00, 0x22, 0x1F, 0x6B, 0x09, 0x00, 0x02, 0xF4 },
+	{ 0x71, 0xC3, 0x8E, 0x17, 0x00, 0x22, 0x24, 0x8B, 0x0E, 0x00, 0x02, 0xF4 },
+	{ 0x70, 0x8D, 0x6E, 0x17, 0x00, 0x22, 0x1F, 0x6B, 0x0E, 0x00, 0x02, 0xF4 },
+	{ 0x24, 0x4F, 0xF2, 0x06, 0x00, 0x31, 0x1F, 0x52, 0x06, 0x00, 0x0E, 0xF4 },
+	{ 0x31, 0x1B, 0x64, 0x07, 0x00, 0x61, 0x1F, 0xD0, 0x67, 0x00, 0x0E, 0xF4 },
+	{ 0x31, 0x1B, 0x61, 0x06, 0x00, 0x61, 0x1F, 0xD2, 0x36, 0x00, 0x0C, 0xF4 },
+	{ 0x31, 0x1F, 0x31, 0x06, 0x00, 0x61, 0x1F, 0x50, 0x36, 0x00, 0x0C, 0xF4 },
+	{ 0x31, 0x1F, 0x41, 0x06, 0x00, 0x61, 0x1F, 0xA0, 0x36, 0x00, 0x0C, 0xF4 },
+	{ 0x21, 0x9A, 0x53, 0x56, 0x00, 0x21, 0x9F, 0xA0, 0x16, 0x00, 0x0E, 0xF4 },
+	{ 0x21, 0x9A, 0x53, 0x56, 0x00, 0x21, 0x9F, 0xA0, 0x16, 0x00, 0x0E, 0xF4 },
+	{ 0x61, 0x19, 0x53, 0x58, 0x00, 0x21, 0x1F, 0xA0, 0x18, 0x00, 0x0C, 0xF4 },
+	{ 0x61, 0x19, 0x73, 0x57, 0x00, 0x21, 0x1F, 0xA0, 0x17, 0x00, 0x0C, 0xF4 },
+	{ 0x21, 0x1B, 0x71, 0xA6, 0x00, 0x21, 0x1F, 0xA1, 0x96, 0x00, 0x0E, 0xF4 },
+	{ 0x85, 0x91, 0xF5, 0x44, 0x00, 0xA1, 0x1F, 0xF0, 0x45, 0x00, 0x06, 0xF4 },
+	{ 0x07, 0x51, 0xF5, 0x33, 0x00, 0x61, 0x1F, 0xF0, 0x25, 0x00, 0x06, 0xF4 },
+	{ 0x13, 0x8C, 0xFF, 0x21, 0x00, 0x11, 0x9F, 0xFF, 0x03, 0x00, 0x0E, 0xF4 },
+	{ 0x38, 0x8C, 0xF3, 0x0D, 0x00, 0xB1, 0x5F, 0xF5, 0x33, 0x00, 0x0E, 0xF4 },
+	{ 0x87, 0x91, 0xF5, 0x55, 0x00, 0x22, 0x1F, 0xF0, 0x54, 0x00, 0x06, 0xF4 },
+	{ 0xB6, 0x4A, 0xB6, 0x32, 0x00, 0x11, 0x2B, 0xD1, 0x31, 0x00, 0x0E, 0xF4 },
+	{ 0x04, 0x00, 0xFE, 0xF0, 0x00, 0xC2, 0x1F, 0xF6, 0xB5, 0x00, 0x0E, 0xF4 },
+	{ 0x05, 0x4E, 0xDA, 0x15, 0x00, 0x01, 0x9F, 0xF0, 0x13, 0x00, 0x0A, 0xF4 },
+	{ 0x31, 0x44, 0xF2, 0x9A, 0x00, 0x32, 0x1F, 0xF0, 0x27, 0x00, 0x06, 0xF4 },
+	{ 0xB0, 0xC4, 0xA4, 0x02, 0x00, 0xD7, 0x9F, 0x40, 0x42, 0x00, 0x00, 0xF4 },
+	{ 0xCA, 0x84, 0xF0, 0xF0, 0x00, 0xCF, 0x1F, 0x59, 0x62, 0x00, 0x0C, 0xF4 },
+	{ 0x30, 0x35, 0xF5, 0xF0, 0x00, 0x35, 0x1F, 0xF0, 0x9B, 0x00, 0x02, 0xF4 },
+	{ 0x63, 0x0F, 0xF4, 0x04, 0x02, 0x6F, 0x1F, 0xF0, 0x43, 0x00, 0x06, 0xF4 },
+	{ 0x07, 0x40, 0x09, 0x53, 0x00, 0x05, 0x1F, 0xF6, 0x94, 0x00, 0x0E, 0xF4 },
+	{ 0x09, 0x4E, 0xDA, 0x25, 0x00, 0x01, 0x1F, 0xF1, 0x15, 0x00, 0x0A, 0xF4 },
+	{ 0x04, 0x00, 0xF3, 0xA0, 0x02, 0x04, 0x1F, 0xF8, 0x46, 0x00, 0x0E, 0xF4 },
+	{ 0x07, 0x00, 0xF0, 0xF0, 0x00, 0x00, 0x1F, 0x5C, 0xDC, 0x00, 0x0E, 0xF4 },
+	{ 0x1F, 0x1E, 0xE5, 0x5B, 0x00, 0x0F, 0x1F, 0x5D, 0xFA, 0x00, 0x0E, 0xF4 },
+	{ 0x11, 0x8A, 0xF1, 0x11, 0x00, 0x01, 0x5F, 0xF1, 0xB3, 0x00, 0x06, 0xF4 },
+	{ 0x00, 0x40, 0xD1, 0x53, 0x00, 0x00, 0x1F, 0xF2, 0x56, 0x00, 0x0E, 0xF4 },
+	{ 0x32, 0x44, 0xF8, 0xFF, 0x00, 0x11, 0x1F, 0xF5, 0x7F, 0x00, 0x0E, 0xF4 },
+	{ 0x00, 0x40, 0x09, 0x53, 0x00, 0x02, 0x1F, 0xF7, 0x94, 0x00, 0x0E, 0xF4 },
+	{ 0x11, 0x86, 0xF2, 0xA8, 0x00, 0x01, 0x9F, 0xA0, 0xA8, 0x00, 0x08, 0xF4 },
+	{ 0x00, 0x50, 0xF2, 0x70, 0x00, 0x13, 0x1F, 0xF2, 0x72, 0x00, 0x0E, 0xF4 },
+	{ 0xF0, 0x00, 0x11, 0x11, 0x00, 0xE0, 0xDF, 0x11, 0x11, 0x00, 0x0E, 0xF4 }
+};
+
+// hardcoded, dumped from ADHOM.DRV
+uint16 frequencyLookUpTable[SHERLOCK_ADLIB_NOTES_COUNT] = {
+	0x0158, 0x016C, 0x0182, 0x0199, 0x01B1, 0x01CB, 0x01E6, 0x0203, 0x0222, 0x0242,
+	0x0265, 0x0289, 0x0558, 0x056C, 0x0582, 0x0599, 0x05B1, 0x05CB, 0x05E6, 0x0603,
+	0x0622, 0x0642, 0x0665, 0x0689, 0x0958, 0x096C, 0x0982, 0x0999, 0x09B1, 0x09CB,
+	0x09E6, 0x0A03, 0x0A22, 0x0A42, 0x0A65, 0x0A89, 0x0D58, 0x0D6C, 0x0D82, 0x0D99,
+	0x0DB1, 0x0DCB, 0x0DE6, 0x0E03, 0x0E22, 0x0E42, 0x0E65, 0x0E89, 0x1158, 0x116C,
+	0x1182, 0x1199, 0x11B1, 0x11CB, 0x11E6, 0x1203, 0x1222, 0x1242, 0x1265, 0x1289,
+	0x1558, 0x156C, 0x1582, 0x1599, 0x15B1, 0x15CB, 0x15E6, 0x1603, 0x1622, 0x1642,
+	0x1665, 0x1689, 0x1958, 0x196C, 0x1982, 0x1999, 0x19B1, 0x19CB, 0x19E6, 0x1A03,
+	0x1A22, 0x1A42, 0x1A65, 0x1A89, 0x1D58, 0x1D6C, 0x1D82, 0x1D99, 0x1DB1, 0x1DCB,
+	0x1DE6, 0x1E03, 0x1E22, 0x1E42, 0x1E65, 0x1E89
+};
+
+class MidiDriver_SH_AdLib : public MidiDriver {
+public:
+	MidiDriver_SH_AdLib(Audio::Mixer *mixer)
+		: _masterVolume(15), _opl(0),
+		  _adlibTimerProc(0), _adlibTimerParam(0), _isOpen(false) {
+		memset(_voiceChannelMapping, 0, sizeof(_voiceChannelMapping));
+	}
+	virtual ~MidiDriver_SH_AdLib() { }
+
+	// MidiDriver
+	int open();
+	void close();
+	void send(uint32 b);
+	MidiChannel *allocateChannel() { return NULL; }
+	MidiChannel *getPercussionChannel() { return NULL; }
+	bool isOpen() const { return _isOpen; }
+	uint32 getBaseTempo() { return 1000000 / OPL::OPL::kDefaultCallbackFrequency; }
+
+	int getPolyphony() const { return SHERLOCK_ADLIB_VOICES_COUNT; }
+	bool hasRhythmChannel() const { return false; }
+
+	virtual void setTimerCallback(void *timerParam, Common::TimerManager::TimerProc timerProc);
+
+	void setVolume(byte volume);
+	virtual uint32 property(int prop, uint32 param);
+
+	void newMusicData(byte *musicData, int32 musicDataSize);
+
+private:
+	struct adlib_ChannelEntry {
+		bool   inUse;
+		uint16 inUseTimer;
+		const  InstrumentEntry *currentInstrumentPtr;
+		byte   currentNote;
+		byte   currentA0hReg;
+		byte   currentB0hReg;
+
+		adlib_ChannelEntry() : inUse(false), inUseTimer(0), currentInstrumentPtr(NULL), currentNote(0),
+								currentA0hReg(0), currentB0hReg(0) { }
+	};
+
+	OPL::OPL *_opl;
+	int _masterVolume;
+
+	Common::TimerManager::TimerProc _adlibTimerProc;
+	void *_adlibTimerParam;
+
+	bool _isOpen;
+
+	// points to a MIDI channel for each of the new voice channels
+	byte _voiceChannelMapping[SHERLOCK_ADLIB_VOICES_COUNT];
+
+	// stores information about all FM voice channels
+	adlib_ChannelEntry _channels[SHERLOCK_ADLIB_VOICES_COUNT];
+
+	void onTimer();
+
+	void resetAdLib();
+	void resetAdLibOperatorRegisters(byte baseRegister, byte value);
+	void resetAdLibFMVoiceChannelRegisters(byte baseRegister, byte value);
+
+	void programChange(byte MIDIchannel, byte parameter);
+	void setRegister(int reg, int value);
+	void noteOn(byte MIDIchannel, byte note, byte velocity);
+	void noteOff(byte MIDIchannel, byte note);
+	void voiceOnOff(byte FMVoiceChannel, bool KeyOn, byte note, byte velocity);
+
+	void pitchBendChange(byte MIDIchannel, byte parameter1, byte parameter2);
+};
+
+int MidiDriver_SH_AdLib::open() {
+	debugC(kDebugLevelAdLibDriver, "AdLib: starting driver");
+
+	_opl = OPL::Config::create(OPL::Config::kOpl2);
+
+	if (!_opl)
+		return -1;
+
+	_opl->init();
+
+	_isOpen = true;
+
+	_opl->start(new Common::Functor0Mem<void, MidiDriver_SH_AdLib>(this, &MidiDriver_SH_AdLib::onTimer));
+
+	return 0;
+}
+
+void MidiDriver_SH_AdLib::close() {
+	// Stop the OPL timer
+	_opl->stop();
+
+	delete _opl;
+}
+
+void MidiDriver_SH_AdLib::setVolume(byte volume) {
+	_masterVolume = volume;
+	//renewNotes(-1, true);
+}
+
+// this should/must get called per tick
+// original driver did this before MIDI data processing on each tick
+// we do it atm after MIDI data processing
+void MidiDriver_SH_AdLib::onTimer() {
+	if (_adlibTimerProc)
+		(*_adlibTimerProc)(_adlibTimerParam);
+
+	// this should/must get called per tick
+	// original driver did this before MIDI data processing on each tick
+	// we do it atm after MIDI data processing
+	for (byte FMvoiceChannel = 0; FMvoiceChannel < SHERLOCK_ADLIB_VOICES_COUNT; FMvoiceChannel++) {
+		if (_channels[FMvoiceChannel].inUse) {
+			_channels[FMvoiceChannel].inUseTimer++;
+		}
+	}
+}
+
+// Called when a music track got loaded into memory
+void MidiDriver_SH_AdLib::newMusicData(byte *musicData, int32 musicDataSize) {
+	assert(musicDataSize >= 0x7F);
+	// MIDI Channel <-> FM Voice Channel mapping at offset 0x22 of music data
+	memcpy(&_voiceChannelMapping, musicData + 0x22, 9);
+
+	// reset OPL
+	resetAdLib();
+
+	// reset current channel data
+	memset(&_channels, 0, sizeof(_channels));
+}
+
+void MidiDriver_SH_AdLib::resetAdLib() {
+
+	setRegister(0x01, 0x20); // enable waveform control on both operators
+	setRegister(0x04, 0xE0); // Timer control
+
+	setRegister(0x08, 0); // select FM music mode
+	setRegister(0xBD, 0); // disable Rhythm
+
+	// reset FM voice instrument data
+	resetAdLibOperatorRegisters(0x20, 0);
+	resetAdLibOperatorRegisters(0x60, 0);
+	resetAdLibOperatorRegisters(0x80, 0);
+	resetAdLibFMVoiceChannelRegisters(0xA0, 0);
+	resetAdLibFMVoiceChannelRegisters(0xB0, 0);
+	resetAdLibFMVoiceChannelRegisters(0xC0, 0);
+	resetAdLibOperatorRegisters(0xE0, 0);
+	resetAdLibOperatorRegisters(0x40, 0x3F);
+}
+
+void MidiDriver_SH_AdLib::resetAdLibOperatorRegisters(byte baseRegister, byte value) {
+	byte operatorIndex;
+
+	for (operatorIndex = 0; operatorIndex < 0x16; operatorIndex++) {
+		switch (operatorIndex) {
+		case 0x06:
+		case 0x07:
+		case 0x0E:
+		case 0x0F:
+			break;
+		default:
+			setRegister(baseRegister + operatorIndex, value);
+		}
+	}
+}
+
+void MidiDriver_SH_AdLib::resetAdLibFMVoiceChannelRegisters(byte baseRegister, byte value) {
+	byte FMvoiceChannel;
+
+	for (FMvoiceChannel = 0; FMvoiceChannel < SHERLOCK_ADLIB_VOICES_COUNT; FMvoiceChannel++) {
+		setRegister(baseRegister + FMvoiceChannel, value);
+	}
+}
+
+// MIDI messages can be found at http://www.midi.org/techspecs/midimessages.php
+void MidiDriver_SH_AdLib::send(uint32 b) {
+	byte command = b & 0xf0;
+	byte channel = b & 0xf;
+	byte op1 = (b >> 8) & 0xff;
+	byte op2 = (b >> 16) & 0xff;
+
+	switch (command) {
+	case 0x80:
+		noteOff(channel, op1);
+		break;
+	case 0x90:
+		noteOn(channel, op1, op2);
+		break;
+	case 0xb0: // Control change
+		// Doesn't seem to be implemented in the Sherlock Holmes adlib driver
+		break;
+	case 0xc0: // Program Change
+		programChange(channel, op1);
+		break;
+	case 0xa0: // Polyphonic key pressure (aftertouch)
+	case 0xd0: // Channel pressure (aftertouch)
+		// Aftertouch doesn't seem to be implemented in the Sherlock Holmes adlib driver
+		break;
+	case 0xe0:
+		debugC(kDebugLevelAdLibDriver, "AdLib: pitch bend change");
+		pitchBendChange(channel, op1, op2);
+		break;
+	case 0xf0: // SysEx
+		warning("ADLIB: SysEx: %x", b);
+		break;
+	default:
+		warning("ADLIB: Unknown event %02x", command);
+	}
+}
+
+void MidiDriver_SH_AdLib::noteOn(byte MIDIchannel, byte note, byte velocity) {
+	int16  oldestInUseChannel = -1;
+	uint16 oldestInUseTimer   = 0;
+
+	if (velocity == 0)
+		return noteOff(MIDIchannel, note);
+
+	if (MIDIchannel != 9) {
+		// Not Percussion
+		for (byte FMvoiceChannel = 0; FMvoiceChannel < SHERLOCK_ADLIB_VOICES_COUNT; FMvoiceChannel++) {
+			if (_voiceChannelMapping[FMvoiceChannel] == MIDIchannel) {
+				if (!_channels[FMvoiceChannel].inUse) {
+					_channels[FMvoiceChannel].inUse = true;
+					_channels[FMvoiceChannel].currentNote = note;
+
+					voiceOnOff(FMvoiceChannel, true, note, velocity);
+					return;
+				}
+			}
+		}
+
+		// Look for oldest in-use channel
+		for (byte FMvoiceChannel = 0; FMvoiceChannel < SHERLOCK_ADLIB_VOICES_COUNT; FMvoiceChannel++) {
+			if (_voiceChannelMapping[FMvoiceChannel] == MIDIchannel) {
+				if (_channels[FMvoiceChannel].inUseTimer > oldestInUseTimer) {
+					oldestInUseTimer   = _channels[FMvoiceChannel].inUseTimer;
+					oldestInUseChannel = FMvoiceChannel;
+				}
+			}
+		}
+		if (oldestInUseChannel >= 0) {
+			// channel found
+			debugC(kDebugLevelAdLibDriver, "AdLib: used In-Use channel");
+			// original driver used note 0, we use the current note
+			// because using note 0 could create a bad note (out of index) and we check that. Original driver didn't.
+			voiceOnOff(oldestInUseChannel, false, _channels[oldestInUseChannel].currentNote, 0);
+
+			_channels[oldestInUseChannel].inUse       = true;
+			_channels[oldestInUseChannel].inUseTimer  = 0; // safety, original driver also did this
+			_channels[oldestInUseChannel].currentNote = note;
+			voiceOnOff(oldestInUseChannel, true, note, velocity);
+			return;
+		}
+		debugC(kDebugLevelAdLibDriver, "AdLib: MIDI channel not mapped/all FM voice channels busy %d", MIDIchannel);
+
+	} else {
+		// Percussion channel
+		for (byte FMvoiceChannel = 0; FMvoiceChannel < SHERLOCK_ADLIB_VOICES_COUNT; FMvoiceChannel++) {
+			if (_voiceChannelMapping[FMvoiceChannel] == MIDIchannel) {
+				if (note == percussionChannelTable[FMvoiceChannel].requiredNote) {
+					_channels[FMvoiceChannel].inUse = true;
+					_channels[FMvoiceChannel].currentNote = note;
+
+					voiceOnOff(FMvoiceChannel, true, percussionChannelTable[FMvoiceChannel].replacementNote, velocity);
+					return;
+				}
+			}
+		}
+		debugC(kDebugLevelAdLibDriver, "AdLib: percussion MIDI channel not mapped/all FM voice channels busy");
+	}
+}
+
+void MidiDriver_SH_AdLib::noteOff(byte MIDIchannel, byte note) {
+	for (byte FMvoiceChannel = 0; FMvoiceChannel < SHERLOCK_ADLIB_VOICES_COUNT; FMvoiceChannel++) {
+		if (_voiceChannelMapping[FMvoiceChannel] == MIDIchannel) {
+			if (_channels[FMvoiceChannel].currentNote == note) {
+				_channels[FMvoiceChannel].inUse = false;
+				_channels[FMvoiceChannel].inUseTimer  = 0;
+				_channels[FMvoiceChannel].currentNote = 0;
+
+				if (MIDIchannel != 9) {
+					// not-percussion
+					voiceOnOff(FMvoiceChannel, false, note, 0);
+				} else {
+					voiceOnOff(FMvoiceChannel, false, percussionChannelTable[FMvoiceChannel].replacementNote, 0);
+				}
+				return;
+			}
+		}
+	}
+}
+
+void MidiDriver_SH_AdLib::voiceOnOff(byte FMvoiceChannel, bool keyOn, byte note, byte velocity) {
+	byte frequencyOffset = 0;
+	uint16 frequency = 0;
+	byte op2RegAdjust = 0;
+	byte regValue40h = 0;
+	byte regValueA0h = 0;
+	byte regValueB0h = 0;
+
+	// Look up frequency
+	if (_channels[FMvoiceChannel].currentInstrumentPtr) {
+		frequencyOffset = note + _channels[FMvoiceChannel].currentInstrumentPtr->frequencyAdjust;
+	} else {
+		frequencyOffset = note;
+	}
+	if (frequencyOffset >= SHERLOCK_ADLIB_NOTES_COUNT) {
+		warning("CRITICAL - AdLib driver: bad note!!!");
+		return;
+	}
+	frequency = frequencyLookUpTable[frequencyOffset];
+
+	if (keyOn) {
+		// adjust register 40h
+		if (_channels[FMvoiceChannel].currentInstrumentPtr) {
+			regValue40h = _channels[FMvoiceChannel].currentInstrumentPtr->reg40op2;
+		}
+		regValue40h = regValue40h - (velocity >> 3);
+		op2RegAdjust = operator2Register[FMvoiceChannel];
+		setRegister(0x40 + op2RegAdjust, regValue40h);
+	}
+
+	regValueA0h = frequency & 0xFF;
+	regValueB0h = frequency >> 8;
+	if (keyOn) {
+		regValueB0h |= 0x20; // set Key-On flag
+	}
+
+	setRegister(0xA0 + FMvoiceChannel, regValueA0h);
+	setRegister(0xB0 + FMvoiceChannel, regValueB0h);
+	_channels[FMvoiceChannel].currentA0hReg = regValueA0h;
+	_channels[FMvoiceChannel].currentB0hReg = regValueB0h;
+}
+
+void MidiDriver_SH_AdLib::pitchBendChange(byte MIDIchannel, byte parameter1, byte parameter2) {
+	uint16 channelFrequency              = 0;
+	byte   channelRegB0hWithoutFrequency = 0;
+	uint16 parameter                     = 0;
+	byte   regValueA0h = 0;
+	byte   regValueB0h = 0;
+
+	for (byte FMvoiceChannel = 0; FMvoiceChannel < SHERLOCK_ADLIB_VOICES_COUNT; FMvoiceChannel++) {
+		if (_voiceChannelMapping[FMvoiceChannel] == MIDIchannel) {
+			if (_channels[FMvoiceChannel].inUse) {
+				// FM voice channel found and it's currently in use -> apply pitch bend change
+
+				// Remove frequency bits from current channel B0h-register
+				channelFrequency              = ((_channels[FMvoiceChannel].currentB0hReg << 8) | (_channels[FMvoiceChannel].currentA0hReg)) & 0x3FF;
+				channelRegB0hWithoutFrequency = _channels[FMvoiceChannel].currentB0hReg & 0xFC;
+
+				if (parameter2 < 0x40) {
+					channelFrequency = channelFrequency / 2;
+				} else {
+					parameter2 = parameter2 - 0x40;
+				}
+				parameter1 = parameter1 * 2;
+				parameter = parameter1 | (parameter2 << 8);
+				parameter = parameter * 4;
+
+				parameter = (parameter >> 8) + 0xFF;
+				channelFrequency = channelFrequency * parameter;
+				channelFrequency = (channelFrequency >> 8) | (parameter << 8);
+
+				regValueA0h = channelFrequency & 0xFF;
+				regValueB0h = (channelFrequency >> 8) | channelRegB0hWithoutFrequency;
+
+				setRegister(0xA0 + FMvoiceChannel, regValueA0h);
+				setRegister(0xB0 + FMvoiceChannel, regValueB0h);
+			}
+		}
+	}
+}
+
+void MidiDriver_SH_AdLib::programChange(byte MIDIchannel, byte op1) {
+	const InstrumentEntry *instrumentPtr;
+	byte op1Reg = 0;
+	byte op2Reg = 0;
+
+	// setup instrument
+	instrumentPtr = &instrumentTable[op1];
+	//warning("program change for MIDI channel %d, instrument id %d", MIDIchannel, op1);
+
+	for (byte FMvoiceChannel = 0; FMvoiceChannel < SHERLOCK_ADLIB_VOICES_COUNT; FMvoiceChannel++) {
+		if (_voiceChannelMapping[FMvoiceChannel] == MIDIchannel) {
+
+			op1Reg = operator1Register[FMvoiceChannel];
+			op2Reg = operator2Register[FMvoiceChannel];
+
+			setRegister(0x20 + op1Reg, instrumentPtr->reg20op1);
+			setRegister(0x40 + op1Reg, instrumentPtr->reg40op1);
+			setRegister(0x60 + op1Reg, instrumentPtr->reg60op1);
+			setRegister(0x80 + op1Reg, instrumentPtr->reg80op1);
+			setRegister(0xE0 + op1Reg, instrumentPtr->regE0op1);
+
+			setRegister(0x20 + op2Reg, instrumentPtr->reg20op2);
+			setRegister(0x40 + op2Reg, instrumentPtr->reg40op2);
+			setRegister(0x60 + op2Reg, instrumentPtr->reg60op2);
+			setRegister(0x80 + op2Reg, instrumentPtr->reg80op2);
+			setRegister(0xE0 + op2Reg, instrumentPtr->regE0op2);
+
+			setRegister(0xC0 + FMvoiceChannel, instrumentPtr->regC0);
+
+			// Remember instrument
+			_channels[FMvoiceChannel].currentInstrumentPtr = instrumentPtr;
+		}
+	}
+}
+void MidiDriver_SH_AdLib::setRegister(int reg, int value) {
+	_opl->write(0x220, reg);
+	_opl->write(0x221, value);
+}
+
+uint32 MidiDriver_SH_AdLib::property(int prop, uint32 param) {
+	return 0;
+}
+
+void MidiDriver_SH_AdLib::setTimerCallback(void *timerParam, Common::TimerManager::TimerProc timerProc) {
+	_adlibTimerProc = timerProc;
+	_adlibTimerParam = timerParam;
+}
+
+MidiDriver *MidiDriver_SH_AdLib_create() {
+	return new MidiDriver_SH_AdLib(g_system->getMixer());
+}
+
+void MidiDriver_SH_AdLib_newMusicData(MidiDriver *driver, byte *musicData, int32 musicDataSize) {
+	static_cast<MidiDriver_SH_AdLib *>(driver)->newMusicData(musicData, musicDataSize);
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/drivers/mididriver.h b/engines/sherlock/scalpel/drivers/mididriver.h
new file mode 100644
index 0000000000..1b8ceeda3d
--- /dev/null
+++ b/engines/sherlock/scalpel/drivers/mididriver.h
@@ -0,0 +1,41 @@
+/* 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 SHERLOCK_SCALPEL_DRIVERS_MIDIDRIVER_H
+#define SHERLOCK_SCALPEL_DRIVERS_MIDIDRIVER_H
+
+#include "sherlock/sherlock.h"
+#include "audio/mididrv.h"
+#include "common/error.h"
+
+namespace Sherlock {
+
+extern MidiDriver *MidiDriver_SH_AdLib_create();
+extern void MidiDriver_SH_AdLib_newMusicData(MidiDriver *driver, byte *musicData, int32 musicDataSize);
+
+extern MidiDriver *MidiDriver_MT32_create();
+extern void MidiDriver_MT32_uploadPatches(MidiDriver *driver, byte *driverData, int32 driverSize);
+extern void MidiDriver_MT32_newMusicData(MidiDriver *driver, byte *musicData, int32 musicDataSize);
+
+} // End of namespace Sherlock
+
+#endif // SHERLOCK_SCALPEL_DRIVERS_MIDIDRIVER_H
diff --git a/engines/sherlock/scalpel/drivers/mt32.cpp b/engines/sherlock/scalpel/drivers/mt32.cpp
new file mode 100644
index 0000000000..33e7671719
--- /dev/null
+++ b/engines/sherlock/scalpel/drivers/mt32.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 "sherlock/sherlock.h"
+#include "sherlock/scalpel/drivers/mididriver.h"
+
+#include "common/config-manager.h"
+#include "common/file.h"
+#include "common/system.h"
+#include "common/textconsole.h"
+
+//#include "audio/mididrv.h"
+
+namespace Sherlock {
+
+#define SHERLOCK_MT32_CHANNEL_COUNT 16
+
+const byte mt32ReverbDataSysEx[] = {
+	0x10, 0x00, 0x01, 0x01, 0x05, 0x05, 0xFF
+};
+
+class MidiDriver_MT32 : public MidiDriver {
+public:
+	MidiDriver_MT32() {
+		_driver = NULL;
+		_isOpen = false;
+		_nativeMT32 = false;
+		_baseFreq = 250;
+
+		memset(_MIDIchannelActive, 1, sizeof(_MIDIchannelActive));
+	}
+	virtual ~MidiDriver_MT32();
+
+	// MidiDriver
+	int open();
+	void close();
+	bool isOpen() const { return _isOpen; }
+
+	void send(uint32 b);
+
+	void newMusicData(byte *musicData, int32 musicDataSize);
+
+	MidiChannel *allocateChannel() {
+		if (_driver)
+			return _driver->allocateChannel();
+		return NULL;
+	}
+	MidiChannel *getPercussionChannel() {
+		if (_driver)
+			return _driver->getPercussionChannel();
+		return NULL;
+	}
+
+	void setTimerCallback(void *timer_param, Common::TimerManager::TimerProc timer_proc) {
+		if (_driver)
+			_driver->setTimerCallback(timer_param, timer_proc);
+	}
+
+	uint32 getBaseTempo() {
+		if (_driver) {
+			return _driver->getBaseTempo();
+		}
+		return 1000000 / _baseFreq;
+	}
+
+protected:
+	Common::Mutex _mutex;
+	MidiDriver *_driver;
+	bool _nativeMT32;
+
+	bool _isOpen;
+	int _baseFreq;
+
+private:
+	// points to a MIDI channel for each of the new voice channels
+	byte _MIDIchannelActive[SHERLOCK_MT32_CHANNEL_COUNT];
+
+public:
+	void uploadMT32Patches(byte *driverData, int32 driverSize);
+
+	void mt32SysEx(const byte *&dataPtr, int32 &bytesLeft);
+};
+
+MidiDriver_MT32::~MidiDriver_MT32() {
+	Common::StackLock lock(_mutex);
+	if (_driver) {
+		_driver->setTimerCallback(0, 0);
+		_driver->close();
+		delete _driver;
+	}
+	_driver = NULL;
+}
+
+int MidiDriver_MT32::open() {
+	assert(!_driver);
+
+	debugC(kDebugLevelMT32Driver, "MT32: starting driver");
+
+	// Setup midi driver
+	MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_PREFER_MT32);
+	MusicType musicType = MidiDriver::getMusicType(dev);
+
+	switch (musicType) {
+	case MT_MT32:
+		_nativeMT32 = true;
+		break;
+	case MT_GM:
+		if (ConfMan.getBool("native_mt32")) {
+			_nativeMT32 = true;
+		}
+		break;
+	default:
+		break;
+	}
+
+	_driver = MidiDriver::createMidi(dev);
+	if (!_driver)
+		return 255;
+
+	if (_nativeMT32)
+		_driver->property(MidiDriver::PROP_CHANNEL_MASK, 0x03FE);
+
+	int ret = _driver->open();
+	if (ret)
+		return ret;
+
+	if (_nativeMT32)
+		_driver->sendMT32Reset();
+	else
+		_driver->sendGMReset();
+
+	return 0;
+}
+
+void MidiDriver_MT32::close() {
+	if (_driver) {
+		_driver->close();
+	}
+}
+
+// Called when a music track got loaded into memory
+void MidiDriver_MT32::newMusicData(byte *musicData, int32 musicDataSize) {
+	assert(musicDataSize >= 0x7F); // Security check
+
+	// MIDI Channel Enable/Disable bytes at offset 0x2 of music data
+	memcpy(&_MIDIchannelActive, musicData + 0x2, SHERLOCK_MT32_CHANNEL_COUNT);
+
+	// Send 16 bytes from offset 0x12 to MT32
+	// All the music tracks of Sherlock seem to contain dummy data
+	// probably a feature, that was used in the game "Ski or Die"
+	// that's why we don't implement this
+
+	// Also send these bytes to MT32 (SysEx) - seems to be reverb configuration
+	if (_nativeMT32) {
+		const byte *reverbData = mt32ReverbDataSysEx;
+		int32       reverbDataSize = sizeof(mt32ReverbDataSysEx);
+		mt32SysEx(reverbData, reverbDataSize);
+	}
+}
+
+void MidiDriver_MT32::uploadMT32Patches(byte *driverData, int32 driverSize) {
+	if (!_driver)
+		return;
+
+	if (!_nativeMT32)
+		return;
+
+	// patch data starts at offset 0x863
+	assert(driverSize == 0x13B9); // Security check
+	assert(driverData[0x863] == 0x7F); // another security check
+
+	const byte *patchPtr  = driverData + 0x863;
+	int32       bytesLeft = driverSize - 0x863;
+
+	while(1) {
+		mt32SysEx(patchPtr, bytesLeft);
+
+		assert(bytesLeft);
+		if (*patchPtr == 0x80) // List terminator
+			break;
+	}
+}
+
+void MidiDriver_MT32::mt32SysEx(const byte *&dataPtr, int32 &bytesLeft) {
+	byte   sysExMessage[270];
+	uint16 sysExPos      = 0;
+	byte   sysExByte     = 0;
+	uint16 sysExChecksum = 0;
+
+	memset(&sysExMessage, 0, sizeof(sysExMessage));
+
+	sysExMessage[0] = 0x41; // Roland
+	sysExMessage[1] = 0x10;
+	sysExMessage[2] = 0x16; // Model MT32
+	sysExMessage[3] = 0x12; // Command DT1
+
+	sysExPos      = 4;
+	sysExChecksum = 0;
+	while (1) {
+		assert(bytesLeft);
+
+		sysExByte = *dataPtr++;
+		bytesLeft--;
+		if (sysExByte == 0xff)
+			break; // Message done
+
+		assert(sysExPos < sizeof(sysExMessage));
+		sysExMessage[sysExPos++] = sysExByte;
+		sysExChecksum -= sysExByte;
+	}
+
+	// Calculate checksum
+	assert(sysExPos < sizeof(sysExMessage));
+	sysExMessage[sysExPos++] = sysExChecksum & 0x7f;
+
+	debugC(kDebugLevelMT32Driver, "MT32: uploading patch data, size %d", sysExPos);
+
+	// Send SysEx
+	_driver->sysEx(sysExMessage, sysExPos);
+
+	// Wait the time it takes to send the SysEx data
+	uint32 delay = (sysExPos + 2) * 1000 / 3125;
+
+	// Plus an additional delay for the MT-32 rev00
+	if (_nativeMT32)
+		delay += 40;
+
+	g_system->delayMillis(delay);
+}
+
+// MIDI messages can be found at http://www.midi.org/techspecs/midimessages.php
+void MidiDriver_MT32::send(uint32 b) {
+	byte command = b & 0xf0;
+	byte channel = b & 0xf;
+
+	if (command == 0xF0) {
+		if (_driver) {
+			_driver->send(b);
+		}
+		return;
+	}
+
+	if (_MIDIchannelActive[channel]) {
+		// Only forward MIDI-data in case the channel is currently enabled via music-data
+		if (_driver) {
+			_driver->send(b);
+		}
+	}
+}
+
+MidiDriver *MidiDriver_MT32_create() {
+	return new MidiDriver_MT32();
+}
+
+void MidiDriver_MT32_newMusicData(MidiDriver *driver, byte *musicData, int32 musicDataSize) {
+	static_cast<MidiDriver_MT32 *>(driver)->newMusicData(musicData, musicDataSize);
+}
+
+void MidiDriver_MT32_uploadPatches(MidiDriver *driver, byte *driverData, int32 driverSize) {
+	static_cast<MidiDriver_MT32 *>(driver)->uploadMT32Patches(driverData, driverSize);
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel.cpp b/engines/sherlock/scalpel/scalpel.cpp
new file mode 100644
index 0000000000..b17f38b218
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel.cpp
@@ -0,0 +1,1425 @@
+/* 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 "engines/util.h"
+#include "gui/saveload.h"
+#include "common/translation.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/scalpel/scalpel_fixed_text.h"
+#include "sherlock/scalpel/scalpel_map.h"
+#include "sherlock/scalpel/scalpel_people.h"
+#include "sherlock/scalpel/scalpel_scene.h"
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "sherlock/scalpel/tsage/logo.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/music.h"
+#include "sherlock/animation.h"
+#include "sherlock/scalpel/3do/movie_decoder.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+#define PROLOGUE_NAMES_COUNT 6
+
+// The following are a list of filenames played in the prologue that have
+// special effects associated with them at specific frames
+static const char *const PROLOGUE_NAMES[PROLOGUE_NAMES_COUNT] = {
+	"subway1", "subway2", "finale2", "suicid", "coff3", "coff4"
+};
+
+static const int PROLOGUE_FRAMES[6][9] = {
+	{ 4, 26, 54, 72, 92, 134, FRAMES_END },
+	{ 2, 80, 95, 117, 166, FRAMES_END },
+	{ 1, FRAMES_END },
+	{ 42, FRAMES_END },
+	{ FRAMES_END },
+	{ FRAMES_END }
+};
+
+#define TITLE_NAMES_COUNT 7
+
+// Title animations file list
+static const char *const TITLE_NAMES[TITLE_NAMES_COUNT] = {
+	"27pro1", "14note", "coff1", "coff2", "coff3", "coff4", "14kick"
+};
+
+static const int TITLE_FRAMES[7][9] = {
+	{ 29, 131, FRAMES_END },
+	{ 55, 80, 95, 117, 166, FRAMES_END },
+	{ 15, FRAMES_END },
+	{ 4, 37, 92, FRAMES_END },
+	{ 2, 43, FRAMES_END },
+	{ 2, FRAMES_END },
+	{ 10, 50, FRAMES_END }
+};
+
+#define NUM_PLACES 100
+
+static const int MAP_X[NUM_PLACES] = {
+	0, 368, 0, 219, 0, 282, 0, 43, 0, 0, 396, 408, 0, 0, 0, 568, 37, 325,
+	28, 0, 263, 36, 148, 469, 342, 143, 443, 229, 298, 0, 157, 260, 432,
+	174, 0, 351, 0, 528, 0, 136, 0, 0, 0, 555, 165, 0, 506, 0, 0, 344, 0, 0
+};
+static const int MAP_Y[NUM_PLACES] = {
+	0, 147, 0, 166, 0, 109, 0, 61, 0, 0, 264, 70, 0, 0, 0, 266, 341, 30, 275,
+	0, 294, 146, 311, 230, 184, 268, 133, 94, 207, 0, 142, 142, 330, 255, 0,
+	37, 0, 70, 0, 116, 0, 0, 0, 50, 21, 0, 303, 0, 0, 229, 0, 0
+};
+
+static const int MAP_TRANSLATE[NUM_PLACES] = {
+	0, 0, 0, 1, 0, 2, 0, 3, 4, 0, 4, 6, 0, 0, 0, 8, 9, 10, 11, 0, 12, 13, 14, 7,
+	15, 16, 17, 18, 19, 0, 20, 21, 22, 23, 0, 24, 0, 25, 0, 26, 0, 0, 0, 27,
+	28, 0, 29, 0, 0, 30, 0
+};
+
+static const byte MAP_SEQUENCES[3][MAX_FRAME] = {
+	{ 1, 1, 2, 3, 4, 0 },		// Overview Still
+	{ 5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 0 },
+	{ 5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 0 }
+};
+
+#define MAX_PEOPLE 66
+
+struct PeopleData {
+	const char *portrait;
+	int fixedTextId;
+	byte stillSequences[MAX_TALK_SEQUENCES];
+	byte talkSequences[MAX_TALK_SEQUENCES];
+};
+
+const PeopleData PEOPLE_DATA[MAX_PEOPLE] = {
+	{ "HOLM", kFixedText_People_SherlockHolmes, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "WATS", kFixedText_People_DrWatson, { 6, 0, 0 }, { 5, 5, 6, 7, 8, 7, 8, 6, 0, 0 } },
+	{ "LEST", kFixedText_People_InspectorLestrade, { 4, 0, 0 }, { 2, 0, 0 } },
+	{ "CON1", kFixedText_People_ConstableOBrien, { 2, 0, 0 }, { 1, 0, 0 } },
+	{ "CON2", kFixedText_People_ConstableLewis, { 2, 0, 0 }, { 1, 0, 0 } },
+	{ "SHEI", kFixedText_People_SheilaParker, { 2, 0, 0 }, { 2, 3, 0, 0 } },
+	{ "HENR", kFixedText_People_HenryCarruthers, { 3, 0, 0 }, { 3, 0, 0 } },
+	{ "LESL", kFixedText_People_Lesley, { 9, 0, 0 }, { 1, 2, 3, 2, 1, 2, 3, 0, 0 } },
+	{ "USH1", kFixedText_People_AnUsher, { 13, 0, 0 }, { 13, 14, 0, 0 } },
+	{ "USH2", kFixedText_People_AnUsher, { 2, 0, 0 }, { 2, 0, 0 } },
+	{ "FRED", kFixedText_People_FredrickEpstein, { 4, 0, 0 }, { 1, 2, 3, 4, 3, 4, 3, 2, 0, 0 } },
+	{ "WORT", kFixedText_People_MrsWorthington, { 9, 0, 0 }, { 8, 0, 0 } },
+	{ "COAC", kFixedText_People_TheCoach, { 2, 0, 0 }, { 1, 2, 3, 4, 5, 4, 3, 2, 0, 0 } },
+	{ "PLAY", kFixedText_People_APlayer, { 8, 0, 0 }, { 7, 8, 0, 0 } },
+	{ "WBOY", kFixedText_People_Tim, { 13, 0, 0 }, { 12, 13, 0, 0 } },
+	{ "JAME", kFixedText_People_JamesSanders, { 6, 0, 0 }, { 3, 4, 0, 0 } },
+	{ "BELL", kFixedText_People_Belle, { 1, 0, 0 }, { 4, 5, 0, 0 } },
+	{ "GIRL", kFixedText_People_CleaningGirl, { 20, 0, 0 }, { 14, 15, 16, 17, 18, 19, 20, 20, 20, 0, 0 } },
+	{ "EPST", kFixedText_People_FredrickEpstein, { 17, 0, 0 }, { 16, 17, 18, 18, 18, 17, 17, 0, 0 } },
+	{ "WIGG", kFixedText_People_Wiggins, { 3, 0, 0 }, { 2, 3, 0, 0 } },
+	{ "PAUL", kFixedText_People_Paul, { 2, 0, 0 }, { 1, 2, 0, 0 } },
+	{ "BART", kFixedText_People_TheBartender, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "DIRT", kFixedText_People_ADirtyDrunk, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "SHOU", kFixedText_People_AShoutingDrunk, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "STAG", kFixedText_People_AStaggeringDrunk, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "BOUN", kFixedText_People_TheBouncer, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "SAND", kFixedText_People_JamesSanders, { 6, 0, 0 }, { 5, 6, 0, 0 } },
+	{ "CORO", kFixedText_People_TheCoroner, { 6, 0, 0 }, { 4, 5, 0, 0 } },
+	{ "EQUE", kFixedText_People_ReginaldSnipes, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "GEOR", kFixedText_People_GeorgeBlackwood, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "LARS", kFixedText_People_Lars, { 7, 0, 0 }, { 5, 6, 0, 0 } },
+	{ "PARK", kFixedText_People_SheilaParker, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "CHEM", kFixedText_People_TheChemist, { 8, 0, 0 }, { 8, 9, 0, 0 } },
+	{ "GREG", kFixedText_People_InspectorGregson, { 6, 0, 0 }, { 5, 6, 0, 0 } },
+	{ "LAWY", kFixedText_People_JacobFarthington, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "MYCR", kFixedText_People_Mycroft, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "SHER", kFixedText_People_OldSherman, { 7, 0, 0 }, { 7, 8, 0, 0 } },
+	{ "CHMB", kFixedText_People_Richard, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "BARM", kFixedText_People_TheBarman, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "DAND", kFixedText_People_ADandyPlayer, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "ROUG", kFixedText_People_ARoughlookingPlayer, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "SPEC", kFixedText_People_ASpectator, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "HUNT", kFixedText_People_RobertHunt, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "VIOL", kFixedText_People_Violet, { 3, 0, 0 }, { 3, 4, 0, 0 } },
+	{ "PETT", kFixedText_People_Pettigrew, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "APPL", kFixedText_People_Augie, { 8, 0, 0 }, { 14, 15, 0, 0 } },
+	{ "ANNA", kFixedText_People_AnnaCarroway, { 16, 0, 0 }, { 3, 4, 5, 6, 0, 0 } },
+	{ "GUAR", kFixedText_People_AGuard, { 1, 0, 0 }, { 4, 5, 6, 0, 0 } },
+	{ "ANTO", kFixedText_People_AntonioCaruso, { 8, 0, 0 }, { 7, 8, 0, 0 } },
+	{ "TOBY", kFixedText_People_TobyTheDog, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "KING", kFixedText_People_SimonKingsley, { 13, 0, 0 }, { 13, 14, 0, 0 } },
+	{ "ALFR", kFixedText_People_Alfred, { 2, 0, 0 }, { 2, 3, 0, 0 } },
+	{ "LADY", kFixedText_People_LadyBrumwell, { 1, 0, 0 }, { 3, 4, 0, 0 } },
+	{ "ROSA", kFixedText_People_MadameRosa, { 1, 0, 0 }, { 1, 30, 0, 0 } },
+	{ "LADB", kFixedText_People_LadyBrumwell, { 1, 0, 0 }, { 3, 4, 0, 0 } },
+	{ "MOOR", kFixedText_People_JosephMoorehead, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "BEAL", kFixedText_People_MrsBeale, { 5, 0, 0 }, { 14, 15, 16, 17, 18, 19, 20, 0, 0 } },
+	{ "LION", kFixedText_People_Felix, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "HOLL", kFixedText_People_Hollingston, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "CALL", kFixedText_People_ConstableCallaghan, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "JERE", kFixedText_People_SergeantDuncan, { 2, 0, 0 }, { 1, 1, 2, 2, 0, 0 } },
+	{ "LORD", kFixedText_People_LordBrumwell, { 1, 0, 0 }, { 9, 10, 0, 0 } },
+	{ "NIGE", kFixedText_People_NigelJaimeson, { 1, 0, 0 }, { 1, 2, 0, 138, 3, 4, 0, 138, 0, 0 } },
+	{ "JONA", kFixedText_People_Jonas, { 1, 0, 0 }, { 1, 8, 0, 0 } },
+	{ "DUGA", kFixedText_People_ConstableDugan, { 1, 0, 0 }, { 1, 0, 0 } },
+	{ "INSP", kFixedText_People_InspectorLestrade, { 4, 0, 0 }, { 2, 0, 0 } }
+};
+
+uint INFO_BLACK;
+uint BORDER_COLOR;
+uint COMMAND_BACKGROUND;
+uint BUTTON_BACKGROUND;
+uint TALK_FOREGROUND;
+uint TALK_NULL;
+uint BUTTON_TOP;
+uint BUTTON_MIDDLE;
+uint BUTTON_BOTTOM;
+uint COMMAND_FOREGROUND;
+uint COMMAND_HIGHLIGHTED;
+uint COMMAND_NULL;
+uint INFO_FOREGROUND;
+uint INFO_BACKGROUND;
+uint INV_FOREGROUND;
+uint INV_BACKGROUND;
+uint PEN_COLOR;
+
+/*----------------------------------------------------------------*/
+
+#define FROM_RGB(r, g, b) pixelFormatRGB565.RGBToColor(r, g, b)
+
+ScalpelEngine::ScalpelEngine(OSystem *syst, const SherlockGameDescription *gameDesc) :
+		SherlockEngine(syst, gameDesc) {
+	_darts = nullptr;
+	_mapResult = 0;
+
+	if (getPlatform() == Common::kPlatform3DO) {
+		const Graphics::PixelFormat pixelFormatRGB565 = Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0);
+		INFO_BLACK = FROM_RGB(0, 0, 0);
+		BORDER_COLOR = FROM_RGB(0x6d, 0x38, 0x10);
+		COMMAND_BACKGROUND = FROM_RGB(0x38, 0x38, 0xce);
+		BUTTON_BACKGROUND = FROM_RGB(0x95, 0x5d, 0x24);
+		TALK_FOREGROUND = FROM_RGB(0xff, 0x55, 0x55);
+		TALK_NULL = FROM_RGB(0xce, 0xc6, 0xc2);
+		BUTTON_TOP = FROM_RGB(0xbe, 0x85, 0x3c);
+		BUTTON_MIDDLE = FROM_RGB(0x9d, 0x40, 0);
+		BUTTON_BOTTOM = FROM_RGB(0x69, 0x24, 0);
+		COMMAND_FOREGROUND = FROM_RGB(0xFF, 0xFF, 0xFF);
+		COMMAND_HIGHLIGHTED = FROM_RGB(0x55, 0xff, 0x55);
+		COMMAND_NULL = FROM_RGB(0x69, 0x24, 0);
+		INFO_FOREGROUND = FROM_RGB(0x55, 0xff, 0xff);
+		INFO_BACKGROUND = FROM_RGB(0, 0, 0x48);
+		INV_FOREGROUND = FROM_RGB(0xff, 0xff, 0x55);
+		INV_BACKGROUND = FROM_RGB(0, 0, 0x48);
+		PEN_COLOR = FROM_RGB(0x50, 0x18, 0);
+	} else {
+		INFO_BLACK = 1;
+		BORDER_COLOR = 237;
+		COMMAND_BACKGROUND = 4;
+		BUTTON_BACKGROUND = 235;
+		TALK_FOREGROUND = 12;
+		TALK_NULL = 16;
+		BUTTON_TOP = 233;
+		BUTTON_MIDDLE = 244;
+		BUTTON_BOTTOM = 248;
+		COMMAND_FOREGROUND = 15;
+		COMMAND_HIGHLIGHTED = 10;
+		COMMAND_NULL = 248;
+		INFO_FOREGROUND = 11;
+		INFO_BACKGROUND = 1;
+		INV_FOREGROUND = 14;
+		INV_BACKGROUND = 1;
+		PEN_COLOR = 250;
+	}
+}
+
+ScalpelEngine::~ScalpelEngine() {
+	delete _darts;
+}
+
+void ScalpelEngine::setupGraphics() {
+	if (getPlatform() != Common::kPlatform3DO) {
+		// 320x200 palettized
+		initGraphics(320, 200, false);
+	} else {
+		// 3DO actually uses RGB555, but some platforms of ours only support RGB565, so we use that
+		const Graphics::PixelFormat pixelFormatRGB565 = Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0);
+
+		// First try for a 640x400 mode
+		g_system->beginGFXTransaction();
+		initCommonGFX(true);
+		g_system->initSize(640, 400, &pixelFormatRGB565);
+		OSystem::TransactionError gfxError = g_system->endGFXTransaction();
+
+		if (gfxError == OSystem::kTransactionSuccess) {
+			_isScreenDoubled = true;
+		} else {
+			// System doesn't support it, so fall back on 320x200 mode
+			initGraphics(320, 200, false, &pixelFormatRGB565);
+		}
+	}
+}
+
+void ScalpelEngine::initialize() {
+	// Setup graphics mode
+	setupGraphics();
+
+	// Let the base engine intialize
+	SherlockEngine::initialize();
+
+	_darts = new Darts(this);
+
+	_flags.resize(100 * 8);
+	_flags[3] = true;		// Turn on Alley
+	_flags[39] = true;		// Turn on Baker Street
+
+	if (!isDemo()) {
+		// Load the map co-ordinates for each scene and sequence data
+		ScalpelMap &map = *(ScalpelMap *)_map;
+		map.loadPoints(NUM_PLACES, &MAP_X[0], &MAP_Y[0], &MAP_TRANSLATE[0]);
+		map.loadSequences(3, &MAP_SEQUENCES[0][0]);
+		map._oldCharPoint = BAKER_ST_EXTERIOR;
+	}
+
+	// Load the inventory
+	loadInventory();
+
+	// Set up list of people
+	ScalpelFixedText &fixedText = *(ScalpelFixedText *)_fixedText;
+	const char *peopleNamePtr = nullptr;
+
+	for (int idx = 0; idx < MAX_PEOPLE; ++idx) {
+		peopleNamePtr = fixedText.getText(PEOPLE_DATA[idx].fixedTextId);
+		_people->_characters.push_back(PersonData(peopleNamePtr, PEOPLE_DATA[idx].portrait,
+			PEOPLE_DATA[idx].stillSequences, PEOPLE_DATA[idx].talkSequences));
+	}
+
+	_animation->setPrologueNames(&PROLOGUE_NAMES[0], PROLOGUE_NAMES_COUNT);
+	_animation->setPrologueFrames(&PROLOGUE_FRAMES[0][0], 6, 9);
+
+	_animation->setTitleNames(&TITLE_NAMES[0], TITLE_NAMES_COUNT);
+	_animation->setTitleFrames(&TITLE_FRAMES[0][0], 7, 9);
+
+	// Starting scene
+	if (isDemo() && _interactiveFl)
+		_scene->_goToScene = 3;
+	else
+		_scene->_goToScene = 4;
+}
+
+void ScalpelEngine::showOpening() {
+	bool finished = true;
+
+	if (isDemo() && _interactiveFl)
+		return;
+
+	_events->setFrameRate(60);
+
+	if (getPlatform() == Common::kPlatform3DO) {
+		show3DOSplash();
+
+		finished = showCityCutscene3DO();
+		if (finished)
+			finished = showAlleyCutscene3DO();
+		if (finished)
+			finished = showStreetCutscene3DO();
+		if (finished)
+			showOfficeCutscene3DO();
+
+		_events->clearEvents();
+		_music->stopMusic();
+	} else {
+		TsAGE::Logo::show(this);
+
+		finished = showCityCutscene();
+		if (finished)
+			finished = showAlleyCutscene();
+		if (finished)
+			finished = showStreetCutscene();
+		if (finished)
+			showOfficeCutscene();
+
+		_events->clearEvents();
+		_music->stopMusic();
+	}
+
+	_events->setFrameRate(GAME_FRAME_RATE);
+}
+
+bool ScalpelEngine::showCityCutscene() {
+	byte greyPalette[PALETTE_SIZE];
+	byte palette[PALETTE_SIZE];
+
+	// Demo fades from black into grey and then fades from grey into the scene
+	Common::fill(&greyPalette[0], &greyPalette[PALETTE_SIZE], 142);
+	_screen->fadeIn((const byte *)greyPalette, 3);
+
+	_music->loadSong("prolog1");
+	_animation->_gfxLibraryFilename = "title.lib";
+	_animation->_soundLibraryFilename = "title.snd";
+	bool finished = _animation->play("26open1", true, 1, 255, true, 2);
+
+	if (finished) {
+		ImageFile titleImages_LondonNovember("title2.vgs", true);
+		_screen->_backBuffer1.blitFrom(*_screen);
+		_screen->_backBuffer2.blitFrom(*_screen);
+
+		Common::Point londonPosition;
+
+		if ((titleImages_LondonNovember[0]._width == 302) && (titleImages_LondonNovember[0]._height == 39)) {
+			// Spanish
+			londonPosition = Common::Point(9, 8);
+		} else {
+			// English (German uses the same English graphics), width 272, height 37
+			// In the German version this is placed differently, check against German floppy version TODO
+			londonPosition = Common::Point(30, 50);
+		}
+
+		// London, England
+		_screen->_backBuffer1.transBlitFrom(titleImages_LondonNovember[0], londonPosition);
+		_screen->randomTransition();
+		finished = _events->delay(1000, true);
+
+		// November, 1888
+		if (finished) {
+			_screen->_backBuffer1.transBlitFrom(titleImages_LondonNovember[1], Common::Point(100, 100));
+			_screen->randomTransition();
+			finished = _events->delay(5000, true);
+		}
+
+		// Transition out the title
+		_screen->_backBuffer1.blitFrom(_screen->_backBuffer2);
+		_screen->randomTransition();
+	}
+
+	if (finished)
+		finished = _animation->play("26open2", true, 1, 0, false, 2);
+
+	if (finished) {
+		ImageFile titleImages_SherlockHolmesTitle("title.vgs", true);
+		_screen->_backBuffer1.blitFrom(*_screen);
+		_screen->_backBuffer2.blitFrom(*_screen);
+
+		Common::Point lostFilesPosition;
+		Common::Point sherlockHolmesPosition;
+		Common::Point copyrightPosition;
+
+		if ((titleImages_SherlockHolmesTitle[0]._width == 306) && (titleImages_SherlockHolmesTitle[0]._height == 39)) {
+			// Spanish
+			lostFilesPosition = Common::Point(5, 5);
+			sherlockHolmesPosition = Common::Point(24, 40);
+			copyrightPosition = Common::Point(3, 190);
+		} else {
+			// English (German uses the same English graphics), width 208, height 39
+			lostFilesPosition = Common::Point(75, 6);
+			sherlockHolmesPosition = Common::Point(34, 21);
+			copyrightPosition = Common::Point(4, 190);
+		}
+
+		// The Lost Files of
+		_screen->_backBuffer1.transBlitFrom(titleImages_SherlockHolmesTitle[0], lostFilesPosition);
+		// Sherlock Holmes
+		_screen->_backBuffer1.transBlitFrom(titleImages_SherlockHolmesTitle[1], sherlockHolmesPosition);
+		// copyright
+		_screen->_backBuffer1.transBlitFrom(titleImages_SherlockHolmesTitle[2], copyrightPosition);
+
+		_screen->verticalTransition();
+		finished = _events->delay(4000, true);
+
+		if (finished) {
+			_screen->_backBuffer1.blitFrom(_screen->_backBuffer2);
+			_screen->randomTransition();
+			finished = _events->delay(2000);
+		}
+
+		if (finished) {
+			_screen->getPalette(palette);
+			_screen->fadeToBlack(2);
+		}
+
+		if (finished) {
+			// In the alley...
+			Common::Point alleyPosition;
+
+			if ((titleImages_SherlockHolmesTitle[3]._width == 105) && (titleImages_SherlockHolmesTitle[3]._height == 16)) {
+				// German
+				alleyPosition = Common::Point(72, 50);
+			} else if ((titleImages_SherlockHolmesTitle[3]._width == 166) && (titleImages_SherlockHolmesTitle[3]._height == 36)) {
+				// Spanish
+				alleyPosition = Common::Point(71, 50);
+			} else {
+				// English, width 175, height 38
+				alleyPosition = Common::Point(72, 51);
+			}
+			_screen->transBlitFrom(titleImages_SherlockHolmesTitle[3], alleyPosition);
+			_screen->fadeIn(palette, 3);
+
+			// Wait until the track got looped and the first few notes were played
+			finished = _music->waitUntilMSec(4300, 21300, 0, 2500); // ticks 0x104 / ticks 0x500
+		}
+	}
+
+	_animation->_gfxLibraryFilename = "";
+	_animation->_soundLibraryFilename = "";
+	return finished;
+}
+
+bool ScalpelEngine::showAlleyCutscene() {
+	byte palette[PALETTE_SIZE];
+	_music->loadSong("prolog2");
+
+	_animation->_gfxLibraryFilename = "TITLE.LIB";
+	_animation->_soundLibraryFilename = "TITLE.SND";
+
+	// Fade "In The Alley..." text to black
+	_screen->fadeToBlack(2);
+
+	bool finished = _animation->play("27PRO1", true, 1, 3, true, 2);
+	if (finished) {
+		_screen->getPalette(palette);
+		_screen->fadeToBlack(2);
+
+		// wait until second lower main note
+		finished = _music->waitUntilMSec(26800, 0xFFFFFFFF, 0, 1000); // ticks 0x64A
+	}
+
+	if (finished) {
+		_screen->setPalette(palette);
+		finished = _animation->play("27PRO2", true, 1, 0, false, 2);
+	}
+
+	if (finished) {
+		showLBV("scream.lbv");
+
+		// wait until first "scream" in music happened
+		finished = _music->waitUntilMSec(45800, 0xFFFFFFFF, 0, 6000); // ticks 0xABE
+	}
+
+	if (finished) {
+		// quick fade out 
+		_screen->fadeToBlack(1);
+
+		// wait until after third "scream" in music happened
+		finished = _music->waitUntilMSec(49000, 0xFFFFFFFF, 0, 2000); // ticks 0xB80
+	}
+
+	if (finished)
+		finished = _animation->play("27PRO3", true, 1, 0, true, 2);
+
+	if (finished) {
+		_screen->getPalette(palette);
+		_screen->fadeToBlack(2);
+	}
+
+	if (finished) {
+		ImageFile titleImages_EarlyTheFollowingMorning("title3.vgs", true);
+		// "Early the following morning on Baker Street..."
+		Common::Point earlyTheFollowingMorningPosition;
+
+		if ((titleImages_EarlyTheFollowingMorning[0]._width == 164) && (titleImages_EarlyTheFollowingMorning[0]._height == 19)) {
+			// German
+			earlyTheFollowingMorningPosition = Common::Point(35, 50);
+		} else if ((titleImages_EarlyTheFollowingMorning[0]._width == 171) && (titleImages_EarlyTheFollowingMorning[0]._height == 32)) {
+			// Spanish
+			earlyTheFollowingMorningPosition = Common::Point(35, 50);
+		} else {
+			// English, width 218, height 31
+			earlyTheFollowingMorningPosition = Common::Point(35, 52);
+		}
+
+		_screen->transBlitFrom(titleImages_EarlyTheFollowingMorning[0], earlyTheFollowingMorningPosition);
+
+		// fast fade-in
+		_screen->fadeIn(palette, 1);
+
+		// wait for music to end and wait an additional 2.5 seconds
+		finished = _music->waitUntilMSec(0xFFFFFFFF, 0xFFFFFFFF, 2500, 3000);
+	}
+
+	_animation->_gfxLibraryFilename = "";
+	_animation->_soundLibraryFilename = "";
+	return finished;
+}
+
+bool ScalpelEngine::showStreetCutscene() {
+	_animation->_gfxLibraryFilename = "TITLE.LIB";
+	_animation->_soundLibraryFilename = "TITLE.SND";
+
+	_music->loadSong("prolog3");
+
+	// wait a bit
+	bool finished = _events->delay(500);
+
+	if (finished) {
+		// fade out "Early the following morning..."
+		_screen->fadeToBlack(2);
+
+		// wait for music a bit
+		finished = _music->waitUntilMSec(3800, 0xFFFFFFFF, 0, 1000); // ticks 0xE4
+	}
+
+	if (finished)
+		finished = _animation->play("14KICK", true, 1, 3, true, 2);
+
+	// Constable animation plays slower than speed 2
+	// If we play it with speed 2, music gets obviously out of sync
+	if (finished)
+		finished = _animation->play("14NOTE", true, 1, 0, false, 3);
+
+	// Fade to black
+	if (finished)
+		_screen->fadeToBlack(1);
+
+	_animation->_gfxLibraryFilename = "";
+	_animation->_soundLibraryFilename = "";
+	return finished;
+}
+
+bool ScalpelEngine::showOfficeCutscene() {
+	_music->loadSong("prolog4");
+	_animation->_gfxLibraryFilename = "TITLE2.LIB";
+	_animation->_soundLibraryFilename = "TITLE.SND";
+
+	bool finished = _animation->play("COFF1", true, 1, 3, true, 3);
+	if (finished)
+		finished = _animation->play("COFF2", true, 1, 0, false, 3);
+	if (finished) {
+		showLBV("note.lbv");
+
+		if (_sound->_voices) {
+			finished = _sound->playSound("NOTE1", WAIT_KBD_OR_FINISH);
+			if (finished)
+				finished = _sound->playSound("NOTE2", WAIT_KBD_OR_FINISH);
+			if (finished)
+				finished = _sound->playSound("NOTE3", WAIT_KBD_OR_FINISH);
+			if (finished)
+				finished = _sound->playSound("NOTE4", WAIT_KBD_OR_FINISH);
+		} else
+			finished = _events->delay(19000);
+
+		if (finished) {
+			_events->clearEvents();
+			finished = _events->delay(500);
+		}
+	}
+
+	if (finished)
+		finished = _animation->play("COFF3", true, 1, 0, true, 3);
+
+	if (finished)
+		finished = _animation->play("COFF4", true, 1, 0, false, 3);
+
+	if (finished)
+		finished = scrollCredits();
+
+	if (finished)
+		_screen->fadeToBlack(3);
+
+	_animation->_gfxLibraryFilename = "";
+	_animation->_soundLibraryFilename = "";
+	return finished;
+}
+
+bool ScalpelEngine::scrollCredits() {
+	// Load the images for displaying credit text
+	Common::SeekableReadStream *stream = _res->load("credits.vgs", "title.lib");
+	ImageFile creditsImages(*stream);
+
+	// Demo fades slowly from the scene into credits palette
+	_screen->fadeIn(creditsImages._palette, 3);
+
+	delete stream;
+
+	// Save a copy of the screen background for use in drawing each credit frame
+	_screen->_backBuffer1.blitFrom(*_screen);
+
+	// Loop for showing the credits
+	for(int idx = 0; idx < 600 && !_events->kbHit() && !shouldQuit(); ++idx) {
+		// Copy the entire screen background before writing text
+		_screen->blitFrom(_screen->_backBuffer1);
+
+		// Write the text appropriate for the next frame
+		if (idx < 400)
+			_screen->transBlitFrom(creditsImages[0], Common::Point(10, 200 - idx), false, 0);
+		if (idx > 200)
+			_screen->transBlitFrom(creditsImages[1], Common::Point(10, 400 - idx), false, 0);
+
+		// Don't show credit text on the top and bottom ten rows of the screen
+		_screen->blitFrom(_screen->_backBuffer1, Common::Point(0, 0), Common::Rect(0, 0, _screen->w(), 10));
+		_screen->blitFrom(_screen->_backBuffer1, Common::Point(0, _screen->h() - 10),
+			Common::Rect(0, _screen->h() - 10, _screen->w(), _screen->h()));
+
+		_events->delay(100);
+	}
+
+	return true;
+}
+
+// 3DO variant
+bool ScalpelEngine::show3DOSplash() {
+	// 3DO EA Splash screen
+	ImageFile3DO titleImage_3DOSplash("3DOSplash.cel", kImageFile3DOType_Cel);
+
+	_screen->transBlitFrom(titleImage_3DOSplash[0]._frame, Common::Point(0, -20));
+	bool finished = _events->delay(3000, true);
+
+	if (finished) {
+		_screen->clear();
+		finished = _events->delay(500, true);
+	}
+
+	if (finished) {
+		// EA logo movie
+		play3doMovie("EAlogo.stream", Common::Point(20, 0));
+	}
+
+	// Always clear screen
+	_screen->clear();
+	return finished;
+}
+
+bool ScalpelEngine::showCityCutscene3DO() {
+	Scalpel3DOScreen &screen = *(Scalpel3DOScreen *)_screen;
+	_animation->_soundLibraryFilename = "TITLE.SND";
+
+	screen.clear();
+	bool finished = _events->delay(2500, true);
+
+	if (finished) {
+		finished = _events->delay(2500, true);
+
+		// Play intro music
+		_music->loadSong("prolog");
+
+		// Loop rain.aiff until the Sherlock logo fades away.
+		// TODO: The volume is just a guess.
+		_sound->playAiff("prologue/sounds/rain.aiff", 15, true);
+
+		// Fade screen to grey
+		screen._backBuffer1.fill(0xCE59); // RGB565: 25, 50, 25 (grey)
+		screen.fadeIntoScreen3DO(2);
+	}
+
+	if (finished) {
+		finished = _music->waitUntilMSec(3400, 0, 0, 3400);
+	}
+
+	if (finished) {
+		screen._backBuffer1.fill(0); // fill backbuffer with black to avoid issues during fade from white
+		finished = _animation->play3DO("26open1", true, 1, true, 2);
+	}
+
+	if (finished) {
+		screen._backBuffer2.blitFrom(screen._backBuffer1);
+
+		// "London, England"
+		ImageFile3DO titleImage_London("title2a.cel", kImageFile3DOType_Cel);
+		screen._backBuffer1.transBlitFrom(titleImage_London[0]._frame, Common::Point(30, 50));
+
+		screen.fadeIntoScreen3DO(1);
+		finished = _events->delay(1500, true);
+
+		if (finished) {
+			// "November, 1888"
+			ImageFile3DO titleImage_November("title2b.cel", kImageFile3DOType_Cel);
+			screen._backBuffer1.transBlitFrom(titleImage_November[0]._frame, Common::Point(100, 100));
+
+			screen.fadeIntoScreen3DO(1);
+			finished = _music->waitUntilMSec(14700, 0, 0, 5000);
+		}
+
+		if (finished) {
+			// Restore screen
+			_screen->_backBuffer1.blitFrom(screen._backBuffer2);
+			_screen->blitFrom(screen._backBuffer1);
+		}
+	}
+
+	if (finished)
+		finished = _animation->play3DO("26open2", true, 1, false, 2);
+
+	if (finished) {
+		// "Sherlock Holmes" (title)
+		ImageFile3DO titleImage_SherlockHolmesTitle("title1ab.cel", kImageFile3DOType_Cel);
+		screen._backBuffer1.transBlitFrom(titleImage_SherlockHolmesTitle[0]._frame, Common::Point(34, 5));
+
+		// Blend in
+		screen.fadeIntoScreen3DO(2);
+		finished = _events->delay(500, true);
+
+		// Title should fade in, Copyright should be displayed a bit after that
+		if (finished) {
+			ImageFile3DO titleImage_Copyright("title1c.cel", kImageFile3DOType_Cel);
+
+			screen.transBlitFrom(titleImage_Copyright[0]._frame, Common::Point(20, 190));
+			finished = _events->delay(3500, true);
+		}
+	}
+
+	if (finished)
+		finished = _music->waitUntilMSec(33600, 0, 0, 2000);
+
+	_sound->stopAiff();
+
+	if (finished) {
+		// Fade to black
+		screen._backBuffer1.clear();
+		screen.fadeIntoScreen3DO(3);
+	}
+
+	if (finished) {
+		// "In the alley behind the Regency Theatre..."
+		ImageFile3DO titleImage_InTheAlley("title1d.cel", kImageFile3DOType_Cel);
+		screen._backBuffer1.transBlitFrom(titleImage_InTheAlley[0]._frame, Common::Point(72, 51));
+
+		// Fade in
+		screen.fadeIntoScreen3DO(4);
+		finished = _music->waitUntilMSec(39900, 0, 0, 2500);
+
+		// Fade out
+		screen._backBuffer1.clear();
+		screen.fadeIntoScreen3DO(4);
+	}
+	return finished;
+}
+
+bool ScalpelEngine::showAlleyCutscene3DO() {
+	Scalpel3DOScreen &screen = *(Scalpel3DOScreen *)_screen;
+	bool finished = _music->waitUntilMSec(43500, 0, 0, 1000);
+
+	if (finished)
+		finished = _animation->play3DO("27PRO1", true, 1, false, 2);
+
+	if (finished) {
+		// Fade out...
+		screen._backBuffer1.clear();
+		screen.fadeIntoScreen3DO(3);
+
+		finished = _music->waitUntilMSec(67100, 0, 0, 1000); // 66700
+	}
+
+	if (finished)
+		finished = _animation->play3DO("27PRO2", true, 1, false, 2);
+
+	if (finished)
+		finished = _music->waitUntilMSec(76000, 0, 0, 1000);
+
+	if (finished) {
+		// Show screaming victim
+		ImageFile3DO titleImage_ScreamingVictim("scream.cel", kImageFile3DOType_Cel);
+
+		screen.clear();
+		screen.transBlitFrom(titleImage_ScreamingVictim[0]._frame, Common::Point(0, 0));
+
+		// Play "scream.aiff"
+		if (_sound->_voices)
+			_sound->playSound("prologue/sounds/scream.aiff", WAIT_RETURN_IMMEDIATELY, 100);
+
+		finished = _music->waitUntilMSec(81600, 0, 0, 6000);
+	}
+
+	if (finished) {
+		// Fade out
+		screen._backBuffer1.clear();
+		screen.fadeIntoScreen3DO(5);
+
+		finished = _music->waitUntilMSec(84400, 0, 0, 2000);
+	}
+
+	if (finished)
+		finished = _animation->play3DO("27PRO3", true, 1, false, 2);
+
+	if (finished) {
+		// Fade out
+		screen._backBuffer1.clear();
+		screen.fadeIntoScreen3DO(5);
+	}
+
+	if (finished) {
+		// "Early the following morning on Baker Street..."
+		ImageFile3DO titleImage_EarlyTheFollowingMorning("title3.cel", kImageFile3DOType_Cel);
+		screen._backBuffer1.transBlitFrom(titleImage_EarlyTheFollowingMorning[0]._frame, Common::Point(35, 51));
+
+		// Fade in
+		screen.fadeIntoScreen3DO(4);
+		finished = _music->waitUntilMSec(96700, 0, 0, 3000);
+	}
+
+	return finished;
+}
+
+bool ScalpelEngine::showStreetCutscene3DO() {
+	Scalpel3DOScreen &screen = *(Scalpel3DOScreen *)_screen;
+	bool finished = true;
+
+	if (finished) {
+		// fade out "Early the following morning..."
+		screen._backBuffer1.clear();
+		screen.fadeIntoScreen3DO(4);
+
+		// wait for music a bit
+		finished = _music->waitUntilMSec(100300, 0, 0, 1000);
+	}
+
+	if (finished)
+		finished = _animation->play3DO("14KICK", true, 1, false, 2);
+
+	// note: part of the constable is sticking to the door during the following
+	//       animation, when he walks away. This is a bug of course, but it actually happened on 3DO!
+	//       I'm not sure if it happens because the door is pure black (0, 0, 0) and it's because
+	//       of transparency - or if the animation itself is bad. We will definitely have to adjust
+	//       the animation data to fix it.
+	if (finished)
+		finished = _animation->play3DO("14NOTE", true, 1, false, 3);
+
+	if (finished) {
+		// Fade out
+		screen._backBuffer1.clear();
+		screen.fadeIntoScreen3DO(4);
+	}
+
+	return finished;
+}
+
+bool ScalpelEngine::showOfficeCutscene3DO() {
+	bool finished = _music->waitUntilMSec(151000, 0, 0, 1000);
+
+	if (finished)
+		finished = _animation->play3DO("COFF1", true, 1, false, 3);
+
+	if (finished)
+		finished = _animation->play3DO("COFF2", true, 1, false, 3);
+
+	if (finished)
+		finished = _music->waitUntilMSec(182400, 0, 0, 1000);
+
+	if (finished) {
+		// Show the note
+		ImageFile3DO titleImage_CoffeeNote("note.cel", kImageFile3DOType_Cel);
+
+		_screen->clear();
+		_screen->transBlitFrom(titleImage_CoffeeNote[0]._frame, Common::Point(0, 0));
+
+		if (_sound->_voices) {
+			finished = _sound->playSound("prologue/sounds/note.aiff", WAIT_KBD_OR_FINISH);
+		} else
+			finished = _events->delay(19000);
+
+		if (finished)
+			finished = _music->waitUntilMSec(218800, 0, 0, 1000);
+
+		// Fade out
+		_screen->clear();
+	}
+
+	if (finished)
+		finished = _music->waitUntilMSec(222200, 0, 0, 1000);
+
+	if (finished)
+		finished = _animation->play3DO("COFF3", true, 1, false, 3);
+
+	if (finished)
+		finished = _animation->play3DO("COFF4", true, 1, false, 3);
+
+	if (finished) {
+		finished = _music->waitUntilMSec(244500, 0, 0, 2000);
+
+		// TODO: Brighten the image, possibly by doing a partial fade
+		// to white.
+
+		_screen->_backBuffer2.blitFrom(_screen->_backBuffer1);
+
+		for (int nr = 1; finished && nr <= 4; nr++) {
+			char filename[15];
+			sprintf(filename, "credits%d.cel", nr);
+			ImageFile3DO *creditsImage = new ImageFile3DO(filename, kImageFile3DOType_Cel);
+			ImageFrame *creditsFrame = &(*creditsImage)[0];
+			for (int i = 0; finished && i < 200 + creditsFrame->_height; i++) {
+				_screen->blitFrom(_screen->_backBuffer2);
+				_screen->transBlitFrom(creditsFrame->_frame, Common::Point((320 - creditsFrame->_width) / 2, 200 - i));
+				if (!_events->delay(70, true))
+					finished = false;
+			}
+			delete creditsImage;
+		}
+	}
+
+	return finished;
+}
+
+void ScalpelEngine::loadInventory() {
+	ScalpelFixedText &fixedText = *(ScalpelFixedText *)_fixedText;
+	Inventory &inv = *_inventory;
+
+	Common::String fixedText_Message    = fixedText.getText(kFixedText_InitInventory_Message);
+	Common::String fixedText_HolmesCard = fixedText.getText(kFixedText_InitInventory_HolmesCard);
+	Common::String fixedText_Tickets    = fixedText.getText(kFixedText_InitInventory_Tickets);
+	Common::String fixedText_CuffLink   = fixedText.getText(kFixedText_InitInventory_CuffLink);
+	Common::String fixedText_WireHook   = fixedText.getText(kFixedText_InitInventory_WireHook);
+	Common::String fixedText_Note       = fixedText.getText(kFixedText_InitInventory_Note);
+	Common::String fixedText_OpenWatch  = fixedText.getText(kFixedText_InitInventory_OpenWatch);
+	Common::String fixedText_Paper      = fixedText.getText(kFixedText_InitInventory_Paper);
+	Common::String fixedText_Letter     = fixedText.getText(kFixedText_InitInventory_Letter);
+	Common::String fixedText_Tarot      = fixedText.getText(kFixedText_InitInventory_Tarot);
+	Common::String fixedText_OrnateKey  = fixedText.getText(kFixedText_InitInventory_OrnateKey);
+	Common::String fixedText_PawnTicket = fixedText.getText(kFixedText_InitInventory_PawnTicket);
+
+	// Initial inventory
+	inv._holdings = 2;
+	inv.push_back(InventoryItem(0,     "Message", fixedText_Message,    "_ITEM03A"));
+	inv.push_back(InventoryItem(0, "Holmes Card", fixedText_HolmesCard, "_ITEM07A"));
+
+	// Hidden items
+	inv.push_back(InventoryItem(95,  "Tickets",     fixedText_Tickets,    "_ITEM10A"));
+	inv.push_back(InventoryItem(138, "Cuff Link",   fixedText_CuffLink,   "_ITEM04A"));
+	inv.push_back(InventoryItem(138, "Wire Hook",   fixedText_WireHook,   "_ITEM06A"));
+	inv.push_back(InventoryItem(150, "Note",        fixedText_Note,       "_ITEM13A"));
+	inv.push_back(InventoryItem(481, "Open Watch",  fixedText_OpenWatch,  "_ITEM62A"));
+	inv.push_back(InventoryItem(481, "Paper",       fixedText_Paper,      "_ITEM44A"));
+	inv.push_back(InventoryItem(532, "Letter",      fixedText_Letter,     "_ITEM68A"));
+	inv.push_back(InventoryItem(544, "Tarot",       fixedText_Tarot,      "_ITEM71A"));
+	inv.push_back(InventoryItem(544, "Ornate Key",  fixedText_OrnateKey,  "_ITEM70A"));
+	inv.push_back(InventoryItem(586, "Pawn ticket", fixedText_PawnTicket, "_ITEM16A"));
+}
+
+void ScalpelEngine::showLBV(const Common::String &filename) {
+	Common::SeekableReadStream *stream = _res->load(filename, "title.lib");
+	ImageFile images(*stream);
+	delete stream;
+
+	_screen->setPalette(images._palette);
+	_screen->_backBuffer1.blitFrom(images[0]);
+	_screen->verticalTransition();
+}
+
+void ScalpelEngine::startScene() {
+	if (_scene->_goToScene == OVERHEAD_MAP || _scene->_goToScene == OVERHEAD_MAP2) {
+		// Show the map
+		if (_music->_musicOn && _music->loadSong(100))
+			_music->startSong();
+
+		_scene->_goToScene = _map->show();
+
+		_music->freeSong();
+		_people->_savedPos = Common::Point(-1, -1);
+		_people->_savedPos._facing = -1;
+	}
+
+	// Some rooms are prologue cutscenes, rather than normal game scenes. These are:
+	//  2: Blackwood's capture
+	// 52: Rescuing Anna
+	// 53: Moorehead's death / subway train
+	// 55: Fade out and exit
+	// 70: Brumwell suicide
+	switch (_scene->_goToScene) {
+	case BLACKWOOD_CAPTURE:
+	case RESCUE_ANNA:
+	case MOOREHEAD_DEATH:
+	case BRUMWELL_SUICIDE:
+		if (_music->_musicOn && _music->loadSong(_scene->_goToScene))
+			_music->startSong();
+
+		switch (_scene->_goToScene) {
+		case BLACKWOOD_CAPTURE:
+			// Blackwood's capture
+			_res->addToCache("final2.vda", "epilogue.lib");
+			_res->addToCache("final2.vdx", "epilogue.lib");
+			_animation->play("final1", false, 1, 3, true, 4);
+			_animation->play("final2", false, 1, 0, false, 4);
+			break;
+
+		case RESCUE_ANNA:
+			// Rescuing Anna
+			_res->addToCache("finalr2.vda", "epilogue.lib");
+			_res->addToCache("finalr2.vdx", "epilogue.lib");
+			_res->addToCache("finale1.vda", "epilogue.lib");
+			_res->addToCache("finale1.vdx", "epilogue.lib");
+			_res->addToCache("finale2.vda", "epilogue.lib");
+			_res->addToCache("finale2.vdx", "epilogue.lib");
+			_res->addToCache("finale3.vda", "epilogue.lib");
+			_res->addToCache("finale3.vdx", "epilogue.lib");
+			_res->addToCache("finale4.vda", "EPILOG2.lib");
+			_res->addToCache("finale4.vdx", "EPILOG2.lib");
+
+			_animation->play("finalr1", false, 1, 3, true, 4);
+			_animation->play("finalr2", false, 1, 0, false, 4);
+
+			if (!_res->isInCache("finale2.vda")) {
+				// Finale file isn't cached
+				_res->addToCache("finale2.vda", "epilogue.lib");
+				_res->addToCache("finale2.vdx", "epilogue.lib");
+				_res->addToCache("finale3.vda", "epilogue.lib");
+				_res->addToCache("finale3.vdx", "epilogue.lib");
+				_res->addToCache("finale4.vda", "EPILOG2.lib");
+				_res->addToCache("finale4.vdx", "EPILOG2.lib");
+			}
+
+			_animation->play("finale1", false, 1, 0, false, 4);
+			_animation->play("finale2", false, 1, 0, false, 4);
+			_animation->play("finale3", false, 1, 0, false, 4);
+
+			_useEpilogue2 = true;
+			_animation->play("finale4", false, 1, 0, false, 4);
+			_useEpilogue2 = false;
+			break;
+
+		case MOOREHEAD_DEATH:
+			// Moorehead's death / subway train
+			_res->addToCache("SUBWAY2.vda", "epilogue.lib");
+			_res->addToCache("SUBWAY2.vdx", "epilogue.lib");
+			_res->addToCache("SUBWAY3.vda", "epilogue.lib");
+			_res->addToCache("SUBWAY3.vdx", "epilogue.lib");
+
+			_animation->play("SUBWAY1", false, 1, 3, true, 4);
+			_animation->play("SUBWAY2", false, 1, 0, false, 4);
+			_animation->play("SUBWAY3", false, 1, 0, false, 4);
+
+			// Set fading to direct fade temporary so the transition goes quickly.
+			_scene->_tempFadeStyle = _screen->_fadeStyle ? 257 : 256;
+			_screen->_fadeStyle = false;
+			break;
+
+		case BRUMWELL_SUICIDE:
+			// Brumwell suicide
+			_animation->play("suicid", false, 1, 3, true, 4);
+			break;
+		default:
+			break;
+		}
+
+		// Except for the Moorehead Murder scene, fade to black first
+		if (_scene->_goToScene != MOOREHEAD_DEATH) {
+			_events->wait(40);
+			_screen->fadeToBlack(3);
+		}
+
+		switch (_scene->_goToScene) {
+		case 52:
+			_scene->_goToScene = LAWYER_OFFICE;		// Go to the Lawyer's Office
+			_map->_bigPos = Common::Point(0, 0);	// Overland scroll position
+			_map->_overPos = Common::Point(22900 - 600, 9400 + 900);	// Overland position
+			_map->_oldCharPoint = LAWYER_OFFICE;
+			break;
+
+		case 53:
+			_scene->_goToScene = STATION;			// Go to St. Pancras Station
+			_map->_bigPos = Common::Point(0, 0);	// Overland scroll position
+			_map->_overPos = Common::Point(32500 - 600, 3000 + 900);	// Overland position
+			_map->_oldCharPoint = STATION;
+			break;
+
+		default:
+			_scene->_goToScene = BAKER_STREET;		// Back to Baker st.
+			_map->_bigPos = Common::Point(0, 0);	// Overland scroll position
+			_map->_overPos = Common::Point(14500 - 600, 8400 + 900);	// Overland position
+			_map->_oldCharPoint = BAKER_STREET;
+			break;
+		}
+
+		// Free any song from the previous scene
+		_music->freeSong();
+		break;
+
+	case EXIT_GAME:
+		// Exit game
+		_screen->fadeToBlack(3);
+		quitGame();
+		return;
+
+	default:
+		break;
+	}
+
+	_events->setCursor(ARROW);
+
+	if (_scene->_goToScene == 99) {
+		// Darts Board minigame
+		_darts->playDarts();
+		_mapResult = _scene->_goToScene = PUB_INTERIOR;
+	}
+
+	_mapResult = _scene->_goToScene;
+}
+
+void ScalpelEngine::eraseBrumwellMirror() {
+	Common::Point pt((*_people)[HOLMES]._position.x / FIXED_INT_MULTIPLIER, (*_people)[HOLMES]._position.y / FIXED_INT_MULTIPLIER);
+
+	// If player is in range of the mirror, then restore background from the secondary back buffer
+	if (Common::Rect(70, 100, 200, 200).contains(pt)) {
+		_screen->_backBuffer1.blitFrom(_screen->_backBuffer2, Common::Point(137, 18),
+			Common::Rect(137, 18, 184, 74));
+	}
+}
+
+void ScalpelEngine::doBrumwellMirror() {
+	People &people = *_people;
+	Person &player = people[HOLMES];
+
+	Common::Point pt((*_people)[HOLMES]._position.x / FIXED_INT_MULTIPLIER, (*_people)[HOLMES]._position.y / FIXED_INT_MULTIPLIER);
+	int frameNum = player._walkSequences[player._sequenceNumber][player._frameNumber] +
+		player._walkSequences[player._sequenceNumber][0] - 2;
+
+	switch ((*_people)[HOLMES]._sequenceNumber) {
+	case WALK_DOWN:
+		frameNum -= 7;
+		break;
+	case WALK_UP:
+		frameNum += 7;
+		break;
+	case WALK_DOWNRIGHT:
+		frameNum += 7;
+		break;
+	case WALK_UPRIGHT:
+		frameNum -= 7;
+		break;
+	case WALK_DOWNLEFT:
+		frameNum += 7;
+		break;
+	case WALK_UPLEFT:
+		frameNum -= 7;
+		break;
+	case STOP_DOWN:
+		frameNum -= 10;
+		break;
+	case STOP_UP:
+		frameNum += 11;
+		break;
+	case STOP_DOWNRIGHT:
+		frameNum -= 15;
+		break;
+	case STOP_DOWNLEFT:
+		frameNum -= 15;
+		break;
+	case STOP_UPRIGHT:
+	case STOP_UPLEFT:
+		frameNum += 15;
+		if (frameNum == 55)
+			frameNum = 54;
+		break;
+	default:
+		break;
+	}
+
+	if (Common::Rect(80, 100, 145, 138).contains(pt)) {
+		// Get the frame of Sherlock to draw
+		ImageFrame &imageFrame = (*people[HOLMES]._images)[frameNum];
+
+		// Draw the mirror image of Holmes
+		bool flipped = people[HOLMES]._sequenceNumber == WALK_LEFT || people[HOLMES]._sequenceNumber == STOP_LEFT
+			|| people[HOLMES]._sequenceNumber == WALK_UPRIGHT || people[HOLMES]._sequenceNumber == STOP_UPRIGHT
+			|| people[HOLMES]._sequenceNumber == WALK_DOWNLEFT || people[HOLMES]._sequenceNumber == STOP_DOWNLEFT;
+		_screen->_backBuffer1.transBlitFrom(imageFrame, pt + Common::Point(38, -imageFrame._frame.h - 25), flipped);
+
+		// Redraw the mirror borders to prevent the drawn image of Holmes from appearing outside of the mirror
+		_screen->_backBuffer1.blitFrom(_screen->_backBuffer2, Common::Point(114, 18),
+			Common::Rect(114, 18, 137, 114));
+		_screen->_backBuffer1.blitFrom(_screen->_backBuffer2, Common::Point(137, 70),
+			Common::Rect(137, 70, 142, 114));
+		_screen->_backBuffer1.blitFrom(_screen->_backBuffer2, Common::Point(142, 71),
+			Common::Rect(142, 71, 159, 114));
+		_screen->_backBuffer1.blitFrom(_screen->_backBuffer2, Common::Point(159, 72),
+			Common::Rect(159, 72, 170, 116));
+		_screen->_backBuffer1.blitFrom(_screen->_backBuffer2, Common::Point(170, 73),
+			Common::Rect(170, 73, 184, 114));
+		_screen->_backBuffer1.blitFrom(_screen->_backBuffer2, Common::Point(184, 18),
+			Common::Rect(184, 18, 212, 114));
+	}
+}
+
+void ScalpelEngine::flushBrumwellMirror() {
+	Common::Point pt((*_people)[HOLMES]._position.x / FIXED_INT_MULTIPLIER, (*_people)[HOLMES]._position.y / FIXED_INT_MULTIPLIER);
+
+	// If player is in range of the mirror, then draw the entire mirror area to the screen
+	if (Common::Rect(70, 100, 200, 200).contains(pt))
+		_screen->slamArea(137, 18, 47, 56);
+}
+
+
+void ScalpelEngine::showScummVMSaveDialog() {
+	GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Save game:"), _("Save"), true);
+
+	int slot = dialog->runModalWithCurrentTarget();
+	if (slot >= 0) {
+		Common::String desc = dialog->getResultString();
+
+		saveGameState(slot, desc);
+	}
+
+	delete dialog;
+}
+
+void ScalpelEngine::showScummVMRestoreDialog() {
+	GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Restore game:"), _("Restore"), false);
+
+	int slot = dialog->runModalWithCurrentTarget();
+	if (slot >= 0) {
+		loadGameState(slot);
+	}
+
+	delete dialog;
+}
+
+bool ScalpelEngine::play3doMovie(const Common::String &filename, const Common::Point &pos, bool isPortrait) {
+	Scalpel3DOScreen &screen = *(Scalpel3DOScreen *)_screen;
+	Scalpel3DOMovieDecoder *videoDecoder = new Scalpel3DOMovieDecoder();
+	Graphics::Surface tempSurface;
+
+	Common::Point framePos(pos.x, pos.y);
+	ImageFile3DO *frameImageFile = nullptr;
+	ImageFrame *frameImage = nullptr;
+	bool frameShown = false;
+
+	if (!videoDecoder->loadFile(filename)) {
+		warning("Scalpel3DOMoviePlay: could not open '%s'", filename.c_str());
+		return false;
+	}
+
+	bool halfSize = isPortrait && !_isScreenDoubled;
+	if (isPortrait) {
+		// only for portrait videos, not for EA intro logo and such
+		if ((framePos.x >= 8) && (framePos.y >= 8)) { // safety check
+			framePos.x -= 8;
+			framePos.y -= 8; // frame is 8 pixels on left + top, and 7 pixels on right + bottom
+		}
+
+		frameImageFile = new ImageFile3DO("vidframe.cel", kImageFile3DOType_Cel);
+		frameImage = &(*frameImageFile)[0];
+	}
+
+	bool skipVideo = false;
+	//byte bytesPerPixel = videoDecoder->getPixelFormat().bytesPerPixel;
+	uint16 width = videoDecoder->getWidth();
+	uint16 height = videoDecoder->getHeight();
+	//uint16 pitch = videoDecoder->getWidth() * bytesPerPixel;
+
+	_events->clearEvents();
+	videoDecoder->start();
+
+	// If we're to show the movie at half-size, we'll need a temporary intermediate surface
+	if (halfSize)
+		tempSurface.create(width / 2, height / 2, _screen->getPixelFormat());
+
+	while (!shouldQuit() && !videoDecoder->endOfVideo() && !skipVideo) {
+		if (videoDecoder->needsUpdate()) {
+			const Graphics::Surface *frame = videoDecoder->decodeNextFrame();
+
+			if (frame) {
+				if (halfSize) {
+					// movies are 152 x 200
+
+					// Downscale, but calculate average color out of 4 pixels and put that average into the target pixel
+					// TODO: 3DO actually did pixel weighting, exact details about this are unknown
+					// It's also unknown what 3DO exactly did for interpolation
+					// and it's also unknown atm if the CinePak videos contained pixel weighting information
+
+					if ((height & 1) || (width & 1)) {
+						error("Scalpel3DOMoviePlay: critical error, half-size requested on video with uneven height/width");
+					}
+
+					for (int downscaleY = 0; downscaleY < height / 2; downscaleY++) {
+						const uint16 *downscaleSource1Ptr = (const uint16 *)frame->getBasePtr(0, downscaleY * 2);
+						const uint16 *downscaleSource2Ptr = (const uint16 *)frame->getBasePtr(0, (downscaleY * 2) + 1);
+						uint16 *downscaleTargetPtr = (uint16 *)tempSurface.getBasePtr(0, downscaleY);
+
+						for (int downscaleX = 0; downscaleX < width / 2; downscaleX++) {
+							// get 4 pixel colors
+							uint16 downscaleColor = *downscaleSource1Ptr;
+							uint32 downscaleRed = downscaleColor >> 11; // 5 bits
+							uint32 downscaleGreen = (downscaleColor >> 5) & 0x3f; // 6 bits
+							uint32 downscaleBlue = downscaleColor & 0x1f;
+
+							downscaleSource1Ptr++;
+							downscaleColor = *downscaleSource1Ptr;
+							downscaleRed += downscaleColor >> 11;
+							downscaleGreen += (downscaleColor >> 5) & 0x3f;
+							downscaleBlue += downscaleColor & 0x1f;
+
+							downscaleColor = *downscaleSource2Ptr;
+							downscaleRed += downscaleColor >> 11;
+							downscaleGreen += (downscaleColor >> 5) & 0x3f;
+							downscaleBlue += downscaleColor & 0x1f;
+
+							downscaleSource2Ptr++;
+							downscaleColor = *downscaleSource2Ptr;
+							downscaleRed += downscaleColor >> 11;
+							downscaleGreen += (downscaleColor >> 5) & 0x3f;
+							downscaleBlue += downscaleColor & 0x1f;
+
+							// Divide colors by 4, so that we get the average
+							downscaleRed = downscaleRed >> 2;
+							downscaleGreen = downscaleGreen >> 2;
+							downscaleBlue = downscaleBlue >> 2;
+
+							// write new color to target pixel
+							downscaleColor = (downscaleRed << 11) | (downscaleGreen << 5) | downscaleBlue;
+							*downscaleTargetPtr = downscaleColor;
+
+							downscaleSource1Ptr++;
+							downscaleSource2Ptr++;
+							downscaleTargetPtr++;
+						}
+					}
+
+					// Point the drawing frame to the temporary surface
+					frame = &tempSurface;
+				}
+
+				if (isPortrait && !frameShown) {
+					// Draw the frame (not the frame of the video, but a frame around the video) itself
+					_screen->transBlitFrom(frameImage->_frame, framePos);
+					frameShown = true;
+				}
+
+				if (isPortrait && !halfSize) {
+					screen.rawBlitFrom(*frame, Common::Point(pos.x * 2, pos.y * 2));
+				} else {
+					_screen->blitFrom(*frame, pos);
+				}
+
+				_screen->update();
+			}
+		}
+
+		_events->pollEventsAndWait();
+		_events->setButtonState();
+
+		if (_events->kbHit()) {
+			Common::KeyState keyState = _events->getKey();
+			if (keyState.keycode == Common::KEYCODE_ESCAPE)
+				skipVideo = true;
+		} else if (_events->_pressed) {
+			skipVideo = true;
+		}
+	}
+
+	if (halfSize)
+		tempSurface.free();
+
+	videoDecoder->close();
+	delete videoDecoder;
+
+	if (isPortrait) {
+		delete frameImageFile;
+	}
+
+	// Restore scene
+	screen._backBuffer1.blitFrom(screen._backBuffer2);
+	_scene->updateBackground();
+	screen.slamArea(0, 0, screen.w(), CONTROLS_Y);
+
+	return !skipVideo;
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel.h b/engines/sherlock/scalpel/scalpel.h
new file mode 100644
index 0000000000..af4d72a7d7
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel.h
@@ -0,0 +1,160 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_SCALPEL_H
+#define SHERLOCK_SCALPEL_H
+
+#include "sherlock/sherlock.h"
+#include "sherlock/scalpel/scalpel_darts.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+extern uint BUTTON_TOP;
+extern uint BUTTON_MIDDLE;
+extern uint BUTTON_BOTTOM;
+extern uint COMMAND_FOREGROUND;
+extern uint COMMAND_HIGHLIGHTED;
+extern uint COMMAND_NULL;
+extern uint INFO_FOREGROUND;
+extern uint INFO_BACKGROUND;
+extern uint INV_FOREGROUND;
+extern uint INV_BACKGROUND;
+extern uint PEN_COLOR;
+extern uint INFO_BLACK;
+extern uint BORDER_COLOR;
+extern uint COMMAND_BACKGROUND;
+extern uint BUTTON_BACKGROUND;
+extern uint TALK_FOREGROUND;
+extern uint TALK_NULL;
+
+class ScalpelEngine : public SherlockEngine {
+private:
+	Darts *_darts;
+	int _mapResult;
+
+	/**
+	 * Initialize graphics mode
+	 */
+	void setupGraphics();
+
+	/**
+	 * Show the 3DO splash screen
+	 */
+	bool show3DOSplash();
+
+	/**
+	 * Show the starting city cutscene which shows the game title
+	 */
+	bool showCityCutscene();
+	bool showCityCutscene3DO();
+
+	/**
+	 * Show the back alley where the initial murder takes place
+	 */
+	bool showAlleyCutscene();
+	bool showAlleyCutscene3DO();
+
+	/**
+	 * Show the Baker Street outside cutscene
+	 */
+	bool showStreetCutscene();
+	bool showStreetCutscene3DO();
+
+	/**
+	 * Show Holmes and Watson at the breakfast table, lestrade's note, and then the scrolling credits
+	 */
+	bool showOfficeCutscene();
+	bool showOfficeCutscene3DO();
+
+	/**
+	 * Show the game credits
+	 */
+	bool scrollCredits();
+
+	/**
+	 * Load the default inventory for the game, which includes both the initial active inventory,
+	 * as well as special pending inventory items which can appear automatically in the player's
+	 * inventory once given required flags are set
+	 */
+	void loadInventory();
+
+	/**
+	 * Transition to show an image
+	 */
+	void showLBV(const Common::String &filename);
+protected:
+	/**
+	 * Game initialization
+	 */
+	virtual void initialize();
+
+	/**
+	 * Show the opening sequence
+	 */
+	virtual void showOpening();
+
+	/**
+	 * Starting a scene within the game
+	 */
+	virtual void startScene();
+public:
+	ScalpelEngine(OSystem *syst, const SherlockGameDescription *gameDesc);
+	virtual ~ScalpelEngine();
+
+	/**
+	 * Takes care of clearing the mirror in scene 12 (mansion drawing room), in case anything drew over it
+	 */
+	void eraseBrumwellMirror();
+
+	/**
+	 * Takes care of drawing Holme's reflection onto the mirror in scene 12 (mansion drawing room)
+	 */
+	void doBrumwellMirror();
+
+	/**
+	 * This clears the mirror in scene 12 (mansion drawing room) in case anything messed draw over it
+	 */
+	void flushBrumwellMirror();
+
+	/**
+	 * Show the ScummVM restore savegame dialog
+	 */
+	void showScummVMSaveDialog();
+
+	/**
+	 * Show the ScummVM restore savegame dialog
+	 */
+	void showScummVMRestoreDialog();
+
+	/**
+	 * Play back a 3do movie
+	 */
+	bool play3doMovie(const Common::String &filename, const Common::Point &pos, bool isPortrait = false);
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_darts.cpp b/engines/sherlock/scalpel/scalpel_darts.cpp
new file mode 100644
index 0000000000..87f4566837
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_darts.cpp
@@ -0,0 +1,546 @@
+/* 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 "sherlock/scalpel/scalpel_darts.h"
+#include "sherlock/scalpel/scalpel.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+enum {
+	STATUS_INFO_X = 218,
+	STATUS_INFO_Y = 53,
+	DART_INFO_X = 218,
+	DART_INFO_Y = 103,
+	DARTBARHX = 35,
+	DARTHORIZY = 190,
+	DARTBARVX = 1,
+	DARTHEIGHTY = 25,
+	DARTBARSIZE = 150,
+	DART_BAR_FORE = 8
+};
+
+enum {
+	DART_COL_FORE = 5,
+	PLAYER_COLOR = 11
+};
+#define OPPONENTS_COUNT 4
+
+const char *const OPPONENT_NAMES[OPPONENTS_COUNT] = {
+	"Skipper", "Willy", "Micky", "Tom"
+};
+
+/*----------------------------------------------------------------*/
+
+Darts::Darts(ScalpelEngine *vm) : _vm(vm) {
+	_dartImages = nullptr;
+	_level = 0;
+	_computerPlayer = 1;
+	_playerDartMode = false;
+	_dartScore1 = _dartScore2 = 0;
+	_roundNumber = 0;
+	_playerDartMode = false;
+	_roundScore = 0;
+	_oldDartButtons = false;
+}
+
+void Darts::playDarts() {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	int playerNumber = 0;
+	int lastDart;
+
+	// Change the font
+	int oldFont = screen.fontNumber();
+	screen.setFont(2);
+
+	loadDarts();
+	initDarts();
+
+	bool done = false;
+	do {
+		int score, roundStartScore;
+		roundStartScore = score = playerNumber == 0 ? _dartScore1 : _dartScore2;
+
+		// Show player details
+		showNames(playerNumber);
+		showStatus(playerNumber);
+		_roundScore = 0;
+
+		if (_vm->shouldQuit())
+			return;
+
+		for (int idx = 0; idx < 3; ++idx) {
+			// Throw a single dart
+			if (_computerPlayer == 1)
+				lastDart = throwDart(idx + 1, playerNumber * 2);
+			else if (_computerPlayer == 2)
+				lastDart = throwDart(idx + 1, playerNumber + 1);
+			else
+				lastDart = throwDart(idx + 1, 0);
+
+			score -= lastDart;
+			_roundScore += lastDart;
+
+			screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(DART_INFO_X, DART_INFO_Y - 1),
+				Common::Rect(DART_INFO_X, DART_INFO_Y - 1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+			screen.print(Common::Point(DART_INFO_X, DART_INFO_Y), DART_COL_FORE, "Dart # %d", idx + 1);
+			screen.print(Common::Point(DART_INFO_X, DART_INFO_Y + 10), DART_COL_FORE, "Scored %d points", lastDart);
+
+			if (score != 0 && playerNumber == 0)
+				screen.print(Common::Point(DART_INFO_X, DART_INFO_Y + 30), DART_COL_FORE, "Press a key");
+
+			if (score == 0) {
+				// Some-one has won
+				screen.print(Common::Point(DART_INFO_X, DART_INFO_Y + 20), PLAYER_COLOR, "GAME OVER!");
+
+				if (playerNumber == 0) {
+					screen.print(Common::Point(DART_INFO_X, DART_INFO_Y + 30), PLAYER_COLOR, "Holmes Wins!");
+					if (_level < OPPONENTS_COUNT)
+						_vm->setFlagsDirect(318 + _level);
+				} else {
+					screen.print(Common::Point(DART_INFO_X, DART_INFO_Y + 30), PLAYER_COLOR, "%s Wins!", _opponent.c_str());
+				}
+
+				screen.print(Common::Point(DART_INFO_X, DART_INFO_Y + 4), DART_COL_FORE, "Press a key");
+
+				idx = 10;
+				done = true;
+			} else if (score < 0) {
+				screen.print(Common::Point(DART_INFO_X, DART_INFO_Y + 20), PLAYER_COLOR, "BUSTED!");
+
+				idx = 10;
+				score = roundStartScore;
+			}
+
+			if (playerNumber == 0)
+				_dartScore1 = score;
+			else
+				_dartScore2 = score;
+
+			showStatus(playerNumber);
+			events.clearKeyboard();
+
+			if ((playerNumber == 0 && _computerPlayer == 1) || _computerPlayer == 0 || done) {
+				int dartKey;
+				while (!(dartKey = dartHit()) && !_vm->shouldQuit())
+					events.delay(10);
+
+				if (dartKey == Common::KEYCODE_ESCAPE) {
+					idx = 10;
+					done = true;
+				}
+			} else {
+				events.wait(20);
+			}
+
+			screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(DART_INFO_X, DART_INFO_Y - 1),
+				Common::Rect(DART_INFO_X, DART_INFO_Y - 1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+			screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+		}
+
+		playerNumber ^= 1;
+		if (!playerNumber)
+			++_roundNumber;
+
+		done |= _vm->shouldQuit();
+
+		if (!done) {
+			screen._backBuffer2.blitFrom((*_dartImages)[0], Common::Point(0, 0));
+			screen._backBuffer1.blitFrom(screen._backBuffer2);
+			screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+		}
+	} while (!done);
+
+	closeDarts();
+	screen.fadeToBlack();
+
+	// Restore font
+	screen.setFont(oldFont);
+}
+
+void Darts::loadDarts() {
+	Screen &screen = *_vm->_screen;
+
+	_dartImages = new ImageFile("darts.vgs");
+	screen.setPalette(_dartImages->_palette);
+
+	screen._backBuffer1.blitFrom((*_dartImages)[0], Common::Point(0, 0));
+	screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+}
+
+void Darts::initDarts() {
+	_dartScore1 = _dartScore2 = 301;
+	_roundNumber = 1;
+
+	if (_level == 9) {
+		// No computer players
+		_computerPlayer = 0;
+		_level = 0;
+	} else if (_level == 8) {
+		_level = _vm->getRandomNumber(3);
+		_computerPlayer = 2;
+	} else {
+		// Check flags for opponents
+		for (int idx = 0; idx < OPPONENTS_COUNT; ++idx) {
+			if (_vm->readFlags(314 + idx))
+				_level = idx;
+		}
+	}
+
+	_opponent = OPPONENT_NAMES[_level];
+}
+
+void Darts::closeDarts() {
+	delete _dartImages;
+	_dartImages = nullptr;
+}
+
+void Darts::showNames(int playerNum) {
+	Screen &screen = *_vm->_screen;
+	byte color = playerNum == 0 ? PLAYER_COLOR : DART_COL_FORE;
+
+	// Print Holmes first
+	if (playerNum == 0)
+		screen.print(Common::Point(STATUS_INFO_X, STATUS_INFO_Y), PLAYER_COLOR + 3, "Holmes");
+	else
+		screen.print(Common::Point(STATUS_INFO_X, STATUS_INFO_Y), color, "Holmes");
+
+	screen._backBuffer1.fillRect(Common::Rect(STATUS_INFO_X, STATUS_INFO_Y + 10,
+		STATUS_INFO_X + 31, STATUS_INFO_Y + 12), color);
+	screen.slamArea(STATUS_INFO_X, STATUS_INFO_Y + 10, 31, 12);
+
+	// Second player
+	color = playerNum == 1 ? PLAYER_COLOR : DART_COL_FORE;
+
+	if (playerNum != 0)
+		screen.print(Common::Point(STATUS_INFO_X + 50, STATUS_INFO_Y), PLAYER_COLOR + 3,
+			"%s", _opponent.c_str());
+	else
+		screen.print(Common::Point(STATUS_INFO_X + 50, STATUS_INFO_Y), color,
+			"%s", _opponent.c_str());
+
+	screen._backBuffer1.fillRect(Common::Rect(STATUS_INFO_X + 50, STATUS_INFO_Y + 10,
+		STATUS_INFO_X + 81, STATUS_INFO_Y + 12), color);
+	screen.slamArea(STATUS_INFO_X + 50, STATUS_INFO_Y + 10, 81, 12);
+
+	// Make a copy of the back buffer to the secondary one
+	screen._backBuffer2.blitFrom(screen._backBuffer1);
+}
+
+void Darts::showStatus(int playerNum) {
+	Screen &screen = *_vm->_screen;
+	byte color;
+
+	// Copy scoring screen from secondary back buffer. This will erase any previously displayed status/score info
+	screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(STATUS_INFO_X, STATUS_INFO_Y + 10),
+		Common::Rect(STATUS_INFO_X, STATUS_INFO_Y + 10, SHERLOCK_SCREEN_WIDTH, STATUS_INFO_Y + 48));
+
+	color = (playerNum == 0) ? PLAYER_COLOR : DART_COL_FORE;
+	screen.print(Common::Point(STATUS_INFO_X + 6, STATUS_INFO_Y + 13), color, "%d", _dartScore1);
+
+	color = (playerNum == 1) ? PLAYER_COLOR : DART_COL_FORE;
+	screen.print(Common::Point(STATUS_INFO_X + 56, STATUS_INFO_Y + 13), color, "%d", _dartScore2);
+	screen.print(Common::Point(STATUS_INFO_X, STATUS_INFO_Y + 25), PLAYER_COLOR, "Round: %d", _roundNumber);
+	screen.print(Common::Point(STATUS_INFO_X, STATUS_INFO_Y + 35), PLAYER_COLOR, "Turn Total: %d", _roundScore);
+	screen.slamRect(Common::Rect(STATUS_INFO_X, STATUS_INFO_Y + 10, SHERLOCK_SCREEN_WIDTH, STATUS_INFO_Y + 48));
+}
+
+int Darts::throwDart(int dartNum, int computer) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	Common::Point targetNum;
+	int width, height;
+
+	events.clearKeyboard();
+
+	erasePowerBars();
+	screen.print(Common::Point(DART_INFO_X, DART_INFO_Y), DART_COL_FORE, "Dart # %d", dartNum);
+
+	if (!computer) {
+		screen.print(Common::Point(DART_INFO_X, DART_INFO_Y + 10), DART_COL_FORE, "Hit a key");
+		screen.print(Common::Point(DART_INFO_X, DART_INFO_Y + 18), DART_COL_FORE, "to start");
+	}
+
+	if (!computer) {
+		while (!_vm->shouldQuit() && !dartHit())
+			;
+	} else {
+		events.delay(10);
+	}
+
+	if (_vm->shouldQuit())
+		return 0;
+
+	screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(DART_INFO_X, DART_INFO_Y - 1),
+		Common::Rect(DART_INFO_X, DART_INFO_Y - 1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+	screen.slamRect(Common::Rect(DART_INFO_X, DART_INFO_Y - 1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+
+	// If it's a computer player, choose a dart destination
+	if (computer)
+		targetNum = getComputerDartDest(computer - 1);
+
+	width = doPowerBar(Common::Point(DARTBARHX, DARTHORIZY), DART_BAR_FORE, targetNum.x, false);
+	height = 101 - doPowerBar(Common::Point(DARTBARVX, DARTHEIGHTY), DART_BAR_FORE, targetNum.y, true);
+
+	// For human players, slight y adjustment
+	if (computer == 0)
+		height += 2;
+
+	// Copy the bars to the secondary back buffer so that they remain fixed at their selected values
+	// whilst the dart is being animated at being thrown at the board
+	screen._backBuffer2.blitFrom(screen._backBuffer1, Common::Point(DARTBARHX - 1, DARTHORIZY - 1),
+		Common::Rect(DARTBARHX - 1, DARTHORIZY - 1, DARTBARHX + DARTBARSIZE + 3, DARTHORIZY + 10));
+	screen._backBuffer2.blitFrom(screen._backBuffer1, Common::Point(DARTBARVX - 1, DARTHEIGHTY - 1),
+		Common::Rect(DARTBARVX - 1, DARTHEIGHTY - 1, DARTBARVX + 11, DARTHEIGHTY + DARTBARSIZE + 3));
+
+	// Convert height and width to relative range of -50 to 50, where 0,0 is the exact centre of the board
+	height -= 50;
+	width -= 50;
+
+	Common::Point dartPos(111 + width * 2, 99 + height * 2);
+	drawDartThrow(dartPos);
+
+	return dartScore(dartPos);
+}
+
+void Darts::drawDartThrow(const Common::Point &pt) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	Common::Point pos(pt.x, pt.y + 2);
+	Common::Rect oldDrawBounds;
+	int delta = 9;
+
+	for (int idx = 4; idx < 23; ++idx) {
+		ImageFrame &frame = (*_dartImages)[idx];
+
+		// Adjust draw position for animating dart
+		if (idx < 13)
+			pos.y -= delta--;
+		else if (idx == 13)
+			delta = 1;
+		else
+			pos.y += delta++;
+
+		// Draw the dart
+		Common::Point drawPos(pos.x - frame._width / 2, pos.y - frame._height);
+		screen._backBuffer1.transBlitFrom(frame, drawPos);
+		screen.slamArea(drawPos.x, drawPos.y, frame._width, frame._height);
+
+		// Handle erasing old dart frame area
+		if (!oldDrawBounds.isEmpty())
+			screen.slamRect(oldDrawBounds);
+
+		oldDrawBounds = Common::Rect(drawPos.x, drawPos.y, drawPos.x + frame._width, drawPos.y + frame._height);
+		screen._backBuffer1.blitFrom(screen._backBuffer2, drawPos, oldDrawBounds);
+
+		events.wait(2);
+	}
+
+	// Draw dart in final "stuck to board" form
+	screen._backBuffer1.transBlitFrom((*_dartImages)[22], Common::Point(oldDrawBounds.left, oldDrawBounds.top));
+	screen._backBuffer2.transBlitFrom((*_dartImages)[22], Common::Point(oldDrawBounds.left, oldDrawBounds.top));
+	screen.slamRect(oldDrawBounds);
+}
+
+void Darts::erasePowerBars() {
+	Screen &screen = *_vm->_screen;
+
+	screen._backBuffer1.fillRect(Common::Rect(DARTBARHX, DARTHORIZY, DARTBARHX + DARTBARSIZE, DARTHORIZY + 10), BLACK);
+	screen._backBuffer1.fillRect(Common::Rect(DARTBARVX, DARTHEIGHTY, DARTBARVX + 10, DARTHEIGHTY + DARTBARSIZE), BLACK);
+	screen._backBuffer1.transBlitFrom((*_dartImages)[2], Common::Point(DARTBARHX - 1, DARTHORIZY - 1));
+	screen._backBuffer1.transBlitFrom((*_dartImages)[3], Common::Point(DARTBARVX - 1, DARTHEIGHTY - 1));
+	screen.slamArea(DARTBARHX - 1, DARTHORIZY - 1, DARTBARSIZE + 3, 11);
+	screen.slamArea(DARTBARVX - 1, DARTHEIGHTY - 1, 11, DARTBARSIZE + 3);
+}
+
+int Darts::doPowerBar(const Common::Point &pt, byte color, int goToPower, bool isVertical) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	bool done;
+	int idx = 0;
+
+	events.clearEvents();
+	events.delay(100);
+
+	// Display loop
+	do {
+		done = _vm->shouldQuit() || idx >= DARTBARSIZE;
+
+		if (idx == (goToPower - 1))
+			// Reached target power for a computer player
+			done = true;
+		else if (goToPower == 0) {
+			// Check for press
+			if (dartHit())
+				done = true;
+		}
+
+		if (isVertical) {
+			screen._backBuffer1.hLine(pt.x, pt.y + DARTBARSIZE - 1 - idx, pt.x + 8, color);
+			screen._backBuffer1.transBlitFrom((*_dartImages)[3], Common::Point(pt.x - 1, pt.y - 1));
+			screen.slamArea(pt.x, pt.y + DARTBARSIZE - 1 - idx, 8, 2);
+		} else {
+			screen._backBuffer1.vLine(pt.x + idx, pt.y, pt.y + 8, color);
+			screen._backBuffer1.transBlitFrom((*_dartImages)[2], Common::Point(pt.x - 1, pt.y - 1));
+			screen.slamArea(pt.x + idx, pt.y, 1, 8);
+		}
+
+		if (!(idx % 8))
+			events.wait(1);
+	
+		++idx;
+	} while (!done);
+
+	return MIN(idx * 100 / DARTBARSIZE, 100);
+}
+
+int Darts::dartHit() {
+	Events &events = *_vm->_events;
+
+	// Process pending events
+	events.pollEventsAndWait();
+
+	if (events.kbHit()) {
+		// Key was pressed, so return it
+		Common::KeyState keyState = events.getKey();
+		return keyState.keycode;
+	}
+
+	_oldDartButtons = events._pressed;
+	events.setButtonState();
+
+	// Only return true if the mouse button is newly pressed
+	return (events._pressed && !_oldDartButtons) ? 1 : 0;
+}
+
+int Darts::dartScore(const Common::Point &pt) {
+	Common::Point pos(pt.x - 37, pt.y - 33);
+	Graphics::Surface &scoreImg = (*_dartImages)[1]._frame;
+
+	if (pos.x < 0 || pos.y < 0 || pos.x >= scoreImg.w || pos.y >= scoreImg.h)
+		// Not on the board
+		return 0;
+
+	// On board, so get the score from the pixel at that position
+	int score = *(const byte *)scoreImg.getBasePtr(pos.x, pos.y);
+	return score;
+}
+
+Common::Point Darts::getComputerDartDest(int playerNum) {
+	Common::Point target;
+	int score = playerNum == 0 ? _dartScore1 : _dartScore2;
+
+	if (score > 50) {
+		// Aim for the bullseye
+		target.x = target.y = 76;
+
+		if (_level <= 1 &&  _vm->getRandomNumber(1) == 1) {
+			// Introduce margin of error
+			target.x += _vm->getRandomNumber(21) - 10;
+			target.y += _vm->getRandomNumber(21) - 10;
+		}
+	} else {
+		int aim = score;
+
+		bool done;
+		Common::Point pt;
+		do {
+			done = findNumberOnBoard(aim, pt);
+			--aim;
+		} while (!done);
+
+		target.x = 75 + ((target.x - 75) * 20 / 27);
+		target.y = 75 + ((target.y - 75) * 2 / 3);
+	}
+
+	// Pick a level of accuracy. The higher the level, the more accurate their throw will be
+	int accuracy = _vm->getRandomNumber(10) + _level * 2;
+
+	if (accuracy <= 2) {
+		target.x += _vm->getRandomNumber(71) - 35;
+		target.y += _vm->getRandomNumber(71) - 35;
+	} else if (accuracy <= 4) {
+		target.x += _vm->getRandomNumber(51) - 25;
+		target.y += _vm->getRandomNumber(51) - 25;
+	} else if (accuracy <= 6) {
+		target.x += _vm->getRandomNumber(31) - 15;
+		target.y += _vm->getRandomNumber(31) - 15;
+	} else if (accuracy <= 8) {
+		target.x += _vm->getRandomNumber(21) - 10;
+		target.y += _vm->getRandomNumber(21) - 10;
+	} else if (accuracy <= 10) {
+		target.x += _vm->getRandomNumber(11) - 5;
+		target.y += _vm->getRandomNumber(11) - 5;
+	}
+
+	if (target.x < 1)
+		target.x = 1;
+	if (target.y < 1)
+		target.y = 1;
+
+	return target;
+}
+
+bool Darts::findNumberOnBoard(int aim, Common::Point &pt) {
+	ImageFrame &board = (*_dartImages)[1];
+
+	// Scan board image for the special "center" pixels
+	bool done = false;
+	for (int yp = 0; yp < 132 && !done; ++yp) {
+		const byte *srcP = (const byte *)board._frame.getBasePtr(0, yp);
+		for (int xp = 0; xp < 147 && !done; ++xp, ++srcP) {
+			int score = *srcP;
+
+			// Check for match
+			if (score == aim) {
+				done = true;
+
+				// Aim at non-double/triple numbers where possible
+				if (aim < 21) {
+					pt.x = xp + 5;
+					pt.y = yp + 5;
+
+					score = *(const byte *)board._frame.getBasePtr(xp + 10, yp + 10);
+					if (score != aim)
+						// Not aiming at non-double/triple number yet
+						done = false;
+				} else {
+					// Aiming at a double or triple
+					pt.x = xp + 3;
+					pt.y = yp + 3;
+				}
+			}
+		}
+	}
+
+	if (aim == 3)
+		pt.x += 15;
+	pt.y = 132 - pt.y;
+
+	return done;
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_darts.h b/engines/sherlock/scalpel/scalpel_darts.h
new file mode 100644
index 0000000000..483a163510
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_darts.h
@@ -0,0 +1,130 @@
+/* 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 SHERLOCK_SCALPEL_DARTS_H
+#define SHERLOCK_SCALPEL_DARTS_H
+
+#include "sherlock/image_file.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+class ScalpelEngine;
+
+class Darts {
+private:
+	ScalpelEngine *_vm;
+	ImageFile *_dartImages;
+	int _dartScore1, _dartScore2;
+	int _roundNumber;
+	int _level;
+	int _computerPlayer;
+	Common::String _opponent;
+	bool _playerDartMode;
+	int _roundScore;
+	bool _oldDartButtons;
+
+	/**
+	 * Load the graphics needed for the dart game
+	 */
+	void loadDarts();
+
+	/**
+	 * Initializes the variables needed for the dart game
+	 */
+	void initDarts();
+	
+	/**
+	 * Frees the images used by the dart game
+	 */
+	void closeDarts();
+
+	/**
+	 * Show the names of the people playing, Holmes and his opponent
+	 */
+	void showNames(int playerNum);
+
+	/**
+	 * Show the player score and game status
+	 */
+	void showStatus(int playerNum);
+
+	/**
+	 * Throws a single dart.
+	 * @param dartNum	Dart number
+	 * @param computer	0 = Player, 1 = 1st player computer, 2 = 2nd player computer
+	 * @returns			Score for what dart hit
+	 */
+	int throwDart(int dartNum, int computer);
+
+	/**
+	 * Draw a dart moving towards the board
+	 */
+	void drawDartThrow(const Common::Point &pt);
+
+	/**
+	 * Erases the power bars
+	 */
+	void erasePowerBars();
+
+	/**
+	 * Show a gradually incrementing incrementing power that bar. If goToPower is provided, it will
+	 * increment to that power level ignoring all keyboard input (ie. for computer throws).
+	 * Otherwise, it will increment until either a key/mouse button is pressed, or it reaches the end
+	 */
+	int doPowerBar(const Common::Point &pt, byte color, int goToPower, bool isVertical);
+
+	/**
+	 * Returns true if a mouse button or key is pressed.
+	 */
+	int dartHit();
+	
+	/**
+	 * Return the score of the given location on the dart-board
+	 */
+	int dartScore(const Common::Point &pt);
+
+	/**
+	 * Calculates where a computer player is trying to throw their dart, and choose the actual
+	 * point that was hit with some margin of error
+	 */
+	Common::Point getComputerDartDest(int playerNum);
+
+	/**
+	 * Returns the center position for the area of the dartboard with a given number
+	 */
+	bool findNumberOnBoard(int aim, Common::Point &pt);
+public:
+	Darts(ScalpelEngine *vm);
+
+	/**
+	 * Main method for playing darts game
+	 */
+	void playDarts();
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_debugger.cpp b/engines/sherlock/scalpel/scalpel_debugger.cpp
new file mode 100644
index 0000000000..7f5e1efa69
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_debugger.cpp
@@ -0,0 +1,91 @@
+/* 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 "sherlock/scalpel/scalpel_debugger.h"
+#include "sherlock/sherlock.h"
+#include "audio/mixer.h"
+#include "audio/decoders/3do.h"
+#include "audio/decoders/aiff.h"
+#include "audio/decoders/wave.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+ScalpelDebugger::ScalpelDebugger(SherlockEngine *vm) : Debugger(vm) {
+	registerCmd("3do_playmovie", WRAP_METHOD(ScalpelDebugger, cmd3DO_PlayMovie));
+	registerCmd("3do_playaudio", WRAP_METHOD(ScalpelDebugger, cmd3DO_PlayAudio));
+}
+
+bool ScalpelDebugger::cmd3DO_PlayMovie(int argc, const char **argv) {
+	if (argc != 2) {
+		debugPrintf("Format: 3do_playmovie <3do-movie-file>\n");
+		return true;
+	}
+
+	// play gets postboned until debugger is closed
+	Common::String filename = argv[1];
+	_3doPlayMovieFile = filename;
+
+	return cmdExit(0, 0);
+}
+
+bool ScalpelDebugger::cmd3DO_PlayAudio(int argc, const char **argv) {
+	if (argc != 2) {
+		debugPrintf("Format: 3do_playaudio <3do-audio-file>\n");
+		return true;
+	}
+
+	Common::File *file = new Common::File();
+	if (!file->open(argv[1])) {
+		debugPrintf("can not open specified audio file\n");
+		return true;
+	}
+
+	Audio::AudioStream *testStream;
+	Audio::SoundHandle testHandle;
+
+	// Try to load the given file as AIFF/AIFC
+	testStream = Audio::makeAIFFStream(file, DisposeAfterUse::YES);
+
+	if (testStream) {
+		g_system->getMixer()->playStream(Audio::Mixer::kPlainSoundType, &testHandle, testStream);
+		_vm->_events->clearEvents();
+
+		while ((!_vm->shouldQuit()) && g_system->getMixer()->isSoundHandleActive(testHandle)) {
+			_vm->_events->pollEvents();
+			g_system->delayMillis(10);
+			if (_vm->_events->kbHit()) {
+				break;
+			}
+		}
+
+		debugPrintf("playing completed\n");
+		g_system->getMixer()->stopHandle(testHandle);
+	}
+
+	return true;
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_debugger.h b/engines/sherlock/scalpel/scalpel_debugger.h
new file mode 100644
index 0000000000..17a84779f0
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_debugger.h
@@ -0,0 +1,54 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_SCALPEL_DEBUGGER_H
+#define SHERLOCK_SCALPEL_DEBUGGER_H
+
+#include "sherlock/debugger.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Scalpel {
+
+class ScalpelDebugger : public Debugger {
+private:
+	/**
+	 * Plays a 3DO movie
+	 */
+	bool cmd3DO_PlayMovie(int argc, const char **argv);
+
+	/**
+	 * Plays a 3DO audio
+	 */
+	bool cmd3DO_PlayAudio(int argc, const char **argv);
+public:
+	ScalpelDebugger(SherlockEngine *vm);
+	virtual ~ScalpelDebugger() {}
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif	/* SHERLOCK_DEBUGGER_H */
diff --git a/engines/sherlock/scalpel/scalpel_fixed_text.cpp b/engines/sherlock/scalpel/scalpel_fixed_text.cpp
new file mode 100644
index 0000000000..372fbc3e7e
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_fixed_text.cpp
@@ -0,0 +1,565 @@
+/* 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 "sherlock/scalpel/scalpel_fixed_text.h"
+#include "sherlock/sherlock.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+static const char *const fixedTextEN[] = {
+	// SH1: Window buttons
+	"Exit",
+	"Up",
+	"Down",
+	// SH1: Inventory buttons
+	"Exit",
+	"Look",
+	"Use",
+	"Give",
+	// SH1: Journal text
+	"Watson's Journal",
+	"Page %d",
+	// SH1: Journal buttons
+	"Exit",
+	"Back 10",
+	"Up",
+	"Down",
+	"Ahead 10",
+	"Search",
+	"First Page",
+	"Last Page",
+	"Print Text",
+	// SH1: Journal search
+	"Exit",
+	"Backward",
+	"Forward",
+	"Text Not Found !",
+	// SH1: Press key text
+	"Press any Key for More.",
+	"P",
+	"Press any Key to Continue.",
+	"P",
+	// SH1: Initial Inventory
+	"A message requesting help",
+	"A number of business cards",
+	"Opera Tickets",
+	"Cuff Link",
+	"Wire Hook",
+	"Note",
+	"An open pocket watch",
+	"A piece of paper with numbers on it",
+	"A letter folded many times",
+	"Tarot Cards",
+	"An ornate key",
+	"A pawn ticket",
+	// SH1: People names
+	"Sherlock Holmes",
+	"Dr. Watson",
+	"Inspector Lestrade",
+	"Constable O'Brien",
+	"Constable Lewis",
+	"Sheila Parker",
+	"Henry Carruthers",
+	"Lesley",
+	"An Usher",
+	"Fredrick Epstein",
+	"Mrs. Worthington",
+	"The Coach",
+	"A Player",
+	"Tim",
+	"James Sanders",
+	"Belle",
+	"Cleaning Girl",
+	"Wiggins",
+	"Paul",
+	"The Bartender",
+	"A Dirty Drunk",
+	"A Shouting Drunk",
+	"A Staggering Drunk",
+	"The Bouncer",
+	"The Coroner",
+	"Reginald Snipes",
+	"George Blackwood",
+	"Lars",
+	"The Chemist",
+	"Inspector Gregson",
+	"Jacob Farthington",
+	"Mycroft",
+	"Old Sherman",
+	"Richard",
+	"The Barman",
+	"A Dandy Player",
+	"A Rough-looking Player",
+	"A Spectator",
+	"Robert Hunt",
+	"Violet",
+	"Pettigrew",
+	"Augie",
+	"Anna Carroway",
+	"A Guard",
+	"Antonio Caruso",
+	"Toby the Dog",
+	"Simon Kingsley",
+	"Alfred",
+	"Lady Brumwell",
+	"Madame Rosa",
+	"Joseph Moorehead",
+	"Mrs. Beale",
+	"Felix",
+	"Hollingston",
+	"Constable Callaghan",
+	"Sergeant Duncan",
+	"Lord Brumwell",
+	"Nigel Jaimeson",
+	"Jonas",
+	"Constable Dugan"
+};
+
+// sharp-s       : 0xE1 / octal 341
+// small a-umlaut: 0x84 / octal 204
+// small o-umlaut: 0x94 / octal 224
+// small u-umlaut: 0x81 / octal 201
+static const char *const fixedTextDE[] = {
+	// SH1: Window buttons
+	"Zur\201ck",
+	"Hoch",
+	"Runter",
+	// SH1: Inventory buttons
+	"Zur\201ck",
+	"Schau",
+	"Benutze",
+	"Gib",
+	// SH1: Journal text
+	"Watsons Tagebuch",
+	"Seite %d",
+	// SH1: Journal buttons
+	"Zur\201ck",
+	"10 hoch",
+	"Hoch",
+	"Runter",
+	"10 runter",
+	"Suche",
+	"Erste Seite",
+	"Letzte Seite",
+	"Drucke Text",
+	// SH1: Journal search
+	"Zur\201ck",
+	"R\201ckw\204rts", // original: "Backward"
+	"Vorw\204rts", // original: "Forward"
+	"Text nicht gefunden!",
+	// SH1: Press key text
+	"Mehr auf Tastendruck...",
+	"M",
+	"Beliebige Taste dr\201cken.",
+	"B",
+	// SH1: Initial Inventory
+	"Ein Hilferuf von Lestrade",
+	"Holmes' Visitenkarten",
+	"Karten f\201rs Opernhaus",
+	"Manschettenkn\224pfe",
+	"Zum Haken verbogener Drahtkorb",
+	"Mitteilung am Epstein",
+	"Eine offene Taschenuhr",
+	"Ein Zettel mit Zahlen drauf",
+	"Ein mehrfach gefalteter Briefbogen",
+	"Ein Tarot-Kartenspiel", // original interpreter: "Ein Tarock-Kartenspiel" [sic]
+	"Ein verzierter Schl\201ssel",
+	"Ein Pfandschein",
+	// SH1: People names
+	"Sherlock Holmes",
+	"Dr. Watson",
+	"Inspektor Lestrade",
+	"Konstabler O'Brien",
+	"Konstabler Lewis",
+	"Sheila Parker",
+	"Henry Carruthers",
+	"Lesley",
+	"Platzanweiser",
+	"Fredrick Epstein",
+	"Mrs. Worthington",
+	"Der Trainer",
+	"Ein Spieler",
+	"Tim",
+	"James Sanders",
+	"Belle",
+	"Putzm\204dchen",
+	"Wiggins",
+	"Paul",
+	"Gastwirt",
+	"Schmutziger Betrunkener",
+	"Lallender Betrunkener",
+	"Torkelnder Betrunkener",
+	"The Bouncer",
+	"Der Leichenbeschauer",
+	"Reginald Snipes",
+	"George Blackwood",
+	"Lars",
+	"Apotheker",
+	"Inspektor Gregson",
+	"Jacob Farthington",
+	"Mycroft",
+	"Old Sherman",
+	"Richard",
+	"Barkeeper",
+	"Jock Mahoney",
+	"Nobby Charleton",
+	"Zuschauer",
+	"Robert Hunt",
+	"Violet",
+	"Pettigrew",
+	"Augie",
+	"Anna Carroway",
+	"Wache",
+	"Antonio Caruso",
+	"Toby the Dog",
+	"Simon Kingsley",
+	"Alfred",
+	"Lady Brumwell",
+	"Madame Rosa",
+	"Joseph Moorehead",
+	"Mrs. Beale",
+	"Felix",
+	"Hollingston",
+	"Konstabler Callaghan",
+	"Sergeant Duncan",
+	"Lord Brumwell",
+	"Nigel Jaimeson",
+	"Jonas",
+	"Konstabler Dugan"
+};
+
+// up-side down exclamation mark - 0xAD / octal 255
+// up-side down question mark - 0xA8 / octal 250
+// n with a wave on top - 0xA4 / octal 244
+static const char *const fixedTextES[] = {
+	// SH1: Window buttons
+	"Salir", // original interpreter: "Exit"
+	"Subir",
+	"Bajar",
+	// SH1: Inventory buttons
+	"Salir", // original interpreter: "Exit"
+	"Mirar",
+	"Usar",
+	"Dar",
+	// SH1: Journal text
+	"Diario de Watson",
+	"Pagina %d",
+	// SH1: Journal buttons
+	"Salir", // original interpreter: "Exit"
+	"Retroceder",
+	"Subir",
+	"baJar",
+	"Adelante",
+	"Buscar",
+	"1a pagina",
+	"Ult pagina",
+	"Imprimir",
+	// SH1: Journal search
+	"Salir", // original interpreter: "Exit"
+	"Retroceder",
+	"Avanzar",
+	"Texto no encontrado!",
+	// SH1: Press key text
+	"Tecla para ver mas",
+	"T",
+	"Tecla para continuar",
+	"T",
+	// SH1: Initial Inventory
+	"Un mensaje solicitando ayuda",
+	"Unas cuantas tarjetas de visita",
+	"Entradas para la opera",
+	"Unos gemelos",
+	"Un gancho de alambre",
+	"Una nota",
+	"Un reloj de bolsillo abierto",
+	"Un trozo de papel con unos numeros",
+	"Un carta muy plegada",
+	"Unas cartas de Tarot",
+	"Una llave muy vistosa",
+	"Una papeleta de empe\244o",
+	// SH1: People names
+	"Sherlock Holmes",
+	"Dr. Watson",
+	"El inspector Lestrade",
+	"El agente O'Brien",
+	"El agente Lewis",
+	"Sheila Parker",
+	"Henry Carruthers",
+	"Lesley",
+	"Un ujier",
+	"Fredrick Epstein",
+	"Mrs. Worthington",
+	"El entrenador",
+	"El jugador",
+	"Tim",
+	"James Sanders",
+	"Belle",
+	"La chica de la limpieza",
+	"Wiggins",
+	"Paul",
+	"El barman",
+	"Un sucio borracho",
+	"Un borracho griton",
+	"Un tambaleante borracho",
+	"El gorila",
+	"El forense",
+	"Reginald Snipes",
+	"George Blackwood",
+	"Lars",
+	"El quimico",
+	"El inspector Gregson",
+	"Jacob Farthington",
+	"Mycroft",
+	"Old Sherman",
+	"Richard",
+	"El barman",
+	"Un jugador dandy",
+	"Un duro jugador",
+	"Un espectador",
+	"Robert Hunt",
+	"Violeta",
+	"Pettigrew",
+	"Augie",
+	"Anna Carroway",
+	"Un guarda",
+	"Antonio Caruso",
+	"El perro Toby",
+	"Simon Kingsley",
+	"Alfred",
+	"Lady Brumwell",
+	"Madame Rosa",
+	"Joseph Moorehead",
+	"Mrs. Beale",
+	"Felix",
+	"Hollingston",
+	"El agente Callaghan",
+	"El sargento Duncan",
+	"Lord Brumwell",
+	"Nigel Jaimeson",
+	"Jonas",
+	"El agente Dugan"
+};
+
+// =========================================
+
+// === Sherlock Holmes 1: Serrated Scalpel ===
+static const char *const fixedTextEN_ActionOpen[] = {
+	"This cannot be opened",
+	"It is already open",
+	"It is locked",
+	"Wait for Watson",
+	" ",
+	"."
+};
+
+static const char *const fixedTextDE_ActionOpen[] = {
+	"Das kann man nicht \224ffnen",
+	"Ist doch schon offen!",
+	"Leider verschlossen",
+	"Warte auf Watson",
+	" ",
+	"."
+};
+
+static const char *const fixedTextES_ActionOpen[] = {
+	"No puede ser abierto",
+	"Ya esta abierto",
+	"Esta cerrado",
+	"Espera a Watson",
+	" ",
+	"."
+};
+
+static const char *const fixedTextEN_ActionClose[] = {
+	"This cannot be closed",
+	"It is already closed",
+	"The safe door is in the way"
+};
+
+static const char *const fixedTextDE_ActionClose[] = {
+	"Das kann man nicht schlie\341en",
+	"Ist doch schon zu!",
+	"Die safet\201r ist Weg"
+};
+
+static const char *const fixedTextES_ActionClose[] = {
+	"No puede ser cerrado",
+	"Ya esta cerrado",
+	"La puerta de seguridad esta entre medias"
+};
+
+static const char *const fixedTextEN_ActionMove[] = {
+	"This cannot be moved",
+	"It is bolted to the floor",
+	"It is too heavy",
+	"The other crate is in the way"
+};
+
+
+static const char *const fixedTextDE_ActionMove[] = {
+	"L\204\341t sich nicht bewegen",
+	"Festged\201belt in der Erde...",
+	"Oha, VIEL zu schwer",
+	"Der andere Kiste ist im Weg" // [sic]
+};
+
+static const char *const fixedTextES_ActionMove[] = {
+	"No puede moverse",
+	"Esta sujeto a la pared",
+	"Es demasiado pesado",
+	"El otro cajon esta en mitad"
+};
+
+static const char *const fixedTextEN_ActionPick[] = {
+	"Nothing of interest here",
+	"It is bolted down",
+	"It is too big to carry",
+	"It is too heavy",
+	"I think a girl would be more your type",
+	"Those flowers belong to Penny",
+	"She's far too young for you!",
+	"I think a girl would be more your type!",
+	"Government property for official use only"
+};
+
+static const char *const fixedTextDE_ActionPick[] = {
+	"Nichts Interessantes da",
+	"Zu gut befestigt",
+	"Ist ja wohl ein bi\341chen zu gro\341, oder ?",
+	"Oha, VIEL zu schwer",
+	"Ich denke, Du stehst mehr auf M\204dchen ?",
+	"Diese Blumen geh\224ren Penny",
+	"Sie ist doch viel zu jung f\201r Dich!",
+	"Ich denke, Du stehst mehr auf M\204dchen ?",
+	"Staatseigentum - Nur f\201r den Dienstgebrauch !"
+};
+
+static const char *const fixedTextES_ActionPick[] = {
+	"No hay nada interesante",
+	"Esta anclado al suelo",
+	"Es muy grande para llevarlo",
+	"Pesa demasiado",
+	"Creo que una chica sera mas tu tipo",
+	"Esas flores pertenecen a Penny",
+	"\255Es demasiado joven para ti!",
+	"\255Creo que una chica sera mas tu tipo!",
+	"Propiedad del gobierno para uso oficial"
+};
+
+static const char *const fixedTextEN_ActionUse[] = {
+	"You can't do that",
+	"It had no effect",
+	"You can't reach it",
+	"OK, the door looks bigger! Happy?",
+	"Doors don't smoke"
+};
+
+static const char *const fixedTextDE_ActionUse[] = {
+	"Nein, das geht wirklich nicht",
+	"Tja keinerlei Wirkung",
+	"Da kommst du nicht dran",
+	"Na gut, die T\201r sieht jetzt gr\224\341er aus. Zufrieden?",
+	"T\201ren sind Nichtraucher!"
+};
+
+static const char *const fixedTextES_ActionUse[] = {
+	"No puedes hacerlo",
+	"No tuvo ningun efecto",
+	"No puedes alcanzarlo",
+	"Bien, \255es enorme! \250Feliz?",
+	"Las puertas no fuman"
+};
+
+#define FIXEDTEXT_GETCOUNT(_name_) sizeof(_name_) / sizeof(byte *)
+#define FIXEDTEXT_ENTRY(_name_)    _name_, FIXEDTEXT_GETCOUNT(_name_)
+
+static const FixedTextActionEntry fixedTextEN_Actions[] = {
+	{ FIXEDTEXT_ENTRY(fixedTextEN_ActionOpen) },
+	{ FIXEDTEXT_ENTRY(fixedTextEN_ActionClose) },
+	{ FIXEDTEXT_ENTRY(fixedTextEN_ActionMove) },
+	{ FIXEDTEXT_ENTRY(fixedTextEN_ActionPick) },
+	{ FIXEDTEXT_ENTRY(fixedTextEN_ActionUse) }
+};
+
+static const FixedTextActionEntry fixedTextDE_Actions[] = {
+	{ FIXEDTEXT_ENTRY(fixedTextDE_ActionOpen) },
+	{ FIXEDTEXT_ENTRY(fixedTextDE_ActionClose) },
+	{ FIXEDTEXT_ENTRY(fixedTextDE_ActionMove) },
+	{ FIXEDTEXT_ENTRY(fixedTextDE_ActionPick) },
+	{ FIXEDTEXT_ENTRY(fixedTextDE_ActionUse) }
+};
+
+static const FixedTextActionEntry fixedTextES_Actions[] = {
+	{ FIXEDTEXT_ENTRY(fixedTextES_ActionOpen) },
+	{ FIXEDTEXT_ENTRY(fixedTextES_ActionClose) },
+	{ FIXEDTEXT_ENTRY(fixedTextES_ActionMove) },
+	{ FIXEDTEXT_ENTRY(fixedTextES_ActionPick) },
+	{ FIXEDTEXT_ENTRY(fixedTextES_ActionUse) }
+};
+
+// =========================================
+
+// TODO:
+// It seems there was a French version of Sherlock Holmes 2
+static const FixedTextLanguageEntry fixedTextLanguages[] = {
+	{ Common::DE_DEU,   fixedTextDE, fixedTextDE_Actions },
+	{ Common::ES_ESP,   fixedTextES, fixedTextES_Actions },
+	{ Common::EN_ANY,   fixedTextEN, fixedTextEN_Actions },
+	{ Common::UNK_LANG, fixedTextEN, fixedTextEN_Actions }
+};
+
+// =========================================
+
+// =========================================
+
+ScalpelFixedText::ScalpelFixedText(SherlockEngine *vm) : FixedText(vm) {
+	// Figure out which fixed texts to use
+	Common::Language curLanguage = _vm->getLanguage();
+
+	const FixedTextLanguageEntry *curLanguageEntry = fixedTextLanguages;
+
+	while (curLanguageEntry->language != Common::UNK_LANG) {
+		if (curLanguageEntry->language == curLanguage)
+			break; // found current language
+		curLanguageEntry++;
+	}
+	_curLanguageEntry = curLanguageEntry;
+}
+
+const char *ScalpelFixedText::getText(int fixedTextId) {
+	return _curLanguageEntry->fixedTextArray[fixedTextId];
+}
+
+const Common::String ScalpelFixedText::getActionMessage(FixedTextActionId actionId, int messageIndex) {
+	assert(actionId >= 0);
+	assert(messageIndex >= 0);
+	const FixedTextActionEntry *curActionEntry = &_curLanguageEntry->actionArray[actionId];
+
+	assert(messageIndex < curActionEntry->fixedTextArrayCount);
+	return Common::String(curActionEntry->fixedTextArray[messageIndex]);
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_fixed_text.h b/engines/sherlock/scalpel/scalpel_fixed_text.h
new file mode 100644
index 0000000000..f46587ce81
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_fixed_text.h
@@ -0,0 +1,174 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_SCALPEL_FIXED_TEXT_H
+#define SHERLOCK_SCALPEL_FIXED_TEXT_H
+
+#include "sherlock/fixed_text.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+enum FixedTextId {
+	// Window buttons
+	kFixedText_Window_Exit = 0,
+	kFixedText_Window_Up,
+	kFixedText_Window_Down,
+	// Inventory buttons
+	kFixedText_Inventory_Exit,
+	kFixedText_Inventory_Look,
+	kFixedText_Inventory_Use,
+	kFixedText_Inventory_Give,
+	// Journal text
+	kFixedText_Journal_WatsonsJournal,
+	kFixedText_Journal_Page,
+	// Journal buttons
+	kFixedText_Journal_Exit,
+	kFixedText_Journal_Back10,
+	kFixedText_Journal_Up,
+	kFixedText_Journal_Down,
+	kFixedText_Journal_Ahead10,
+	kFixedText_Journal_Search,
+	kFixedText_Journal_FirstPage,
+	kFixedText_Journal_LastPage,
+	kFixedText_Journal_PrintText,
+	// Journal search
+	kFixedText_JournalSearch_Exit,
+	kFixedText_JournalSearch_Backward,
+	kFixedText_JournalSearch_Forward,
+	kFixedText_JournalSearch_NotFound,
+	// Press key text
+	kFixedText_PressKey_ForMore,
+	kFixedText_PressKey_ForMoreHotkey,
+	kFixedText_PressKey_ToContinue,
+	kFixedText_PressKey_ToContinueHotkey,
+	// Initial inventory
+	kFixedText_InitInventory_Message,
+	kFixedText_InitInventory_HolmesCard,
+	kFixedText_InitInventory_Tickets,
+	kFixedText_InitInventory_CuffLink,
+	kFixedText_InitInventory_WireHook,
+	kFixedText_InitInventory_Note,
+	kFixedText_InitInventory_OpenWatch,
+	kFixedText_InitInventory_Paper,
+	kFixedText_InitInventory_Letter,
+	kFixedText_InitInventory_Tarot,
+	kFixedText_InitInventory_OrnateKey,
+	kFixedText_InitInventory_PawnTicket,
+	// People names
+	kFixedText_People_SherlockHolmes,
+	kFixedText_People_DrWatson,
+	kFixedText_People_InspectorLestrade,
+	kFixedText_People_ConstableOBrien,
+	kFixedText_People_ConstableLewis,
+	kFixedText_People_SheilaParker,
+	kFixedText_People_HenryCarruthers,
+	kFixedText_People_Lesley,
+	kFixedText_People_AnUsher,
+	kFixedText_People_FredrickEpstein,
+	kFixedText_People_MrsWorthington,
+	kFixedText_People_TheCoach,
+	kFixedText_People_APlayer,
+	kFixedText_People_Tim,
+	kFixedText_People_JamesSanders,
+	kFixedText_People_Belle,
+	kFixedText_People_CleaningGirl,
+	kFixedText_People_Wiggins,
+	kFixedText_People_Paul,
+	kFixedText_People_TheBartender,
+	kFixedText_People_ADirtyDrunk,
+	kFixedText_People_AShoutingDrunk,
+	kFixedText_People_AStaggeringDrunk,
+	kFixedText_People_TheBouncer,
+	kFixedText_People_TheCoroner,
+	kFixedText_People_ReginaldSnipes,
+	kFixedText_People_GeorgeBlackwood,
+	kFixedText_People_Lars,
+	kFixedText_People_TheChemist,
+	kFixedText_People_InspectorGregson,
+	kFixedText_People_JacobFarthington,
+	kFixedText_People_Mycroft,
+	kFixedText_People_OldSherman,
+	kFixedText_People_Richard,
+	kFixedText_People_TheBarman,
+	kFixedText_People_ADandyPlayer,
+	kFixedText_People_ARoughlookingPlayer,
+	kFixedText_People_ASpectator,
+	kFixedText_People_RobertHunt,
+	kFixedText_People_Violet,
+	kFixedText_People_Pettigrew,
+	kFixedText_People_Augie,
+	kFixedText_People_AnnaCarroway,
+	kFixedText_People_AGuard,
+	kFixedText_People_AntonioCaruso,
+	kFixedText_People_TobyTheDog,
+	kFixedText_People_SimonKingsley,
+	kFixedText_People_Alfred,
+	kFixedText_People_LadyBrumwell,
+	kFixedText_People_MadameRosa,
+	kFixedText_People_JosephMoorehead,
+	kFixedText_People_MrsBeale,
+	kFixedText_People_Felix,
+	kFixedText_People_Hollingston,
+	kFixedText_People_ConstableCallaghan,
+	kFixedText_People_SergeantDuncan,
+	kFixedText_People_LordBrumwell,
+	kFixedText_People_NigelJaimeson,
+	kFixedText_People_Jonas,
+	kFixedText_People_ConstableDugan
+};
+
+struct FixedTextActionEntry {
+	const char *const *fixedTextArray;
+	int   fixedTextArrayCount;
+};
+
+struct FixedTextLanguageEntry {
+	Common::Language language;
+	const char *const *fixedTextArray;
+	const FixedTextActionEntry *actionArray;
+};
+
+class ScalpelFixedText: public FixedText {
+private:
+	const FixedTextLanguageEntry *_curLanguageEntry;
+public:
+	ScalpelFixedText(SherlockEngine *vm);
+	virtual ~ScalpelFixedText() {}
+
+	/**
+	 * Gets text
+	 */
+	virtual const char *getText(int fixedTextId);
+
+	/**
+	 * Get action message
+	 */
+	virtual const Common::String getActionMessage(FixedTextActionId actionId, int messageIndex);
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_inventory.cpp b/engines/sherlock/scalpel/scalpel_inventory.cpp
new file mode 100644
index 0000000000..e19a43238c
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_inventory.cpp
@@ -0,0 +1,296 @@
+/* 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 "sherlock/scalpel/scalpel_inventory.h"
+#include "sherlock/scalpel/scalpel_fixed_text.h"
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "sherlock/scalpel/scalpel_user_interface.h"
+#include "sherlock/scalpel/scalpel.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+ScalpelInventory::ScalpelInventory(SherlockEngine *vm) : Inventory(vm) {
+	_invShapes.resize(6);
+}
+
+ScalpelInventory::~ScalpelInventory() {
+}
+
+void ScalpelInventory::drawInventory(InvNewMode mode) {
+	FixedText &fixedText = *_vm->_fixedText;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	UserInterface &ui = *_vm->_ui;
+	InvNewMode tempMode = mode;
+
+	loadInv();
+
+	if (mode == INVENTORY_DONT_DISPLAY) {
+		screen._backBuffer = &screen._backBuffer2;
+	}
+
+	// Draw the window background
+	Surface &bb = *screen._backBuffer;
+	bb.fillRect(Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, CONTROLS_Y1 + 10), BORDER_COLOR);
+	bb.fillRect(Common::Rect(0, CONTROLS_Y1 + 10, 2, SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+	bb.fillRect(Common::Rect(SHERLOCK_SCREEN_WIDTH - 2, CONTROLS_Y1 + 10,
+		SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+	bb.fillRect(Common::Rect(0, SHERLOCK_SCREEN_HEIGHT - 2, SHERLOCK_SCREEN_WIDTH,
+		SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+	bb.fillRect(Common::Rect(2, CONTROLS_Y1 + 10, SHERLOCK_SCREEN_WIDTH - 2, SHERLOCK_SCREEN_HEIGHT - 2),
+		INV_BACKGROUND);
+
+	// Draw the buttons
+	Common::String fixedText_Exit = fixedText.getText(kFixedText_Inventory_Exit);
+	Common::String fixedText_Look = fixedText.getText(kFixedText_Inventory_Look);
+	Common::String fixedText_Use  = fixedText.getText(kFixedText_Inventory_Use);
+	Common::String fixedText_Give = fixedText.getText(kFixedText_Inventory_Give);
+
+	screen.makeButton(Common::Rect(INVENTORY_POINTS[0][0], CONTROLS_Y1, INVENTORY_POINTS[0][1],
+		CONTROLS_Y1 + 10), INVENTORY_POINTS[0][2] - screen.stringWidth(fixedText_Exit) / 2, fixedText_Exit);
+	screen.makeButton(Common::Rect(INVENTORY_POINTS[1][0], CONTROLS_Y1, INVENTORY_POINTS[1][1],
+		CONTROLS_Y1 + 10), INVENTORY_POINTS[1][2] - screen.stringWidth(fixedText_Look) / 2, fixedText_Look);
+	screen.makeButton(Common::Rect(INVENTORY_POINTS[2][0], CONTROLS_Y1, INVENTORY_POINTS[2][1],
+		CONTROLS_Y1 + 10), INVENTORY_POINTS[2][2] - screen.stringWidth(fixedText_Use) / 2, fixedText_Use);
+	screen.makeButton(Common::Rect(INVENTORY_POINTS[3][0], CONTROLS_Y1, INVENTORY_POINTS[3][1],
+		CONTROLS_Y1 + 10), INVENTORY_POINTS[3][2] - screen.stringWidth(fixedText_Give) / 2, fixedText_Give);
+	screen.makeButton(Common::Rect(INVENTORY_POINTS[4][0], CONTROLS_Y1, INVENTORY_POINTS[4][1],
+		CONTROLS_Y1 + 10), INVENTORY_POINTS[4][2], "^^"); // 2 arrows pointing to the left
+	screen.makeButton(Common::Rect(INVENTORY_POINTS[5][0], CONTROLS_Y1, INVENTORY_POINTS[5][1],
+		CONTROLS_Y1 + 10), INVENTORY_POINTS[5][2], "^"); // 1 arrow pointing to the left
+	screen.makeButton(Common::Rect(INVENTORY_POINTS[6][0], CONTROLS_Y1, INVENTORY_POINTS[6][1],
+		CONTROLS_Y1 + 10), INVENTORY_POINTS[6][2], "_"); // 1 arrow pointing to the right
+	screen.makeButton(Common::Rect(INVENTORY_POINTS[7][0], CONTROLS_Y1, INVENTORY_POINTS[7][1],
+		CONTROLS_Y1 + 10), INVENTORY_POINTS[7][2], "__"); // 2 arrows pointing to the right
+
+	if (tempMode == INVENTORY_DONT_DISPLAY)
+		mode = LOOK_INVENTORY_MODE;
+	_invMode = (InvMode)((int)mode);
+
+	if (mode != PLAIN_INVENTORY) {
+		ui._oldKey = INVENTORY_COMMANDS[(int)mode];
+	} else {
+		ui._oldKey = -1;
+	}
+
+	invCommands(0);
+	putInv(SLAM_DONT_DISPLAY);
+
+	if (tempMode != INVENTORY_DONT_DISPLAY) {
+		if (!ui._slideWindows) {
+			screen.slamRect(Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+		} else {
+			ui.summonWindow(false, CONTROLS_Y1);
+		}
+
+		ui._windowOpen = true;
+	} else {
+		// Reset the screen back buffer to the first buffer now that drawing is done
+		screen._backBuffer = &screen._backBuffer1;
+	}
+
+	assert(IS_SERRATED_SCALPEL);
+	((ScalpelUserInterface *)_vm->_ui)->_oldUse = -1;
+}
+
+void ScalpelInventory::invCommands(bool slamIt) {
+	FixedText &fixedText = *_vm->_fixedText;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	UserInterface &ui = *_vm->_ui;
+
+	Common::String fixedText_Exit = fixedText.getText(kFixedText_Inventory_Exit);
+	Common::String fixedText_Look = fixedText.getText(kFixedText_Inventory_Look);
+	Common::String fixedText_Use  = fixedText.getText(kFixedText_Inventory_Use);
+	Common::String fixedText_Give = fixedText.getText(kFixedText_Inventory_Give);
+
+	if (slamIt) {
+		screen.buttonPrint(Common::Point(INVENTORY_POINTS[0][2], CONTROLS_Y1),
+			_invMode == INVMODE_EXIT ? COMMAND_HIGHLIGHTED :COMMAND_FOREGROUND,
+			true, fixedText_Exit);
+		screen.buttonPrint(Common::Point(INVENTORY_POINTS[1][2], CONTROLS_Y1),
+			_invMode == INVMODE_LOOK ? COMMAND_HIGHLIGHTED :COMMAND_FOREGROUND,
+			true, fixedText_Look);
+		screen.buttonPrint(Common::Point(INVENTORY_POINTS[2][2], CONTROLS_Y1),
+			_invMode == INVMODE_USE ? COMMAND_HIGHLIGHTED : COMMAND_FOREGROUND,
+			true, fixedText_Use);
+		screen.buttonPrint(Common::Point(INVENTORY_POINTS[3][2], CONTROLS_Y1),
+			_invMode == INVMODE_GIVE ? COMMAND_HIGHLIGHTED : COMMAND_FOREGROUND,
+			true, fixedText_Give);
+		screen.print(Common::Point(INVENTORY_POINTS[4][2], CONTROLS_Y1 + 1),
+			_invIndex == 0 ? COMMAND_NULL : COMMAND_FOREGROUND,
+			"^^"); // 2 arrows pointing to the left
+		screen.print(Common::Point(INVENTORY_POINTS[5][2], CONTROLS_Y1 + 1),
+			_invIndex == 0 ? COMMAND_NULL : COMMAND_FOREGROUND,
+			"^"); // 2 arrows pointing to the left
+		screen.print(Common::Point(INVENTORY_POINTS[6][2], CONTROLS_Y1 + 1),
+			(_holdings - _invIndex <= 6) ? COMMAND_NULL : COMMAND_FOREGROUND,
+			"_"); // 1 arrow pointing to the right
+		screen.print(Common::Point(INVENTORY_POINTS[7][2], CONTROLS_Y1 + 1),
+			(_holdings - _invIndex <= 6) ? COMMAND_NULL : COMMAND_FOREGROUND,
+			"__"); // 2 arrows pointing to the right
+		if (_invMode != INVMODE_LOOK)
+			ui.clearInfo();
+	} else {
+		screen.buttonPrint(Common::Point(INVENTORY_POINTS[0][2], CONTROLS_Y1),
+			_invMode == INVMODE_EXIT ? COMMAND_HIGHLIGHTED : COMMAND_FOREGROUND,
+			false, fixedText_Exit);
+		screen.buttonPrint(Common::Point(INVENTORY_POINTS[1][2], CONTROLS_Y1),
+			_invMode == INVMODE_LOOK ? COMMAND_HIGHLIGHTED : COMMAND_FOREGROUND,
+			false, fixedText_Look);
+		screen.buttonPrint(Common::Point(INVENTORY_POINTS[2][2], CONTROLS_Y1),
+			_invMode == INVMODE_USE ? COMMAND_HIGHLIGHTED : COMMAND_FOREGROUND,
+			false, fixedText_Use);
+		screen.buttonPrint(Common::Point(INVENTORY_POINTS[3][2], CONTROLS_Y1),
+			_invMode == INVMODE_GIVE ? COMMAND_HIGHLIGHTED : COMMAND_FOREGROUND,
+			false, fixedText_Give);
+		screen.gPrint(Common::Point(INVENTORY_POINTS[4][2], CONTROLS_Y1),
+			_invIndex == 0 ? COMMAND_NULL : COMMAND_FOREGROUND,
+			"^^"); // 2 arrows pointing to the left
+		screen.gPrint(Common::Point(INVENTORY_POINTS[5][2], CONTROLS_Y1),
+			_invIndex == 0 ? COMMAND_NULL : COMMAND_FOREGROUND,
+			"^"); // 1 arrow pointing to the left
+		screen.gPrint(Common::Point(INVENTORY_POINTS[6][2], CONTROLS_Y1),
+			(_holdings - _invIndex < 7) ? COMMAND_NULL : COMMAND_FOREGROUND,
+			"_"); // 1 arrow pointing to the right
+		screen.gPrint(Common::Point(INVENTORY_POINTS[7][2], CONTROLS_Y1),
+			(_holdings - _invIndex < 7) ? COMMAND_NULL : COMMAND_FOREGROUND,
+			"__"); // 2 arrows pointing to the right
+	}
+}
+
+void ScalpelInventory::highlight(int index, byte color) {
+	Screen &screen = *_vm->_screen;
+	Surface &bb = *screen._backBuffer;
+	int slot = index - _invIndex;
+	ImageFrame &frame = (*_invShapes[slot])[0];
+
+	bb.fillRect(Common::Rect(8 + slot * 52, 165, (slot + 1) * 52, 194), color);
+	bb.transBlitFrom(frame, Common::Point(6 + slot * 52 + ((47 - frame._width) / 2),
+		163 + ((33 - frame._height) / 2)));
+	screen.slamArea(8 + slot * 52, 165, 44, 30);
+}
+
+void ScalpelInventory::refreshInv() {
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	ScalpelUserInterface &ui = *(ScalpelUserInterface *)_vm->_ui;
+
+	ui._invLookFlag = true;
+	freeInv();
+
+	ui._infoFlag = true;
+	ui.clearInfo();
+
+	screen._backBuffer2.blitFrom(screen._backBuffer1, Common::Point(0, CONTROLS_Y),
+		Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+	ui.examine();
+
+	if (!talk._talkToAbort) {
+		screen._backBuffer2.blitFrom((*ui._controlPanel)[0], Common::Point(0, CONTROLS_Y));
+		loadInv();
+	}
+}
+
+void ScalpelInventory::putInv(InvSlamMode slamIt) {
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	UserInterface &ui = *_vm->_ui;
+
+	// If an inventory item has disappeared (due to using it or giving it),
+	// a blank space slot may have appeared. If so, adjust the inventory
+	if (_invIndex > 0 && _invIndex > (_holdings - (int)_invShapes.size())) {
+		--_invIndex;
+		freeGraphics();
+		loadGraphics();
+	}
+
+	if (slamIt != SLAM_SECONDARY_BUFFER) {
+		screen.makePanel(Common::Rect(6, 163, 54, 197));
+		screen.makePanel(Common::Rect(58, 163, 106, 197));
+		screen.makePanel(Common::Rect(110, 163, 158, 197));
+		screen.makePanel(Common::Rect(162, 163, 210, 197));
+		screen.makePanel(Common::Rect(214, 163, 262, 197));
+		screen.makePanel(Common::Rect(266, 163, 314, 197));
+	}
+
+	// Iterate through displaying up to 6 objects at a time
+	for (int idx = _invIndex; idx < _holdings && (idx - _invIndex) < (int)_invShapes.size(); ++idx) {
+		int itemNum = idx - _invIndex;
+		Surface &bb = slamIt == SLAM_SECONDARY_BUFFER ? screen._backBuffer2 : screen._backBuffer1;
+		Common::Rect r(8 + itemNum * 52, 165, 51 + itemNum * 52, 194);
+
+		// Draw the background
+		if (idx == ui._selector) {
+			bb.fillRect(r, BUTTON_BACKGROUND);
+		}
+		else if (slamIt == SLAM_SECONDARY_BUFFER) {
+			bb.fillRect(r, BUTTON_MIDDLE);
+		}
+
+		// Draw the item image
+		ImageFrame &frame = (*_invShapes[itemNum])[0];
+		bb.transBlitFrom(frame, Common::Point(6 + itemNum * 52 + ((47 - frame._width) / 2),
+			163 + ((33 - frame._height) / 2)));
+	}
+
+	if (slamIt == SLAM_DISPLAY)
+		screen.slamArea(6, 163, 308, 34);
+
+	if (slamIt != SLAM_SECONDARY_BUFFER)
+		ui.clearInfo();
+
+	if (slamIt == 0) {
+		invCommands(0);
+	}
+	else if (slamIt == SLAM_SECONDARY_BUFFER) {
+		screen._backBuffer = &screen._backBuffer2;
+		invCommands(0);
+		screen._backBuffer = &screen._backBuffer1;
+	}
+}
+
+void ScalpelInventory::loadInv() {
+	// Exit if the inventory names are already loaded
+	if (_names.size() > 0)
+		return;
+
+	// Load the inventory names
+	Common::SeekableReadStream *stream = _vm->_res->load("invent.txt");
+
+	int streamSize = stream->size();
+	while (stream->pos() < streamSize) {
+		Common::String name;
+		char c;
+		while ((c = stream->readByte()) != 0)
+			name += c;
+
+		_names.push_back(name);
+	}
+
+	delete stream;
+
+	loadGraphics();
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_inventory.h b/engines/sherlock/scalpel/scalpel_inventory.h
new file mode 100644
index 0000000000..afafb0b94a
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_inventory.h
@@ -0,0 +1,74 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_SCALPEL_INVENTORY_H
+#define SHERLOCK_SCALPEL_INVENTORY_H
+
+#include "sherlock/inventory.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+class ScalpelInventory : public Inventory {
+public:
+	ScalpelInventory(SherlockEngine *vm);
+	~ScalpelInventory();
+
+	/**
+	 * Put the game into inventory mode and open the interface window.
+	 */
+	void drawInventory(InvNewMode flag);
+
+	/**
+	 * Prints the line of inventory commands at the top of an inventory window with
+	 * the correct highlighting
+	 */
+	void invCommands(bool slamIt);
+
+	/**
+	 * Set the highlighting color of a given inventory item
+	 */
+	void highlight(int index, byte color);
+
+	/**
+	 * Support method for refreshing the display of the inventory
+	 */
+	void refreshInv();
+
+	/**
+	 * Display the character's inventory. The slamIt parameter specifies:
+	 */
+	void putInv(InvSlamMode slamIt);
+
+	/**
+	 * Load the list of names the inventory items correspond to, if not already loaded,
+	 * and then calls loadGraphics to load the associated graphics
+	 */
+	virtual void loadInv();
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_journal.cpp b/engines/sherlock/scalpel/scalpel_journal.cpp
new file mode 100644
index 0000000000..5c2b8f77f3
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_journal.cpp
@@ -0,0 +1,655 @@
+/* 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 "sherlock/journal.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/scalpel/scalpel_fixed_text.h"
+#include "sherlock/scalpel/scalpel_journal.h"
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/tattoo/tattoo_journal.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+#define JOURNAL_BUTTONS_Y 178
+#define JOURNAL_SEARCH_LEFT 15
+#define JOURNAL_SEARCH_TOP 186
+#define JOURNAL_SEARCH_RIGHT 296
+#define JOURNAL_SEACRH_MAX_CHARS 50
+
+// Positioning of buttons in the journal view
+static const int JOURNAL_POINTS[9][3] = {
+	{ 6, 68, 37 },
+	{ 69, 131, 100 },
+	{ 132, 192, 162 },
+	{ 193, 250, 221 },
+	{ 251, 313, 281 },
+	{ 6, 82, 44 },
+	{ 83, 159, 121 },
+	{ 160, 236, 198 },
+	{ 237, 313, 275 }
+};
+
+static const int SEARCH_POINTS[3][3] = {
+	{ 51, 123, 86 },
+	{ 124, 196, 159 },
+	{ 197, 269, 232 }
+};
+
+/*----------------------------------------------------------------*/
+
+ScalpelJournal::ScalpelJournal(SherlockEngine *vm) : Journal(vm) {
+	if (_vm->_interactiveFl) {
+		// Load the journal directory and location names
+		loadLocations();
+	}
+}
+
+void ScalpelJournal::loadLocations() {
+	Resources &res = *_vm->_res;
+
+	_directory.clear();
+	_locations.clear();
+
+
+	Common::SeekableReadStream *dir = res.load("talk.lib");
+	dir->skip(4);		// Skip header
+
+	// Get the numer of entries
+	_directory.resize(dir->readUint16LE());
+
+	// Read in each entry
+	char buffer[17];
+	for (uint idx = 0; idx < _directory.size(); ++idx) {
+		dir->read(buffer, 17);
+		buffer[16] = '\0';
+
+		_directory[idx] = Common::String(buffer);
+	}
+
+	delete dir;
+
+	if (IS_3DO) {
+		// 3DO: storage of locations is currently unknown TODO
+		return;
+	}
+
+	// Load in the locations stored in journal.txt
+	Common::SeekableReadStream *loc = res.load("journal.txt");
+
+	while (loc->pos() < loc->size()) {
+		Common::String line;
+		char c;
+		while ((c = loc->readByte()) != 0)
+			line += c;
+
+		// WORKAROUND: Special fixes for faulty translations
+		// Was obviously not done in the original interpreter
+		if (_vm->getLanguage() == Common::ES_ESP) {
+			// Spanish version
+			// We fix all sorts of typos
+			// see bug #6931
+			if (line == "En el cajellon destras del teatro Regency") {
+				line = "En el callejon detras del teatro Regency";
+			} else if (line == "En el apartamente de Simon Kingsley") {
+				line = "En el apartamento de Simon Kingsley";
+			} else if (line == "Bajo la muelle de Savoy Pier") {
+				line = "Bajo el muelle de Savoy Pier";
+			} else if (line == "En le viejo Sherman") {
+				line = "En el viejo Sherman";
+			} else if (line == "En la entrada de la cada de Anna Carroway") {
+				line = "En la entrada de la casa de Anna Carroway";
+			}
+		}
+
+		_locations.push_back(line);
+	}
+
+	delete loc;
+}
+
+void ScalpelJournal::drawFrame() {
+	FixedText &fixedText = *_vm->_fixedText;
+	Resources &res = *_vm->_res;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	byte palette[PALETTE_SIZE];
+
+	// Load in the journal background
+	Common::SeekableReadStream *bg = res.load("journal.lbv");
+	bg->read(screen._backBuffer1.getPixels(), SHERLOCK_SCREEN_WIDTH * SHERLOCK_SCREEN_HEIGHT);
+	bg->read(palette, PALETTE_SIZE);
+	delete bg;
+
+	// Translate the palette for display
+	for (int idx = 0; idx < PALETTE_SIZE; ++idx)
+		palette[idx] = VGA_COLOR_TRANS(palette[idx]);
+
+	Common::String fixedText_WatsonsJournal = fixedText.getText(kFixedText_Journal_WatsonsJournal);
+	Common::String fixedText_Exit           = fixedText.getText(kFixedText_Journal_Exit);
+	Common::String fixedText_Back10         = fixedText.getText(kFixedText_Journal_Back10);
+	Common::String fixedText_Up             = fixedText.getText(kFixedText_Journal_Up);
+	Common::String fixedText_Down           = fixedText.getText(kFixedText_Journal_Down);
+	Common::String fixedText_Ahead10        = fixedText.getText(kFixedText_Journal_Ahead10);
+	Common::String fixedText_Search         = fixedText.getText(kFixedText_Journal_Search);
+	Common::String fixedText_FirstPage      = fixedText.getText(kFixedText_Journal_FirstPage);
+	Common::String fixedText_LastPage       = fixedText.getText(kFixedText_Journal_LastPage);
+	Common::String fixedText_PrintText      = fixedText.getText(kFixedText_Journal_PrintText);
+
+	// Set the palette and print the title
+	screen.setPalette(palette);
+	screen.gPrint(Common::Point(111, 18), BUTTON_BOTTOM, "%s", fixedText_WatsonsJournal.c_str());
+	screen.gPrint(Common::Point(110, 17), INV_FOREGROUND, "%s", fixedText_WatsonsJournal.c_str());
+
+	// Draw the buttons
+	screen.makeButton(Common::Rect(JOURNAL_POINTS[0][0], JOURNAL_BUTTONS_Y,
+		JOURNAL_POINTS[0][1], JOURNAL_BUTTONS_Y + 10),
+		JOURNAL_POINTS[0][2] - screen.stringWidth(fixedText_Exit) / 2, fixedText_Exit);
+	screen.makeButton(Common::Rect(JOURNAL_POINTS[1][0], JOURNAL_BUTTONS_Y,
+		JOURNAL_POINTS[1][1], JOURNAL_BUTTONS_Y + 10),
+		JOURNAL_POINTS[1][2] - screen.stringWidth(fixedText_Back10) / 2, fixedText_Back10);
+	screen.makeButton(Common::Rect(JOURNAL_POINTS[2][0], JOURNAL_BUTTONS_Y,
+		JOURNAL_POINTS[2][1], JOURNAL_BUTTONS_Y + 10),
+		JOURNAL_POINTS[2][2] - screen.stringWidth(fixedText_Up) / 2, fixedText_Up);
+	screen.makeButton(Common::Rect(JOURNAL_POINTS[3][0], JOURNAL_BUTTONS_Y,
+		JOURNAL_POINTS[3][1], JOURNAL_BUTTONS_Y + 10),
+		JOURNAL_POINTS[3][2] - screen.stringWidth(fixedText_Down) / 2, fixedText_Down);
+	screen.makeButton(Common::Rect(JOURNAL_POINTS[4][0], JOURNAL_BUTTONS_Y,
+		JOURNAL_POINTS[4][1], JOURNAL_BUTTONS_Y + 10),
+		JOURNAL_POINTS[4][2] - screen.stringWidth(fixedText_Ahead10) / 2, fixedText_Ahead10);
+	screen.makeButton(Common::Rect(JOURNAL_POINTS[5][0], JOURNAL_BUTTONS_Y + 11,
+		JOURNAL_POINTS[5][1], JOURNAL_BUTTONS_Y + 21),
+		JOURNAL_POINTS[5][2] - screen.stringWidth(fixedText_Search) / 2, fixedText_Search);
+	screen.makeButton(Common::Rect(JOURNAL_POINTS[6][0], JOURNAL_BUTTONS_Y + 11,
+		JOURNAL_POINTS[6][1], JOURNAL_BUTTONS_Y + 21),
+		JOURNAL_POINTS[6][2] - screen.stringWidth(fixedText_FirstPage) / 2, fixedText_FirstPage);
+	screen.makeButton(Common::Rect(JOURNAL_POINTS[7][0], JOURNAL_BUTTONS_Y + 11,
+		JOURNAL_POINTS[7][1], JOURNAL_BUTTONS_Y + 21),
+		JOURNAL_POINTS[7][2] - screen.stringWidth(fixedText_LastPage) / 2, fixedText_LastPage);
+
+	// WORKAROUND: Draw Print Text button as disabled, since we don't support it in ScummVM
+	screen.makeButton(Common::Rect(JOURNAL_POINTS[8][0], JOURNAL_BUTTONS_Y + 11,
+		JOURNAL_POINTS[8][1], JOURNAL_BUTTONS_Y + 21),
+		JOURNAL_POINTS[8][2] - screen.stringWidth(fixedText_PrintText) / 2, fixedText_PrintText);
+	screen.buttonPrint(Common::Point(JOURNAL_POINTS[8][2], JOURNAL_BUTTONS_Y + 11),
+		COMMAND_NULL, false, fixedText_PrintText);
+}
+
+void ScalpelJournal::drawInterface() {
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+
+	drawFrame();
+
+	if (_journal.empty()) {
+		_up = _down = 0;
+	} else {
+		drawJournal(0, 0);
+	}
+
+	doArrows();
+
+	// Show the entire screen
+	screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+}
+
+void ScalpelJournal::doArrows() {
+	FixedText &fixedText = *_vm->_fixedText;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	byte color;
+
+	Common::String fixedText_Back10         = fixedText.getText(kFixedText_Journal_Back10);
+	Common::String fixedText_Up             = fixedText.getText(kFixedText_Journal_Up);
+	Common::String fixedText_Down           = fixedText.getText(kFixedText_Journal_Down);
+	Common::String fixedText_Ahead10        = fixedText.getText(kFixedText_Journal_Ahead10);
+	Common::String fixedText_Search         = fixedText.getText(kFixedText_Journal_Search);
+	Common::String fixedText_FirstPage      = fixedText.getText(kFixedText_Journal_FirstPage);
+	Common::String fixedText_LastPage       = fixedText.getText(kFixedText_Journal_LastPage);
+	Common::String fixedText_PrintText      = fixedText.getText(kFixedText_Journal_PrintText);
+
+	color = (_page > 1) ? COMMAND_FOREGROUND : COMMAND_NULL;
+	screen.buttonPrint(Common::Point(JOURNAL_POINTS[1][2], JOURNAL_BUTTONS_Y), color, false, fixedText_Back10);
+	screen.buttonPrint(Common::Point(JOURNAL_POINTS[2][2], JOURNAL_BUTTONS_Y), color, false, fixedText_Up);
+
+	color = _down ? COMMAND_FOREGROUND : COMMAND_NULL;
+	screen.buttonPrint(Common::Point(JOURNAL_POINTS[3][2], JOURNAL_BUTTONS_Y), color, false, fixedText_Down);
+	screen.buttonPrint(Common::Point(JOURNAL_POINTS[4][2], JOURNAL_BUTTONS_Y), color, false, fixedText_Ahead10);
+	screen.buttonPrint(Common::Point(JOURNAL_POINTS[7][2], JOURNAL_BUTTONS_Y + 11), color, false, fixedText_LastPage);
+
+	color = _journal.size() > 0 ? COMMAND_FOREGROUND : COMMAND_NULL;
+	screen.buttonPrint(Common::Point(JOURNAL_POINTS[5][2], JOURNAL_BUTTONS_Y + 11), color, false, fixedText_Search);
+	screen.buttonPrint(Common::Point(JOURNAL_POINTS[8][2], JOURNAL_BUTTONS_Y + 11), COMMAND_NULL, false, fixedText_PrintText);
+
+	color = _page > 1 ? COMMAND_FOREGROUND : COMMAND_NULL;
+	screen.buttonPrint(Common::Point(JOURNAL_POINTS[6][2], JOURNAL_BUTTONS_Y + 11), color, false, fixedText_FirstPage);
+}
+
+JournalButton ScalpelJournal::getHighlightedButton(const Common::Point &pt) {
+	if (pt.x > JOURNAL_POINTS[0][0] && pt.x < JOURNAL_POINTS[0][1] && pt.y >= JOURNAL_BUTTONS_Y &&
+			pt.y < (JOURNAL_BUTTONS_Y + 10))
+		return BTN_EXIT;
+
+	if (pt.x > JOURNAL_POINTS[1][0] && pt.x < JOURNAL_POINTS[1][1] && pt.y >= JOURNAL_BUTTONS_Y &&
+			pt.y < (JOURNAL_BUTTONS_Y + 10) && _page > 1)
+		return BTN_BACK10;
+
+	if (pt.x > JOURNAL_POINTS[2][0] && pt.x < JOURNAL_POINTS[2][1] && pt.y >= JOURNAL_BUTTONS_Y &&
+			pt.y < (JOURNAL_BUTTONS_Y + 10) && _up)
+		return BTN_UP;
+
+	if (pt.x > JOURNAL_POINTS[3][0] && pt.x < JOURNAL_POINTS[3][1] && pt.y >= JOURNAL_BUTTONS_Y &&
+			pt.y < (JOURNAL_BUTTONS_Y + 10) && _down)
+		return BTN_DOWN;
+
+	if (pt.x > JOURNAL_POINTS[4][0] && pt.x < JOURNAL_POINTS[4][1] && pt.y >= JOURNAL_BUTTONS_Y &&
+			pt.y < (JOURNAL_BUTTONS_Y + 10) && _down)
+		return BTN_AHEAD110;
+
+	if (pt.x > JOURNAL_POINTS[5][0] && pt.x < JOURNAL_POINTS[5][1] && pt.y >= (JOURNAL_BUTTONS_Y + 11) &&
+			pt.y < (JOURNAL_BUTTONS_Y + 20) && !_journal.empty())
+		return BTN_SEARCH;
+
+	if (pt.x > JOURNAL_POINTS[6][0] && pt.x < JOURNAL_POINTS[6][1] && pt.y >= (JOURNAL_BUTTONS_Y + 11) &&
+			pt.y < (JOURNAL_BUTTONS_Y + 20) && _up)
+		return BTN_FIRST_PAGE;
+
+	if (pt.x > JOURNAL_POINTS[7][0] && pt.x < JOURNAL_POINTS[7][1] && pt.y >= (JOURNAL_BUTTONS_Y + 11) &&
+			pt.y < (JOURNAL_BUTTONS_Y + 20) && _down)
+		return BTN_LAST_PAGE;
+
+	if (pt.x > JOURNAL_POINTS[8][0] && pt.x < JOURNAL_POINTS[8][1] && pt.y >= (JOURNAL_BUTTONS_Y + 11) &&
+			pt.y < (JOURNAL_BUTTONS_Y + 20) && !_journal.empty())
+		return BTN_PRINT_TEXT;
+
+	return BTN_NONE;
+}
+
+bool ScalpelJournal::handleEvents(int key) {
+	Events    &events    = *_vm->_events;
+	FixedText &fixedText = *_vm->_fixedText;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	bool doneFlag = false;
+
+	Common::Point pt = events.mousePos();
+	JournalButton btn = getHighlightedButton(pt);
+	byte color;
+
+	if (events._pressed || events._released) {
+		Common::String fixedText_Exit           = fixedText.getText(kFixedText_Journal_Exit);
+		Common::String fixedText_Back10         = fixedText.getText(kFixedText_Journal_Back10);
+		Common::String fixedText_Up             = fixedText.getText(kFixedText_Journal_Up);
+		Common::String fixedText_Down           = fixedText.getText(kFixedText_Journal_Down);
+		Common::String fixedText_Ahead10        = fixedText.getText(kFixedText_Journal_Ahead10);
+		Common::String fixedText_Search         = fixedText.getText(kFixedText_Journal_Search);
+		Common::String fixedText_FirstPage      = fixedText.getText(kFixedText_Journal_FirstPage);
+		Common::String fixedText_LastPage       = fixedText.getText(kFixedText_Journal_LastPage);
+		Common::String fixedText_PrintText      = fixedText.getText(kFixedText_Journal_PrintText);
+
+		// Exit button
+		color = (btn == BTN_EXIT) ? COMMAND_HIGHLIGHTED : COMMAND_FOREGROUND;
+		screen.buttonPrint(Common::Point(JOURNAL_POINTS[0][2], JOURNAL_BUTTONS_Y), color, true, fixedText_Exit);
+
+		// Back 10 button
+		if (btn == BTN_BACK10) {
+			screen.buttonPrint(Common::Point(JOURNAL_POINTS[1][2], JOURNAL_BUTTONS_Y), COMMAND_HIGHLIGHTED, true, fixedText_Back10);
+		} else if (_page > 1) {
+			screen.buttonPrint(Common::Point(JOURNAL_POINTS[1][2], JOURNAL_BUTTONS_Y), COMMAND_FOREGROUND, true, fixedText_Back10);
+		}
+
+		// Up button
+		if (btn == BTN_UP) {
+			screen.buttonPrint(Common::Point(JOURNAL_POINTS[2][2], JOURNAL_BUTTONS_Y), COMMAND_HIGHLIGHTED, true, fixedText_Up);
+		} else if (_up) {
+			screen.buttonPrint(Common::Point(JOURNAL_POINTS[2][2], JOURNAL_BUTTONS_Y), COMMAND_FOREGROUND, true, fixedText_Up);
+		}
+
+		// Down button
+		if (btn == BTN_DOWN) {
+			screen.buttonPrint(Common::Point(JOURNAL_POINTS[3][2], JOURNAL_BUTTONS_Y), COMMAND_HIGHLIGHTED, true, fixedText_Down);
+		} else if (_down) {
+			screen.buttonPrint(Common::Point(JOURNAL_POINTS[3][2], JOURNAL_BUTTONS_Y), COMMAND_FOREGROUND, true, fixedText_Down);
+		}
+
+		// Ahead 10 button
+		if (btn == BTN_AHEAD110) {
+			screen.buttonPrint(Common::Point(JOURNAL_POINTS[4][2], JOURNAL_BUTTONS_Y), COMMAND_HIGHLIGHTED, true, fixedText_Ahead10);
+		} else if (_down) {
+			screen.buttonPrint(Common::Point(JOURNAL_POINTS[4][2], JOURNAL_BUTTONS_Y), COMMAND_FOREGROUND, true, fixedText_Ahead10);
+		}
+
+		// Search button
+		if (btn == BTN_SEARCH) {
+			color = COMMAND_HIGHLIGHTED;
+		} else if (_journal.empty()) {
+			color = COMMAND_NULL;
+		} else {
+			color = COMMAND_FOREGROUND;
+		}
+		screen.buttonPrint(Common::Point(JOURNAL_POINTS[5][2], JOURNAL_BUTTONS_Y + 11), color, true, fixedText_Search);
+
+		// First Page button
+		if (btn == BTN_FIRST_PAGE) {
+			color = COMMAND_HIGHLIGHTED;
+		} else if (_up) {
+			color = COMMAND_FOREGROUND;
+		} else {
+			color = COMMAND_NULL;
+		}
+		screen.buttonPrint(Common::Point(JOURNAL_POINTS[6][2], JOURNAL_BUTTONS_Y + 11), color, true, fixedText_FirstPage);
+
+		// Last Page button
+		if (btn == BTN_LAST_PAGE) {
+			color = COMMAND_HIGHLIGHTED;
+		} else if (_down) {
+			color = COMMAND_FOREGROUND;
+		} else {
+			color = COMMAND_NULL;
+		}
+		screen.buttonPrint(Common::Point(JOURNAL_POINTS[7][2], JOURNAL_BUTTONS_Y + 11), color, true, fixedText_LastPage);
+
+		// Print Text button
+		screen.buttonPrint(Common::Point(JOURNAL_POINTS[8][2], JOURNAL_BUTTONS_Y + 11), COMMAND_NULL, true, fixedText_PrintText);
+	}
+
+	if (btn == BTN_EXIT && events._released) {
+		// Exit button pressed
+		doneFlag = true;
+
+	} else if (((btn == BTN_BACK10 && events._released) || key == 'B') && (_page > 1)) {
+		// Scrolll up 10 pages
+		if (_page < 11)
+			drawJournal(1, (_page - 1) * LINES_PER_PAGE);
+		else
+			drawJournal(1, 10 * LINES_PER_PAGE);
+
+		doArrows();
+		screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+	} else if (((btn == BTN_UP && events._released) || key == 'U') && _up) {
+		// Scroll up
+		drawJournal(1, LINES_PER_PAGE);
+		doArrows();
+		screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+	} else if (((btn == BTN_DOWN && events._released) || key == 'D') && _down) {
+		// Scroll down
+		drawJournal(2, LINES_PER_PAGE);
+		doArrows();
+		screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+	} else if (((btn == BTN_AHEAD110 && events._released) || key == 'A') && _down) {
+		// Scroll down 10 pages
+		if ((_page + 10) > _maxPage)
+			drawJournal(2, (_maxPage - _page) * LINES_PER_PAGE);
+		else
+			drawJournal(2, 10 * LINES_PER_PAGE);
+
+		doArrows();
+		screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+	} else if (((btn == BTN_SEARCH && events._released) || key == 'S') && !_journal.empty()) {
+		screen.buttonPrint(Common::Point(JOURNAL_POINTS[5][2], JOURNAL_BUTTONS_Y + 11), COMMAND_FOREGROUND, true, "Search");
+		bool notFound = false;
+
+		do {
+			int dir;
+			if ((dir = getSearchString(notFound)) != 0) {
+				int savedIndex = _index;
+				int savedSub = _sub;
+				int savedPage = _page;
+
+				if (drawJournal(dir + 2, 1000 * LINES_PER_PAGE) == 0) {
+					_index = savedIndex;
+					_sub = savedSub;
+					_page = savedPage;
+
+					drawFrame();
+					drawJournal(0, 0);
+					notFound = true;
+				} else {
+					doneFlag = true;
+				}
+
+				doArrows();
+				screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+			} else {
+				doneFlag = true;
+			}
+		} while (!doneFlag);
+		doneFlag = false;
+
+	} else if (((btn == BTN_FIRST_PAGE && events._released) || key == 'F') && _up) {
+		// First page
+		_index = _sub = 0;
+		_up = _down = false;
+		_page = 1;
+
+		drawFrame();
+		drawJournal(0, 0);
+		doArrows();
+		screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+	} else if (((btn == BTN_LAST_PAGE && events._released) || key == 'L') && _down) {
+		// Last page
+		if ((_page + 10) > _maxPage)
+			drawJournal(2, (_maxPage - _page) * LINES_PER_PAGE);
+		else
+			drawJournal(2, 1000 * LINES_PER_PAGE);
+
+		doArrows();
+		screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+	}
+
+	events.wait(2);
+
+	return doneFlag;
+}
+
+int ScalpelJournal::getSearchString(bool printError) {
+	enum Button { BTN_NONE, BTN_EXIT, BTN_BACKWARD, BTN_FORWARD };
+
+	Events    &events    = *_vm->_events;
+	FixedText &fixedText = *_vm->_fixedText;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	int xp;
+	int yp = 174;
+	bool flag = false;
+	Common::String name;
+	int done = 0;
+	byte color;
+
+	Common::String fixedText_Exit           = fixedText.getText(kFixedText_JournalSearch_Exit);
+	Common::String fixedText_Backward       = fixedText.getText(kFixedText_JournalSearch_Backward);
+	Common::String fixedText_Forward        = fixedText.getText(kFixedText_JournalSearch_Forward);
+	Common::String fixedText_NotFound       = fixedText.getText(kFixedText_JournalSearch_NotFound);
+
+	// Draw search panel
+	screen.makePanel(Common::Rect(6, 171, 313, 199));
+	screen.makeButton(Common::Rect(SEARCH_POINTS[0][0], yp, SEARCH_POINTS[0][1], yp + 10),
+		SEARCH_POINTS[0][2] - screen.stringWidth(fixedText_Exit) / 2, fixedText_Exit);
+	screen.makeButton(Common::Rect(SEARCH_POINTS[1][0], yp, SEARCH_POINTS[1][1], yp + 10),
+		SEARCH_POINTS[1][2] - screen.stringWidth(fixedText_Backward) / 2, fixedText_Backward);
+	screen.makeButton(Common::Rect(SEARCH_POINTS[2][0], yp, SEARCH_POINTS[2][1], yp + 10),
+		SEARCH_POINTS[2][2] - screen.stringWidth(fixedText_Forward) / 2, fixedText_Forward);
+
+	screen.gPrint(Common::Point(SEARCH_POINTS[0][2] - screen.stringWidth(fixedText_Exit) / 2, yp),
+		COMMAND_HIGHLIGHTED, "%c", fixedText_Exit[0]);
+	screen.gPrint(Common::Point(SEARCH_POINTS[1][2] - screen.stringWidth(fixedText_Backward) / 2, yp),
+		COMMAND_HIGHLIGHTED, "%c", fixedText_Backward[0]);
+	screen.gPrint(Common::Point(SEARCH_POINTS[2][2] - screen.stringWidth(fixedText_Forward) / 2, yp),
+		COMMAND_HIGHLIGHTED, "%c", fixedText_Forward[0]);
+
+	screen.makeField(Common::Rect(12, 185, 307, 196));
+
+	screen.fillRect(Common::Rect(12, 185, 307, 186), BUTTON_BOTTOM);
+	screen.vLine(12, 185, 195, BUTTON_BOTTOM);
+	screen.hLine(13, 195, 306, BUTTON_TOP);
+	screen.hLine(306, 186, 195, BUTTON_TOP);
+
+	if (printError) {
+		screen.gPrint(Common::Point((SHERLOCK_SCREEN_WIDTH - screen.stringWidth(fixedText_NotFound)) / 2, 185),
+			INV_FOREGROUND, "%s", fixedText_NotFound.c_str());
+	} else if (!_find.empty()) {
+		// There's already a search term, display it already
+		screen.gPrint(Common::Point(15, 185), TALK_FOREGROUND, "%s", _find.c_str());
+		name = _find;
+	}
+
+	screen.slamArea(6, 171, 307, 28);
+
+	if (printError) {
+		// Give time for user to see the message
+		events.setButtonState();
+		for (int idx = 0; idx < 40 && !_vm->shouldQuit() && !events.kbHit() && !events._released; ++idx) {
+			events.pollEvents();
+			events.setButtonState();
+			events.wait(2);
+		}
+
+		events.clearKeyboard();
+		screen._backBuffer1.fillRect(Common::Rect(13, 186, 306, 195), BUTTON_MIDDLE);
+
+		if (!_find.empty()) {
+			screen.gPrint(Common::Point(15, 185), TALK_FOREGROUND, "%s", _find.c_str());
+			name = _find;
+		}
+
+		screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+	}
+
+	xp = JOURNAL_SEARCH_LEFT + screen.stringWidth(name);
+	yp = JOURNAL_SEARCH_TOP;
+
+	do {
+		events._released = false;
+		Button found = BTN_NONE;
+
+		while (!_vm->shouldQuit() && !events.kbHit() && !events._released) {
+			found = BTN_NONE;
+			if (talk._talkToAbort)
+				return 0;
+
+			// Check if key or mouse button press has occurred
+			events.setButtonState();
+			Common::Point pt = events.mousePos();
+
+			flag = !flag;
+			screen.vgaBar(Common::Rect(xp, yp, xp + 8, yp + 9), flag ? INV_FOREGROUND : BUTTON_MIDDLE);
+
+			if (events._pressed || events._released) {
+				if (pt.x > SEARCH_POINTS[0][0] && pt.x < SEARCH_POINTS[0][1] && pt.y > 174 && pt.y < 183) {
+					found = BTN_EXIT;
+					color = COMMAND_HIGHLIGHTED;
+				} else {
+					color = COMMAND_FOREGROUND;
+				}
+				screen.print(Common::Point(SEARCH_POINTS[0][2] - screen.stringWidth(fixedText_Exit) / 2, 175), color, "%s", fixedText_Exit.c_str());
+
+				if (pt.x > SEARCH_POINTS[1][0] && pt.x < SEARCH_POINTS[1][1] && pt.y > 174 && pt.y < 183) {
+					found = BTN_BACKWARD;
+					color = COMMAND_HIGHLIGHTED;
+				} else {
+					color = COMMAND_FOREGROUND;
+				}
+				screen.print(Common::Point(SEARCH_POINTS[1][2] - screen.stringWidth(fixedText_Backward) / 2, 175), color, "%s", fixedText_Backward.c_str());
+
+				if (pt.x > SEARCH_POINTS[2][0] && pt.x < SEARCH_POINTS[2][1] && pt.y > 174 && pt.y < 183) {
+					found = BTN_FORWARD;
+					color = COMMAND_HIGHLIGHTED;
+				} else {
+					color = COMMAND_FOREGROUND;
+				}
+				screen.print(Common::Point(SEARCH_POINTS[2][2] - screen.stringWidth(fixedText_Forward) / 2, 175), color, "%s", fixedText_Forward.c_str());
+			}
+
+			events.wait(2);
+		}
+
+		if (events.kbHit()) {
+			Common::KeyState keyState = events.getKey();
+
+			if ((keyState.keycode == Common::KEYCODE_BACKSPACE) && (name.size() > 0)) {
+				screen.vgaBar(Common::Rect(xp - screen.charWidth(name.lastChar()), yp, xp + 8, yp + 9), BUTTON_MIDDLE);
+				xp -= screen.charWidth(name.lastChar());
+				screen.vgaBar(Common::Rect(xp, yp, xp + 8, yp + 9), INV_FOREGROUND);
+				name.deleteLastChar();
+
+			} else  if (keyState.keycode == Common::KEYCODE_RETURN) {
+				done = 1;
+
+			}  else if (keyState.keycode == Common::KEYCODE_ESCAPE) {
+				screen.vgaBar(Common::Rect(xp, yp, xp + 8, yp + 9), BUTTON_MIDDLE);
+				done = -1;
+
+			} else if (keyState.ascii >= ' ' && keyState.ascii <= 'z' && keyState.keycode != Common::KEYCODE_AT &&
+				name.size() < JOURNAL_SEACRH_MAX_CHARS && (xp + screen.charWidth(keyState.ascii)) < JOURNAL_SEARCH_RIGHT) {
+				char ch = toupper(keyState.ascii);
+				screen.vgaBar(Common::Rect(xp, yp, xp + 8, yp + 9), BUTTON_MIDDLE);
+				screen.print(Common::Point(xp, yp), TALK_FOREGROUND, "%c", ch);
+				xp += screen.charWidth(ch);
+				name += ch;
+			}
+		}
+
+		if (events._released) {
+			switch (found) {
+			case BTN_EXIT:
+				done = -1; break;
+			case BTN_BACKWARD:
+				done = 2; break;
+			case BTN_FORWARD:
+				done = 1; break;
+			default:
+				break;
+			}
+		}
+	} while (!done && !_vm->shouldQuit());
+
+	if (done != -1) {
+		_find = name;
+	} else {
+		done = 0;
+	}
+
+	// Redisplay the journal screen
+	drawFrame();
+	drawJournal(0, 0);
+	screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+	return done;
+}
+
+void ScalpelJournal::resetPosition() {
+	_index = _sub = _up = _down = 0;
+	_page = 1;
+}
+
+void ScalpelJournal::record(int converseNum, int statementNum, bool replyOnly) {
+	// there seems to be no journal in the 3DO version
+	if (!IS_3DO)
+		Journal::record(converseNum, statementNum, replyOnly);
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_journal.h b/engines/sherlock/scalpel/scalpel_journal.h
new file mode 100644
index 0000000000..c8e9c01739
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_journal.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 SHERLOCK_SCALPEL_JOURNAL_H
+#define SHERLOCK_SCALPEL_JOURNAL_H
+
+#include "sherlock/journal.h"
+#include "sherlock/saveload.h"
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/rect.h"
+#include "common/str-array.h"
+#include "common/stream.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+enum JournalButton {
+	BTN_NONE, BTN_EXIT, BTN_BACK10, BTN_UP, BTN_DOWN, BTN_AHEAD110, BTN_SEARCH,
+	BTN_FIRST_PAGE, BTN_LAST_PAGE, BTN_PRINT_TEXT
+};
+
+class ScalpelJournal: public Journal {
+private:
+	/**
+	 * Load the list of journal locations
+	 */
+	void loadLocations();
+
+	/**
+	 * Display the arrows that can be used to scroll up and down pages
+	 */
+	void doArrows();
+
+	/**
+	 * Show the search submenu and allow the player to enter a search string
+	 */
+	int getSearchString(bool printError);
+
+	/**
+	 * Returns the button, if any, that is under the specified position
+	 */
+	JournalButton getHighlightedButton(const Common::Point &pt);
+public:
+	ScalpelJournal(SherlockEngine *vm);
+	virtual ~ScalpelJournal() {}
+
+	/**
+	 * Display the journal
+	 */
+	void drawInterface();
+
+	/**
+	 * Handle events whilst the journal is being displayed
+	 */
+	bool handleEvents(int key);
+public:
+	/**
+	 * Draw the journal background, frame, and interface buttons
+	 */
+	virtual void drawFrame();
+
+	/**
+	 * Reset viewing position to the start of the journal
+	 */
+	virtual void resetPosition();
+
+	/**
+	 * Records statements that are said, in the order which they are said. The player
+	 * can then read the journal to review them
+	 */
+	virtual void record(int converseNum, int statementNum, bool replyOnly = false);
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_map.cpp b/engines/sherlock/scalpel/scalpel_map.cpp
new file mode 100644
index 0000000000..0924581e38
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_map.cpp
@@ -0,0 +1,611 @@
+/* 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 "sherlock/scalpel/scalpel_map.h"
+#include "sherlock/events.h"
+#include "sherlock/people.h"
+#include "sherlock/screen.h"
+#include "sherlock/sherlock.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+MapPaths::MapPaths() {
+	_numLocations = 0;
+}
+
+void MapPaths::load(int numLocations, Common::SeekableReadStream &s) {
+	_numLocations = numLocations;
+	_paths.resize(_numLocations * _numLocations);
+
+	for (int idx = 0; idx < (numLocations * numLocations); ++idx) {
+		Common::Array<byte> &path = _paths[idx];
+		int v;
+
+		do {
+			v = s.readByte();
+			path.push_back(v);
+		} while (v && v < 254);
+	}
+}
+
+const byte *MapPaths::getPath(int srcLocation, int destLocation) {
+	return &_paths[srcLocation * _numLocations + destLocation][0];
+}
+
+/*----------------------------------------------------------------*/
+
+ScalpelMap::ScalpelMap(SherlockEngine *vm): Map(vm), _topLine(g_system->getWidth(), 12) {
+	_mapCursors = nullptr;
+	_shapes = nullptr;
+	_iconShapes = nullptr;
+	_point = 0;
+	_placesShown = false;
+	_cursorIndex = -1;
+	_drawMap = false;
+	_overPos = Point32(130 * FIXED_INT_MULTIPLIER, 126 * FIXED_INT_MULTIPLIER);
+	_frameChangeFlag = false;
+
+	// Initialise the initial walk sequence set
+	_walkSequences.resize(MAX_HOLMES_SEQUENCE);
+	for (int idx = 0; idx < MAX_HOLMES_SEQUENCE; ++idx) {
+		_walkSequences[idx]._sequences.resize(MAX_FRAME);
+		Common::fill(&_walkSequences[idx]._sequences[0], &_walkSequences[idx]._sequences[0] + MAX_FRAME, 0);
+	}
+
+	if (!_vm->isDemo())
+		loadData();
+}
+
+void ScalpelMap::loadPoints(int count, const int *xList, const int *yList, const int *transList) {
+	for (int idx = 0; idx < count; ++idx, ++xList, ++yList, ++transList) {
+		_points.push_back(MapEntry(*xList, *yList, *transList));
+	}
+}
+
+void ScalpelMap::loadSequences(int count, const byte *seq) {
+	for (int idx = 0; idx < count; ++idx, seq += MAX_FRAME)
+		Common::copy(seq, seq + MAX_FRAME, &_walkSequences[idx]._sequences[0]);
+}
+
+void ScalpelMap::loadData() {
+	// Load the list of location names
+	Common::SeekableReadStream *txtStream = _vm->_res->load("chess.txt");
+
+	int streamSize = txtStream->size();
+	while (txtStream->pos() < streamSize) {
+		Common::String line;
+		char c;
+		while ((c = txtStream->readByte()) != '\0')
+			line += c;
+
+		// WORKAROUND: Special fixes for faulty translations
+		// Was obviously not done in the original interpreter
+		if (_vm->getLanguage() == Common::ES_ESP) {
+			// Spanish version
+			if (line == " Alley") {
+				// The "Alley" location was not translated, we do this now
+				// see bug #6931
+				line = " Callejon";
+			} else if (line == " Alamacen") {
+				// "Warehouse" location has a typo, we fix it
+				// see bug #6931
+				line = " Almacen";
+			}
+		}
+
+		_locationNames.push_back(line);
+	}
+
+	delete txtStream;
+
+	// Load the path data
+	Common::SeekableReadStream *pathStream = _vm->_res->load("chess.pth");
+
+	// Get routes between different locations on the map
+	_paths.load(31, *pathStream);
+
+	// Load in the co-ordinates that the paths refer to
+	_pathPoints.resize(208);
+	for (uint idx = 0; idx < _pathPoints.size(); ++idx) {
+		_pathPoints[idx].x = pathStream->readSint16LE();
+		_pathPoints[idx].y = pathStream->readSint16LE();
+	}
+
+	delete pathStream;
+}
+
+int ScalpelMap::show() {
+	Debugger &debugger = *_vm->_debugger;
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Screen &screen = *_vm->_screen;
+	bool changed = false, exitFlag = false;
+	_active = true;
+
+	// Set font and custom cursor for the map
+	int oldFont = screen.fontNumber();
+	screen.setFont(0);
+
+	// Initial screen clear
+	screen._backBuffer1.clear();
+	screen.clear();
+
+	// Load the entire map
+	ImageFile *bigMap = NULL;
+	if (!IS_3DO) {
+		// PC
+		bigMap = new ImageFile("bigmap.vgs");
+		screen.setPalette(bigMap->_palette);
+	} else {
+		// 3DO
+		bigMap = new ImageFile3DO("overland.cel", kImageFile3DOType_Cel);
+	}
+
+	// Load need sprites
+	setupSprites();
+
+	if (!IS_3DO) {
+		screen._backBuffer1.blitFrom((*bigMap)[0], Common::Point(-_bigPos.x, -_bigPos.y));
+		screen._backBuffer1.blitFrom((*bigMap)[1], Common::Point(-_bigPos.x, SHERLOCK_SCREEN_HEIGHT - _bigPos.y));
+		screen._backBuffer1.blitFrom((*bigMap)[2], Common::Point(SHERLOCK_SCREEN_WIDTH - _bigPos.x, -_bigPos.y));
+		screen._backBuffer1.blitFrom((*bigMap)[3], Common::Point(SHERLOCK_SCREEN_WIDTH - _bigPos.x, SHERLOCK_SCREEN_HEIGHT - _bigPos.y));
+	} else {
+		screen._backBuffer1.blitFrom((*bigMap)[0], Common::Point(-_bigPos.x, -_bigPos.y));
+		screen.blitFrom((*bigMap)[0], Common::Point(-_bigPos.x, -_bigPos.y));
+	}
+
+	_drawMap = true;
+	_charPoint = -1;
+	_point = -1;
+	people[HOLMES]._position = _lDrawnPos = _overPos;
+
+	// Show place icons
+	showPlaces();
+	saveTopLine();
+	_placesShown = true;
+
+	// Keep looping until either a location is picked, or the game is ended
+	while (!_vm->shouldQuit() && !exitFlag) {
+		events.pollEventsAndWait();
+		events.setButtonState();
+
+		if (debugger._showAllLocations == LOC_REFRESH) {
+			showPlaces();
+			screen.slamArea(screen._currentScroll.x, screen._currentScroll.y, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_WIDTH);
+		}
+
+		// Keyboard handling
+		if (events.kbHit()) {
+			Common::KeyState keyState = events.getKey();
+
+			if (keyState.keycode == Common::KEYCODE_RETURN || keyState.keycode == Common::KEYCODE_SPACE) {
+				// Both space and enter simulate a mouse release
+				events._pressed = false;
+				events._released = true;
+				events._oldButtons = 0;
+			}
+		}
+
+		// Ignore scrolling attempts until the screen is drawn
+		if (!_drawMap) {
+			Common::Point pt = events.mousePos();
+
+			// Check for vertical map scrolling
+			if ((pt.y > (SHERLOCK_SCREEN_HEIGHT - 10) && _bigPos.y < 200) || (pt.y < 10 && _bigPos.y > 0)) {
+				if (pt.y > (SHERLOCK_SCREEN_HEIGHT - 10))
+					_bigPos.y += 10;
+				else
+					_bigPos.y -= 10;
+
+				changed = true;
+			}
+
+			// Check for horizontal map scrolling
+			if ((pt.x > (SHERLOCK_SCREEN_WIDTH - 10) && _bigPos.x < 315) || (pt.x < 10 && _bigPos.x > 0)) {
+				if (pt.x > (SHERLOCK_SCREEN_WIDTH - 10))
+					_bigPos.x += 15;
+				else
+					_bigPos.x -= 15;
+
+				changed = true;
+			}
+		}
+
+		if (changed) {
+			// Map has scrolled, so redraw new map view
+			changed = false;
+
+			if (!IS_3DO) {
+				screen._backBuffer1.blitFrom((*bigMap)[0], Common::Point(-_bigPos.x, -_bigPos.y));
+				screen._backBuffer1.blitFrom((*bigMap)[1], Common::Point(-_bigPos.x, SHERLOCK_SCREEN_HEIGHT - _bigPos.y));
+				screen._backBuffer1.blitFrom((*bigMap)[2], Common::Point(SHERLOCK_SCREEN_WIDTH - _bigPos.x, -_bigPos.y));
+				screen._backBuffer1.blitFrom((*bigMap)[3], Common::Point(SHERLOCK_SCREEN_WIDTH - _bigPos.x, SHERLOCK_SCREEN_HEIGHT - _bigPos.y));
+			} else {
+				screen._backBuffer1.blitFrom((*bigMap)[0], Common::Point(-_bigPos.x, -_bigPos.y));
+			}
+
+			showPlaces();
+			_placesShown = false;
+
+			saveTopLine();
+			_savedPos.x = -1;
+			updateMap(true);
+		} else if (!_drawMap) {
+			if (!_placesShown) {
+				showPlaces();
+				_placesShown = true;
+			}
+
+			if (_cursorIndex == 0) {
+				Common::Point pt = events.mousePos();
+				highlightIcon(Common::Point(pt.x - 4 + _bigPos.x, pt.y + _bigPos.y));
+			}
+			updateMap(false);
+		}
+
+		if ((events._released || events._rightReleased) && _point != -1) {
+			if (people[HOLMES]._walkCount == 0) {
+				people[HOLMES]._walkDest = _points[_point] + Common::Point(4, 9);
+				_charPoint = _point;
+
+				// Start walking to selected location
+				walkTheStreets();
+
+				// Show wait cursor
+				_cursorIndex = 1;
+				events.setCursor((*_mapCursors)[_cursorIndex]._frame);
+			}
+		}
+
+		// Check if a scene has beeen selected and we've finished "moving" to it
+		if (people[HOLMES]._walkCount == 0) {
+			if (_charPoint >= 1 && _charPoint < (int)_points.size())
+				exitFlag = true;
+		}
+
+		if (_drawMap) {
+			_drawMap = false;
+
+			if (screen._fadeStyle)
+				screen.randomTransition();
+			else
+				screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+		}
+
+		// Wait for a frame
+		events.wait(1);
+	}
+
+	freeSprites();
+	_overPos = people[HOLMES]._position;
+
+	// Reset font
+	screen.setFont(oldFont);
+
+	// Free map graphic
+	delete bigMap;
+
+	_active = false;
+	return _charPoint;
+}
+
+void ScalpelMap::setupSprites() {
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	_savedPos.x = -1;
+
+	if (!IS_3DO) {
+		// PC
+		_mapCursors = new ImageFile("omouse.vgs");
+		_shapes = new ImageFile("mapicon.vgs");
+		_iconShapes = new ImageFile("overicon.vgs");
+	} else {
+		// 3DO
+		_mapCursors = new ImageFile3DO("omouse.vgs", kImageFile3DOType_RoomFormat);
+		_shapes = new ImageFile3DO("mapicon.vgs", kImageFile3DOType_RoomFormat);
+		_iconShapes = new ImageFile3DO("overicon.vgs", kImageFile3DOType_RoomFormat);
+	}
+
+	_cursorIndex = 0;
+	events.setCursor((*_mapCursors)[_cursorIndex]._frame);
+
+	_iconSave.create((*_shapes)[4]._width, (*_shapes)[4]._height);
+	Person &p = people[HOLMES];
+	p._description = " ";
+	p._type = CHARACTER;
+	p._position = Common::Point(12400, 5000);
+	p._sequenceNumber = 0;
+	p._images = _shapes;
+	p._imageFrame = nullptr;
+	p._frameNumber = 0;
+	p._delta = Common::Point(0, 0);
+	p._oldSize = Common::Point(0, 0);
+	p._oldSize = Common::Point(0, 0);
+	p._misc = 0;
+	p._walkCount = 0;
+	p._allow = 0;
+	p._noShapeSize = Common::Point(0, 0);
+	p._goto = Common::Point(28000, 15000);
+	p._status = 0;
+	p._walkSequences = _walkSequences;
+	p.setImageFrame();
+	scene._bgShapes.clear();
+}
+
+void ScalpelMap::freeSprites() {
+	delete _mapCursors;
+	delete _shapes;
+	delete _iconShapes;
+	_iconSave.free();
+}
+
+void ScalpelMap::showPlaces() {
+	Debugger &debugger = *_vm->_debugger;
+	Screen &screen = *_vm->_screen;
+
+	for (uint idx = 0; idx < _points.size(); ++idx) {
+		const MapEntry &pt = _points[idx];
+
+		if (pt.x != 0 && pt.y != 0) {
+			if (debugger._showAllLocations != LOC_DISABLED)
+				_vm->setFlagsDirect(idx);
+
+			if (pt.x >= _bigPos.x && (pt.x - _bigPos.x) < SHERLOCK_SCREEN_WIDTH
+					&& pt.y >= _bigPos.y && (pt.y - _bigPos.y) < SHERLOCK_SCREEN_HEIGHT) {
+				if (_vm->readFlags(idx)) {
+					screen._backBuffer1.transBlitFrom((*_iconShapes)[pt._translate],
+						Common::Point(pt.x - _bigPos.x - 6, pt.y - _bigPos.y - 12));
+				}
+			}
+		}
+	}
+
+	if (debugger._showAllLocations == LOC_REFRESH)
+		debugger._showAllLocations = LOC_ALL;
+}
+
+void ScalpelMap::saveTopLine() {
+	_topLine.blitFrom(_vm->_screen->_backBuffer1, Common::Point(0, 0), Common::Rect(0, 0, SHERLOCK_SCREEN_WIDTH, 12));
+}
+
+void ScalpelMap::eraseTopLine() {
+	Screen &screen = *_vm->_screen;
+	screen._backBuffer1.blitFrom(_topLine, Common::Point(0, 0));
+	screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, _topLine.h());
+}
+
+void ScalpelMap::showPlaceName(int idx, bool highlighted) {
+	People &people = *_vm->_people;
+	Screen &screen = *_vm->_screen;
+
+	Common::String name = _locationNames[idx];
+	int width = screen.stringWidth(name);
+
+	if (!_cursorIndex) {
+		saveIcon(people[HOLMES]._imageFrame, _lDrawnPos);
+
+		bool flipped = people[HOLMES]._sequenceNumber == MAP_DOWNLEFT || people[HOLMES]._sequenceNumber == MAP_LEFT
+			|| people[HOLMES]._sequenceNumber == MAP_UPLEFT;
+		screen._backBuffer1.transBlitFrom(*people[HOLMES]._imageFrame, _lDrawnPos, flipped);
+	}
+
+	if (highlighted) {
+		int xp = (SHERLOCK_SCREEN_WIDTH - screen.stringWidth(name)) / 2;
+		screen.gPrint(Common::Point(xp + 2, 2), BLACK, "%s", name.c_str());
+		screen.gPrint(Common::Point(xp + 1, 1), BLACK, "%s", name.c_str());
+		screen.gPrint(Common::Point(xp, 0), 12, "%s", name.c_str());
+
+		screen.slamArea(xp, 0, width + 2, 15);
+	}
+}
+
+void ScalpelMap::updateMap(bool flushScreen) {
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Screen &screen = *_vm->_screen;
+	Common::Point osPos = _savedPos;
+	Common::Point osSize = _savedSize;
+	Common::Point hPos;
+
+	if (_cursorIndex >= 1) {
+		if (++_cursorIndex > (1 + 8))
+			_cursorIndex = 1;
+
+		events.setCursor((*_mapCursors)[(_cursorIndex + 1) / 2]._frame);
+	}
+
+	if (!_drawMap && !flushScreen)
+		restoreIcon();
+	else
+		_savedPos.x = -1;
+
+	people[HOLMES].adjustSprite();
+
+	_lDrawnPos.x = hPos.x = people[HOLMES]._position.x / FIXED_INT_MULTIPLIER - _bigPos.x;
+	_lDrawnPos.y = hPos.y = people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES].frameHeight() - _bigPos.y;
+
+	// Draw the person icon
+	saveIcon(people[HOLMES]._imageFrame, hPos);
+	if (people[HOLMES]._sequenceNumber == MAP_DOWNLEFT || people[HOLMES]._sequenceNumber == MAP_LEFT
+			|| people[HOLMES]._sequenceNumber == MAP_UPLEFT)
+		screen._backBuffer1.transBlitFrom(*people[HOLMES]._imageFrame, hPos, true);
+	else
+		screen._backBuffer1.transBlitFrom(*people[HOLMES]._imageFrame, hPos, false);
+
+	if (flushScreen) {
+		screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+	} else if (!_drawMap) {
+		if (hPos.x > 0 && hPos.y >= 0 && hPos.x < SHERLOCK_SCREEN_WIDTH && hPos.y < SHERLOCK_SCREEN_HEIGHT)
+			screen.flushImage(people[HOLMES]._imageFrame, Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER - _bigPos.x,
+			people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES].frameHeight() - _bigPos.y),
+			&people[HOLMES]._oldPosition.x, &people[HOLMES]._oldPosition.y, &people[HOLMES]._oldSize.x, &people[HOLMES]._oldSize.y);
+
+		if (osPos.x != -1)
+			screen.slamArea(osPos.x, osPos.y, osSize.x, osSize.y);
+	}
+}
+
+void ScalpelMap::walkTheStreets() {
+	People &people = *_vm->_people;
+	Common::Array<Common::Point> tempPath;
+
+	// Get indexes into the path lists for the start and destination scenes
+	int start = _points[_oldCharPoint]._translate;
+	int dest = _points[_charPoint]._translate;
+
+	// Get pointer to start of path
+	const byte *path = _paths.getPath(start, dest);
+
+	// Add in destination position
+	people[HOLMES]._walkTo.clear();
+	Common::Point destPos = people[HOLMES]._walkDest;
+
+	// Check for any intermediate points between the two locations
+	if (path[0] || _charPoint > 50 || _oldCharPoint > 50) {
+		people[HOLMES]._sequenceNumber = -1;
+
+		if (_charPoint == 51 || _oldCharPoint == 51) {
+			people[HOLMES].setWalking();
+		} else {
+			bool reversePath = false;
+
+			// Check for moving the path backwards or forwards
+			if (path[0] == 255) {
+				reversePath = true;
+				SWAP(start, dest);
+				path = _paths.getPath(start, dest);
+			}
+
+			do {
+				int idx = *path++;
+				tempPath.push_back(_pathPoints[idx - 1] + Common::Point(4, 4));
+			} while (*path != 254);
+
+			// Load up the path to use
+			people[HOLMES]._walkTo.clear();
+
+			if (reversePath) {
+				for (int idx = (int)tempPath.size() - 1; idx >= 0; --idx)
+					people[HOLMES]._walkTo.push(tempPath[idx]);
+			} else {
+				for (int idx = 0; idx < (int)tempPath.size(); ++idx)
+					people[HOLMES]._walkTo.push(tempPath[idx]);
+			}
+
+			people[HOLMES]._walkDest = people[HOLMES]._walkTo.pop() + Common::Point(12, 6);
+			people[HOLMES].setWalking();
+		}
+	} else {
+		people[HOLMES]._walkCount = 0;
+	}
+
+	// Store the final destination icon position
+	people[HOLMES]._walkTo.push(destPos);
+}
+
+void ScalpelMap::saveIcon(ImageFrame *src, const Common::Point &pt) {
+	Screen &screen = *_vm->_screen;
+	Common::Point size(src->_width, src->_height);
+	Common::Point pos = pt;
+
+	if (pos.x < 0) {
+		size.x += pos.x;
+		pos.x = 0;
+	}
+
+	if (pos.y < 0) {
+		size.y += pos.y;
+		pos.y = 0;
+	}
+
+	if ((pos.x + size.x) > SHERLOCK_SCREEN_WIDTH)
+		size.x -= (pos.x + size.x) - SHERLOCK_SCREEN_WIDTH;
+
+	if ((pos.y + size.y) > SHERLOCK_SCREEN_HEIGHT)
+		size.y -= (pos.y + size.y) - SHERLOCK_SCREEN_HEIGHT;
+
+	if (size.x < 1 || size.y < 1 || pos.x >= SHERLOCK_SCREEN_WIDTH || pos.y >= SHERLOCK_SCREEN_HEIGHT || _drawMap) {
+		// Flag as the area not needing to be saved
+		_savedPos.x = -1;
+		return;
+	}
+
+	assert(size.x <= _iconSave.w() && size.y <= _iconSave.h());
+	_iconSave.blitFrom(screen._backBuffer1, Common::Point(0, 0),
+		Common::Rect(pos.x, pos.y, pos.x + size.x, pos.y + size.y));
+	_savedPos = pos;
+	_savedSize = size;
+}
+
+void ScalpelMap::restoreIcon() {
+	Screen &screen = *_vm->_screen;
+
+	if (_savedPos.x >= 0 && _savedPos.y >= 0 && _savedPos.x <= SHERLOCK_SCREEN_WIDTH
+			&& _savedPos.y < SHERLOCK_SCREEN_HEIGHT)
+		screen._backBuffer1.blitFrom(_iconSave, _savedPos, Common::Rect(0, 0, _savedSize.x, _savedSize.y));
+}
+
+void ScalpelMap::highlightIcon(const Common::Point &pt) {
+	int oldPoint = _point;
+
+	// Iterate through the icon list
+	bool done = false;
+	for (int idx = 0; idx < (int)_points.size(); ++idx) {
+		const MapEntry &entry = _points[idx];
+
+		// Check whether the mouse is over a given icon
+		if (entry.x != 0 && entry.y != 0) {
+			if (Common::Rect(entry.x - 8, entry.y - 8, entry.x + 9, entry.y + 9).contains(pt)) {
+				done = true;
+
+				if (_point != idx && _vm->readFlags(idx)) {
+					// Changed to a new valid (visible) location
+					eraseTopLine();
+					showPlaceName(idx, true);
+					_point = idx;
+				}
+			}
+		}
+	}
+
+	if (!done) {
+		// No icon was highlighted
+		if (_point != -1) {
+			// No longer highlighting previously highlighted icon, so erase it
+			showPlaceName(_point, false);
+			eraseTopLine();
+		}
+
+		_point = -1;
+	} else if (oldPoint != -1 && oldPoint != _point) {
+		showPlaceName(oldPoint, false);
+		eraseTopLine();
+	}
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_map.h b/engines/sherlock/scalpel/scalpel_map.h
new file mode 100644
index 0000000000..b17677725c
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_map.h
@@ -0,0 +1,173 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_SCALPEL_MAP_H
+#define SHERLOCK_SCALPEL_MAP_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/rect.h"
+#include "common/str-array.h"
+#include "sherlock/surface.h"
+#include "sherlock/map.h"
+#include "sherlock/resources.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Scalpel {
+
+
+struct MapEntry : Common::Point {
+	int _translate;
+
+	MapEntry() : Common::Point(), _translate(-1) {}
+
+	MapEntry(int posX, int posY, int translate) : Common::Point(posX, posY), _translate(translate) {}
+};
+
+class MapPaths {
+private:
+	int _numLocations;
+	Common::Array< Common::Array<byte> > _paths;
+
+public:
+	MapPaths();
+
+	/**
+	 * Load the data for the paths between locations on the map
+	 */
+	void load(int numLocations, Common::SeekableReadStream &s);
+
+	/**
+	 * Get the path between two locations on the map
+	 */
+	const byte *getPath(int srcLocation, int destLocation);
+};
+
+class ScalpelMap: public Map {
+private:
+	Common::Array<MapEntry> _points;	// Map locations for each scene
+	Common::StringArray _locationNames;
+	MapPaths _paths;
+	Common::Array<Common::Point> _pathPoints;
+	Common::Point _savedPos;
+	Common::Point _savedSize;
+	Surface _topLine;
+	ImageFile *_mapCursors;
+	ImageFile *_shapes;
+	ImageFile *_iconShapes;
+	WalkSequences _walkSequences;
+	Point32 _lDrawnPos;
+	int _point;
+	bool _placesShown;
+	int _cursorIndex;
+	bool _drawMap;
+	Surface _iconSave;
+protected:
+	/**
+	 * Load data  needed for the map
+	 */
+	void loadData();
+
+	/**
+	 * Load and initialize all the sprites that are needed for the map display
+	 */
+	void setupSprites();
+
+	/**
+	 * Free the sprites and data used by the map
+	 */
+	void freeSprites();
+
+	/**
+	 * Draws an icon for every place that's currently known
+	 */
+	void showPlaces();
+
+	/**
+	 * Makes a copy of the top rows of the screen that are used to display location names
+	 */
+	void saveTopLine();
+
+	/**
+	 * Erases anything shown in the top line by restoring the previously saved original map background
+	 */
+	void eraseTopLine();
+
+	/**
+	 * Prints the name of the specified icon
+	 */
+	void showPlaceName(int idx, bool highlighted);
+
+	/**
+	 * Update all on-screen sprites to account for any scrolling of the map
+	 */
+	void updateMap(bool flushScreen);
+
+	/**
+	 * Handle moving icon for player from their previous location on the map to a destination location
+	 */
+	void walkTheStreets();
+
+	/**
+	 * Save the area under the player's icon
+	 */
+	void saveIcon(ImageFrame *src, const Common::Point &pt);
+
+	/**
+	 * Restore the area under the player's icon
+	 */
+	void restoreIcon();
+
+	/**
+	 * Handles highlighting map icons, showing their names
+	 */
+	void highlightIcon(const Common::Point &pt);
+public:
+	ScalpelMap(SherlockEngine *vm);
+	virtual ~ScalpelMap() {}
+
+	const MapEntry &operator[](int idx) { return _points[idx]; }
+
+	/**
+	 * Loads the list of points for locations on the map for each scene
+	 */
+	void loadPoints(int count, const int *xList, const int *yList, const int *transList);
+
+	/**
+	 * Load the sequence data for player icon animations
+	 */
+	void loadSequences(int count, const byte *seq);
+
+	/**
+	 * Show the map
+	 */
+	virtual int show();
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_people.cpp b/engines/sherlock/scalpel/scalpel_people.cpp
new file mode 100644
index 0000000000..924095cd50
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_people.cpp
@@ -0,0 +1,567 @@
+/* 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 "sherlock/scalpel/scalpel_people.h"
+#include "sherlock/scalpel/scalpel_map.h"
+#include "sherlock/sherlock.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+// Walk speeds
+#define MWALK_SPEED 2
+#define XWALK_SPEED 4
+#define YWALK_SPEED 1
+
+/*----------------------------------------------------------------*/
+
+void ScalpelPerson::adjustSprite() {
+	Map &map = *_vm->_map;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Talk &talk = *_vm->_talk;
+
+	if (_type == INVALID || (_type == CHARACTER && scene._animating))
+		return;
+
+	if (!talk._talkCounter && _type == CHARACTER && _walkCount) {
+		// Handle active movement for the sprite
+		_position += _delta;
+		--_walkCount;
+
+		if (!_walkCount) {
+			// If there any points left for the character to walk to along the
+			// route to a destination, then move to the next point
+			if (!people[HOLMES]._walkTo.empty()) {
+				_walkDest = people[HOLMES]._walkTo.pop();
+				setWalking();
+			} else {
+				gotoStand();
+			}
+		}
+	}
+
+	if (_type == CHARACTER && !map._active) {
+		if ((_position.y / FIXED_INT_MULTIPLIER) > LOWER_LIMIT) {
+			_position.y = LOWER_LIMIT * FIXED_INT_MULTIPLIER;
+			gotoStand();
+		}
+
+		if ((_position.y / FIXED_INT_MULTIPLIER) < UPPER_LIMIT) {
+			_position.y = UPPER_LIMIT * FIXED_INT_MULTIPLIER;
+			gotoStand();
+		}
+
+		if ((_position.x / FIXED_INT_MULTIPLIER) < LEFT_LIMIT) {
+			_position.x = LEFT_LIMIT * FIXED_INT_MULTIPLIER;
+			gotoStand();
+		}
+
+		if ((_position.x / FIXED_INT_MULTIPLIER) > RIGHT_LIMIT) {
+			_position.x = RIGHT_LIMIT * FIXED_INT_MULTIPLIER;
+			gotoStand();
+		}
+	} else if (!map._active) {
+		_position.y = CLIP((int)_position.y, (int)UPPER_LIMIT, (int)LOWER_LIMIT);
+		_position.x = CLIP((int)_position.x, (int)LEFT_LIMIT, (int)RIGHT_LIMIT);
+	}
+
+	if (!map._active || (map._frameChangeFlag = !map._frameChangeFlag))
+		++_frameNumber;
+
+	if (_frameNumber >= (int)_walkSequences[_sequenceNumber]._sequences.size() ||
+			_walkSequences[_sequenceNumber][_frameNumber] == 0) {
+		switch (_sequenceNumber) {
+		case STOP_UP:
+		case STOP_DOWN:
+		case STOP_LEFT:
+		case STOP_RIGHT:
+		case STOP_UPRIGHT:
+		case STOP_UPLEFT:
+		case STOP_DOWNRIGHT:
+		case STOP_DOWNLEFT:
+			// We're in a stop sequence, so reset back to the last frame, so
+			// the character is shown as standing still
+			--_frameNumber;
+			break;
+
+		default:
+			// Move 1 past the first frame - we need to compensate, since we
+			// already passed the frame increment
+			_frameNumber = 1;
+			break;
+		}
+	}
+
+	// Update the _imageFrame to point to the new frame's image
+	setImageFrame();
+
+	// Check to see if character has entered an exit zone
+	if (!_walkCount && scene._walkedInScene && scene._goToScene == -1) {
+		Common::Rect charRect(_position.x / FIXED_INT_MULTIPLIER - 5, _position.y / FIXED_INT_MULTIPLIER - 2,
+			_position.x / FIXED_INT_MULTIPLIER + 5, _position.y / FIXED_INT_MULTIPLIER + 2);
+		Exit *exit = scene.checkForExit(charRect);
+
+		if (exit) {
+			scene._goToScene = exit->_scene;
+
+			if (exit->_newPosition.x != 0) {
+				people._savedPos = exit->_newPosition;
+
+				if (people._savedPos._facing > 100 && people._savedPos.x < 1)
+					people._savedPos.x = 100;
+			}
+		}
+	}
+}
+
+void ScalpelPerson::gotoStand() {
+	ScalpelMap &map = *(ScalpelMap *)_vm->_map;
+	People &people = *_vm->_people;
+	_walkTo.clear();
+	_walkCount = 0;
+
+	switch (_sequenceNumber) {
+	case Scalpel::WALK_UP:
+		_sequenceNumber = STOP_UP;
+		break;
+	case WALK_DOWN:
+		_sequenceNumber = STOP_DOWN;
+		break;
+	case TALK_LEFT:
+	case WALK_LEFT:
+		_sequenceNumber = STOP_LEFT;
+		break;
+	case TALK_RIGHT:
+	case WALK_RIGHT:
+		_sequenceNumber = STOP_RIGHT;
+		break;
+	case WALK_UPRIGHT:
+		_sequenceNumber = STOP_UPRIGHT;
+		break;
+	case WALK_UPLEFT:
+		_sequenceNumber = STOP_UPLEFT;
+		break;
+	case WALK_DOWNRIGHT:
+		_sequenceNumber = STOP_DOWNRIGHT;
+		break;
+	case WALK_DOWNLEFT:
+		_sequenceNumber = STOP_DOWNLEFT;
+		break;
+	default:
+		break;
+	}
+
+	// Only restart frame at 0 if the sequence number has changed
+	if (_oldWalkSequence != -1 || _sequenceNumber == Scalpel::STOP_UP)
+		_frameNumber = 0;
+
+	if (map._active) {
+		_sequenceNumber = 0;
+		people[HOLMES]._position.x = (map[map._charPoint].x - 6) * FIXED_INT_MULTIPLIER;
+		people[HOLMES]._position.y = (map[map._charPoint].y + 10) * FIXED_INT_MULTIPLIER;
+	}
+
+	_oldWalkSequence = -1;
+	people._allowWalkAbort = true;
+}
+
+void ScalpelPerson::setWalking() {
+	Map &map = *_vm->_map;
+	Scene &scene = *_vm->_scene;
+	int oldDirection, oldFrame;
+	Common::Point speed, delta;
+
+	// Flag that player has now walked in the scene
+	scene._walkedInScene = true;
+
+	// Stop any previous walking, since a new dest is being set
+	_walkCount = 0;
+	oldDirection = _sequenceNumber;
+	oldFrame = _frameNumber;
+
+	// Set speed to use horizontal and vertical movement
+	if (map._active) {
+		speed = Common::Point(MWALK_SPEED, MWALK_SPEED);
+	} else {
+		speed = Common::Point(XWALK_SPEED, YWALK_SPEED);
+	}
+
+	// If the player is already close to the given destination that no
+	// walking is needed, move to the next straight line segment in the
+	// overall walking route, if there is one
+	for (;;) {
+		// Since we want the player to be centered on the destination they
+		// clicked, but characters draw positions start at their left, move
+		// the destination half the character width to draw him centered
+		int temp;
+		if (_walkDest.x >= (temp = _imageFrame->_frame.w / 2))
+			_walkDest.x -= temp;
+
+		delta = Common::Point(
+			ABS(_position.x / FIXED_INT_MULTIPLIER - _walkDest.x),
+			ABS(_position.y / FIXED_INT_MULTIPLIER - _walkDest.y)
+		);
+
+		// If we're ready to move a sufficient distance, that's it. Otherwise,
+		// move onto the next portion of the walk path, if there is one
+		if ((delta.x > 3 || delta.y > 0) || _walkTo.empty())
+			break;
+
+		// Pop next walk segment off the walk route stack
+		_walkDest = _walkTo.pop();
+	}
+
+	// If a sufficient move is being done, then start the move
+	if (delta.x > 3 || delta.y) {
+		// See whether the major movement is horizontal or vertical
+		if (delta.x >= delta.y) {
+			// Set the initial frame sequence for the left and right, as well
+			// as setting the delta x depending on direction
+			if (_walkDest.x < (_position.x / FIXED_INT_MULTIPLIER)) {
+				_sequenceNumber = (map._active ? (int)MAP_LEFT : (int)WALK_LEFT);
+				_delta.x = speed.x * -FIXED_INT_MULTIPLIER;
+			} else {
+				_sequenceNumber = (map._active ? (int)MAP_RIGHT : (int)WALK_RIGHT);
+				_delta.x = speed.x * FIXED_INT_MULTIPLIER;
+			}
+
+			// See if the x delta is too small to be divided by the speed, since
+			// this would cause a divide by zero error
+			if (delta.x >= speed.x) {
+				// Det the delta y
+				_delta.y = (delta.y * FIXED_INT_MULTIPLIER) / (delta.x / speed.x);
+				if (_walkDest.y < (_position.y / FIXED_INT_MULTIPLIER))
+					_delta.y = -_delta.y;
+
+				// Set how many times we should add the delta to the player's position
+				_walkCount = delta.x / speed.x;
+			} else {
+				// The delta x was less than the speed (ie. we're really close to
+				// the destination). So set delta to 0 so the player won't move
+				_delta = Point32(0, 0);
+				_position = Point32(_walkDest.x * FIXED_INT_MULTIPLIER, _walkDest.y * FIXED_INT_MULTIPLIER);
+
+				_walkCount = 1;
+			}
+
+			// See if the sequence needs to be changed for diagonal walking
+			if (_delta.y > 150) {
+				if (!map._active) {
+					switch (_sequenceNumber) {
+					case WALK_LEFT:
+						_sequenceNumber = WALK_DOWNLEFT;
+						break;
+					case WALK_RIGHT:
+						_sequenceNumber = WALK_DOWNRIGHT;
+						break;
+					}
+				}
+			} else if (_delta.y < -150) {
+				if (!map._active) {
+					switch (_sequenceNumber) {
+					case WALK_LEFT:
+						_sequenceNumber = WALK_UPLEFT;
+						break;
+					case WALK_RIGHT:
+						_sequenceNumber = WALK_UPRIGHT;
+						break;
+					}
+				}
+			}
+		} else {
+			// Major movement is vertical, so set the sequence for up and down,
+			// and set the delta Y depending on the direction
+			if (_walkDest.y < (_position.y / FIXED_INT_MULTIPLIER)) {
+				_sequenceNumber = WALK_UP;
+				_delta.y = speed.y * -FIXED_INT_MULTIPLIER;
+			} else {
+				_sequenceNumber = WALK_DOWN;
+				_delta.y = speed.y * FIXED_INT_MULTIPLIER;
+			}
+
+			// If we're on the overhead map, set the sequence so we keep moving
+			// in the same direction
+			if (map._active)
+				_sequenceNumber = (oldDirection == -1) ? MAP_RIGHT : oldDirection;
+
+			// Set the delta x
+			_delta.x = (delta.x * FIXED_INT_MULTIPLIER) / (delta.y / speed.y);
+			if (_walkDest.x < (_position.x / FIXED_INT_MULTIPLIER))
+				_delta.x = -_delta.x;
+
+			_walkCount = delta.y / speed.y;
+		}
+	}
+
+	// See if the new walk sequence is the same as the old. If it's a new one,
+	// we need to reset the frame number to zero so its animation starts at
+	// its beginning. Otherwise, if it's the same sequence, we can leave it
+	// as is, so it keeps the animation going at wherever it was up to
+	if (_sequenceNumber != _oldWalkSequence)
+		_frameNumber = 0;
+	_oldWalkSequence = _sequenceNumber;
+
+	if (!_walkCount)
+		gotoStand();
+
+	// If the sequence is the same as when we started, then Holmes was
+	// standing still and we're trying to re-stand him, so reset Holmes'
+	// rame to the old frame number from before it was reset to 0
+	if (_sequenceNumber == oldDirection)
+		_frameNumber = oldFrame;
+}
+
+void ScalpelPerson::walkToCoords(const Point32 &destPos, int destDir) {
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Talk &talk = *_vm->_talk;
+
+	CursorId oldCursor = events.getCursor();
+	events.setCursor(WAIT);
+
+	_walkDest = Common::Point(destPos.x / FIXED_INT_MULTIPLIER + 10, destPos.y / FIXED_INT_MULTIPLIER);
+	people._allowWalkAbort = true;
+	goAllTheWay();
+
+	// Keep calling doBgAnim until the walk is done
+	do {
+		events.pollEventsAndWait();
+		scene.doBgAnim();
+	} while (!_vm->shouldQuit() && _walkCount);
+
+	if (!talk._talkToAbort) {
+		// Put character exactly on destination position, and set direction
+		_position = destPos;
+		_sequenceNumber = destDir;
+		gotoStand();
+
+		// Draw Holmes facing the new direction
+		scene.doBgAnim();
+
+		if (!talk._talkToAbort)
+			events.setCursor(oldCursor);
+	}
+}
+
+Common::Point ScalpelPerson::getSourcePoint() const {
+	return Common::Point(_position.x / FIXED_INT_MULTIPLIER + frameWidth() / 2,
+		_position.y / FIXED_INT_MULTIPLIER);
+}
+
+void ScalpelPerson::synchronize(Serializer &s) {
+	if (_walkCount)
+		gotoStand();
+
+	s.syncAsSint32LE(_position.x);
+	s.syncAsSint32LE(_position.y);
+}
+
+/*----------------------------------------------------------------*/
+
+ScalpelPeople::ScalpelPeople(SherlockEngine *vm) : People(vm) {
+	_data.push_back(new ScalpelPerson());
+}
+
+void ScalpelPeople::setTalking(int speaker) {
+	Resources &res = *_vm->_res;
+
+	// If no speaker is specified, then we can exit immediately
+	if (speaker == -1)
+		return;
+
+	if (_portraitsOn) {
+		delete _talkPics;
+		Common::String filename = Common::String::format("%s.vgs", _characters[speaker]._portrait);
+		_talkPics = new ImageFile(filename);
+
+		// Load portrait sequences
+		Common::SeekableReadStream *stream = res.load("sequence.txt");
+		stream->seek(speaker * MAX_FRAME);
+
+		int idx = 0;
+		do {
+			_portrait._sequences[idx] = stream->readByte();
+			++idx;
+		} while (idx < 2 || _portrait._sequences[idx - 2] || _portrait._sequences[idx - 1]);
+
+		delete stream;
+
+		_portrait._maxFrames = idx;
+		_portrait._frameNumber = 0;
+		_portrait._sequenceNumber = 0;
+		_portrait._images = _talkPics;
+		_portrait._imageFrame = &(*_talkPics)[0];
+		_portrait._position = Common::Point(_portraitSide, 10);
+		_portrait._delta = Common::Point(0, 0);
+		_portrait._oldPosition = Common::Point(0, 0);
+		_portrait._goto = Common::Point(0, 0);
+		_portrait._flags = 5;
+		_portrait._status = 0;
+		_portrait._misc = 0;
+		_portrait._allow = 0;
+		_portrait._type = ACTIVE_BG_SHAPE;
+		_portrait._name = " ";
+		_portrait._description = " ";
+		_portrait._examine = " ";
+		_portrait._walkCount = 0;
+
+		if (_holmesFlip || _speakerFlip) {
+			_portrait._flags |= 2;
+
+			_holmesFlip = false;
+			_speakerFlip = false;
+		}
+
+		if (_portraitSide == 20)
+			_portraitSide = 220;
+		else
+			_portraitSide = 20;
+
+		_portraitLoaded = true;
+	}
+}
+
+void ScalpelPeople::synchronize(Serializer &s) {
+	(*this)[HOLMES].synchronize(s);
+	s.syncAsSint16LE(_holmesQuotient);
+	s.syncAsByte(_holmesOn);
+
+	if (s.isLoading()) {
+		_savedPos = _data[HOLMES]->_position;
+		_savedPos._facing = _data[HOLMES]->_sequenceNumber;
+	}
+}
+
+void ScalpelPeople::setTalkSequence(int speaker, int sequenceNum) {
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+
+	// If no speaker is specified, then nothing needs to be done
+	if (speaker == -1)
+		return;
+
+	if (speaker) {
+		int objNum = people.findSpeaker(speaker);
+		if (objNum != -1) {
+			Object &obj = scene._bgShapes[objNum];
+
+			if (obj._seqSize < MAX_TALK_SEQUENCES) {
+				warning("Tried to copy too many talk frames");
+			} else {
+				for (int idx = 0; idx < MAX_TALK_SEQUENCES; ++idx) {
+					obj._sequences[idx] = people._characters[speaker]._talkSequences[idx];
+					if (idx > 0 && !obj._sequences[idx] && !obj._sequences[idx - 1])
+						return;
+
+					obj._frameNumber = 0;
+					obj._sequenceNumber = 0;
+				}
+			}
+		}
+	}
+}
+
+bool ScalpelPeople::loadWalk() {
+	bool result = false;
+
+	if (_data[HOLMES]->_walkLoaded) {
+		return false;
+	} else {
+		if (!IS_3DO) {
+			_data[HOLMES]->_images = new ImageFile("walk.vgs");
+		} else {
+			// Load walk.anim on 3DO, which is a cel animation file
+			_data[HOLMES]->_images = new ImageFile3DO("walk.anim", kImageFile3DOType_CelAnimation);
+		}
+		_data[HOLMES]->setImageFrame();
+		_data[HOLMES]->_walkLoaded = true;
+
+		result = true;
+	}
+
+	_forceWalkReload = false;
+	return result;
+}
+
+const Common::Point ScalpelPeople::restrictToZone(int zoneId, const Common::Point &destPos) {
+	Scene &scene = *_vm->_scene;
+	Common::Point walkDest = destPos;
+
+	// The destination isn't in a zone
+	if (walkDest.x >= (SHERLOCK_SCREEN_WIDTH - 1))
+		walkDest.x = SHERLOCK_SCREEN_WIDTH - 2;
+
+	// Trace a line between the centroid of the found closest zone to
+	// the destination, to find the point at which the zone will be left
+	const Common::Rect &destRect = scene._zones[zoneId];
+	const Common::Point destCenter((destRect.left + destRect.right) / 2,
+		(destRect.top + destRect.bottom) / 2);
+	const Common::Point delta = walkDest - destCenter;
+	Point32 pt(destCenter.x * FIXED_INT_MULTIPLIER, destCenter.y * FIXED_INT_MULTIPLIER);
+
+	// Move along the line until the zone is left
+	do {
+		pt += delta;
+	} while (destRect.contains(pt.x / FIXED_INT_MULTIPLIER, pt.y / FIXED_INT_MULTIPLIER));
+
+	// Set the new walk destination to the last point that was in the
+	// zone just before it was left
+	return Common::Point((pt.x - delta.x * 2) / FIXED_INT_MULTIPLIER,
+		(pt.y - delta.y * 2) / FIXED_INT_MULTIPLIER);
+}
+
+void ScalpelPeople::setListenSequence(int speaker, int sequenceNum) {
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+
+	// Don't bother doing anything if no specific speaker is specified
+	if (speaker == -1)
+		return;
+
+	if (speaker) {
+		int objNum = people.findSpeaker(speaker);
+		if (objNum != -1) {
+			Object &obj = scene._bgShapes[objNum];
+
+			if (obj._seqSize < MAX_TALK_SEQUENCES) {
+				warning("Tried to copy too few still frames");
+			} else {
+				for (uint idx = 0; idx < MAX_TALK_SEQUENCES; ++idx) {
+					obj._sequences[idx] = people._characters[speaker]._stillSequences[idx];
+					if (idx > 0 && !people._characters[speaker]._talkSequences[idx] &&
+						!people._characters[speaker]._talkSequences[idx - 1])
+						break;
+				}
+
+				obj._frameNumber = 0;
+				obj._seqTo = 0;
+			}
+		}
+	}
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_people.h b/engines/sherlock/scalpel/scalpel_people.h
new file mode 100644
index 0000000000..2ab6f5bc7d
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_people.h
@@ -0,0 +1,130 @@
+/* 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 SHERLOCK_SCALPEL_PEOPLE_H
+#define SHERLOCK_SCALPEL_PEOPLE_H
+
+#include "common/scummsys.h"
+#include "sherlock/people.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Scalpel {
+
+// Animation sequence identifiers for characters
+enum ScalpelSequences {
+	WALK_RIGHT = 0, WALK_DOWN = 1, WALK_LEFT = 2, WALK_UP = 3, STOP_LEFT = 4,
+	STOP_DOWN = 5, STOP_RIGHT = 6, STOP_UP = 7, WALK_UPRIGHT = 8,
+	WALK_DOWNRIGHT = 9, WALK_UPLEFT = 10, WALK_DOWNLEFT = 11,
+	STOP_UPRIGHT = 12, STOP_UPLEFT = 13, STOP_DOWNRIGHT = 14,
+	STOP_DOWNLEFT = 15, TALK_RIGHT = 6, TALK_LEFT = 4
+};
+
+class ScalpelPerson : public Person {
+public:
+	ScalpelPerson() : Person() {}
+	virtual ~ScalpelPerson() {}
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	virtual void synchronize(Serializer &s);
+
+	/**
+	* This adjusts the sprites position, as well as its animation sequence:
+	*/
+	virtual void adjustSprite();
+
+	/**
+	 * Bring a moving character to a standing position
+	 */
+	virtual void gotoStand();
+
+	/**
+	 * Set the variables for moving a character from one poisition to another
+	 * in a straight line
+	 */
+	virtual void setWalking();
+
+	/**
+	 * Walk to the co-ordinates passed, and then face the given direction
+	 */
+	virtual void walkToCoords(const Point32 &destPos, int destDir);
+
+	/**
+	 * Get the source position for a character potentially affected by scaling
+	 */
+	virtual Common::Point getSourcePoint() const;
+};
+
+class ScalpelPeople : public People {
+public:
+	ScalpelPeople(SherlockEngine *vm);
+	virtual ~ScalpelPeople() {}
+
+	ScalpelPerson &operator[](PeopleId id) { return *(ScalpelPerson  *)_data[id]; }
+	ScalpelPerson  &operator[](int idx) { return *(ScalpelPerson  *)_data[idx]; }
+
+	/**
+	 * Setup the data for an animating speaker portrait at the top of the screen
+	 */
+	void setTalking(int speaker);
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	virtual void synchronize(Serializer &s);
+
+	/**
+	 * Change the sequence of the scene background object associated with the specified speaker.
+	 */
+	virtual void setTalkSequence(int speaker, int sequenceNum = 1);
+
+	/**
+	 * Restrict passed point to zone using Sherlock's positioning rules
+	 */
+	virtual const Common::Point restrictToZone(int zoneId, const Common::Point &destPos);
+
+	/**
+	 * Load the walking images for Sherlock
+	 */
+	virtual bool loadWalk();
+
+	/**
+	 * If the specified speaker is a background object, it will set it so that it uses 
+	 * the Listen Sequence (specified by the sequence number). If the current sequence 
+	 * has an Allow Talk Code in it, the _gotoSeq field will be set so that the object 
+	 * begins listening as soon as it hits the Allow Talk Code. If there is no Abort Code, 
+	 * the Listen Sequence will begin immediately.
+	 * @param speaker		Who is speaking
+	 * @param sequenceNum	Which listen sequence to use
+	 */
+	virtual void setListenSequence(int speaker, int sequenceNum = 1);
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_saveload.cpp b/engines/sherlock/scalpel/scalpel_saveload.cpp
new file mode 100644
index 0000000000..01ba149813
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_saveload.cpp
@@ -0,0 +1,261 @@
+/* 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 "sherlock/scalpel/scalpel_saveload.h"
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "sherlock/scalpel/scalpel.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+const int ENV_POINTS[6][3] = {
+	{ 41, 80, 61 },		// Exit
+	{ 81, 120, 101 },	// Load
+	{ 121, 160, 141 },	// Save
+	{ 161, 200, 181 },	// Up
+	{ 201, 240, 221 },	// Down
+	{ 241, 280, 261 }	// Quit
+};
+
+/*----------------------------------------------------------------*/
+
+ScalpelSaveManager::ScalpelSaveManager(SherlockEngine *vm, const Common::String &target) : SaveManager(vm, target) {
+}
+
+void ScalpelSaveManager::drawInterface() {
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	UserInterface &ui = *_vm->_ui;
+
+	// Create a list of savegame slots
+	createSavegameList();
+
+	screen._backBuffer1.fillRect(Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH, CONTROLS_Y + 10), BORDER_COLOR);
+	screen._backBuffer1.fillRect(Common::Rect(0, CONTROLS_Y + 10, 2, SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+	screen._backBuffer1.fillRect(Common::Rect(318, CONTROLS_Y + 10, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+	screen._backBuffer1.fillRect(Common::Rect(0, 199, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+	screen._backBuffer1.fillRect(Common::Rect(2, CONTROLS_Y + 10, SHERLOCK_SCREEN_WIDTH - 2, SHERLOCK_SCREEN_HEIGHT - 2), INV_BACKGROUND);
+
+	screen.makeButton(Common::Rect(ENV_POINTS[0][0], CONTROLS_Y, ENV_POINTS[0][1], CONTROLS_Y + 10),
+		ENV_POINTS[0][2] - screen.stringWidth("Exit") / 2, "Exit");
+	screen.makeButton(Common::Rect(ENV_POINTS[1][0], CONTROLS_Y, ENV_POINTS[1][1], CONTROLS_Y + 10),
+		ENV_POINTS[1][2] - screen.stringWidth("Load") / 2, "Load");
+	screen.makeButton(Common::Rect(ENV_POINTS[2][0], CONTROLS_Y, ENV_POINTS[2][1], CONTROLS_Y + 10),
+		ENV_POINTS[2][2] - screen.stringWidth("Save") / 2, "Save");
+	screen.makeButton(Common::Rect(ENV_POINTS[3][0], CONTROLS_Y, ENV_POINTS[3][1], CONTROLS_Y + 10),
+		ENV_POINTS[3][2] - screen.stringWidth("Up") / 2, "Up");
+	screen.makeButton(Common::Rect(ENV_POINTS[4][0], CONTROLS_Y, ENV_POINTS[4][1], CONTROLS_Y + 10),
+		ENV_POINTS[4][2] - screen.stringWidth("Down") / 2, "Down");
+	screen.makeButton(Common::Rect(ENV_POINTS[5][0], CONTROLS_Y, ENV_POINTS[5][1], CONTROLS_Y + 10),
+		ENV_POINTS[5][2] - screen.stringWidth("Quit") / 2, "Quit");
+
+	if (!_savegameIndex)
+		screen.buttonPrint(Common::Point(ENV_POINTS[3][2], CONTROLS_Y), COMMAND_NULL, 0, "Up");
+
+	if (_savegameIndex == MAX_SAVEGAME_SLOTS - ONSCREEN_FILES_COUNT)
+		screen.buttonPrint(Common::Point(ENV_POINTS[4][2], CONTROLS_Y), COMMAND_NULL, 0, "Down");
+
+	for (int idx = _savegameIndex; idx < _savegameIndex + ONSCREEN_FILES_COUNT; ++idx) {
+		screen.gPrint(Common::Point(6, CONTROLS_Y + 11 + (idx - _savegameIndex) * 10),
+			INV_FOREGROUND, "%d.", idx + 1);
+		screen.gPrint(Common::Point(24, CONTROLS_Y + 11 + (idx - _savegameIndex) * 10),
+			INV_FOREGROUND, "%s", _savegames[idx].c_str());
+	}
+
+	if (!ui._slideWindows) {
+		screen.slamRect(Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+	} else {
+		ui.summonWindow();
+	}
+
+	_envMode = SAVEMODE_NONE;
+}
+
+int ScalpelSaveManager::getHighlightedButton() const {
+	Common::Point pt = _vm->_events->mousePos();
+
+	for (int idx = 0; idx < 6; ++idx) {
+		if (pt.x > ENV_POINTS[idx][0] && pt.x < ENV_POINTS[idx][1] && pt.y > CONTROLS_Y
+				&& pt.y < (CONTROLS_Y + 10))
+			return idx;
+	}
+
+	return -1;
+}
+
+void ScalpelSaveManager::highlightButtons(int btnIndex) {
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	byte color = (btnIndex == 0) ? COMMAND_HIGHLIGHTED : COMMAND_FOREGROUND;
+
+	screen.buttonPrint(Common::Point(ENV_POINTS[0][2], CONTROLS_Y), color, 1, "Exit");
+
+	if ((btnIndex == 1) || ((_envMode == SAVEMODE_LOAD) && (btnIndex != 2)))
+		screen.buttonPrint(Common::Point(ENV_POINTS[1][2], CONTROLS_Y), COMMAND_HIGHLIGHTED, true, "Load");
+	else
+		screen.buttonPrint(Common::Point(ENV_POINTS[1][2], CONTROLS_Y), COMMAND_FOREGROUND, true, "Load");
+
+	if ((btnIndex == 2) || ((_envMode == SAVEMODE_SAVE) && (btnIndex != 1)))
+		screen.buttonPrint(Common::Point(ENV_POINTS[2][2], CONTROLS_Y), COMMAND_HIGHLIGHTED, true, "Save");
+	else
+		screen.buttonPrint(Common::Point(ENV_POINTS[2][2], CONTROLS_Y), COMMAND_FOREGROUND, true, "Save");
+
+	if (btnIndex == 3 && _savegameIndex)
+		screen.buttonPrint(Common::Point(ENV_POINTS[3][2], CONTROLS_Y), COMMAND_HIGHLIGHTED, true, "Up");
+	else
+		if (_savegameIndex)
+			screen.buttonPrint(Common::Point(ENV_POINTS[3][2], CONTROLS_Y), COMMAND_FOREGROUND, true, "Up");
+
+	if ((btnIndex == 4) && (_savegameIndex < MAX_SAVEGAME_SLOTS - 5))
+		screen.buttonPrint(Common::Point(ENV_POINTS[4][2], CONTROLS_Y), COMMAND_HIGHLIGHTED, true, "Down");
+	else if (_savegameIndex < (MAX_SAVEGAME_SLOTS - 5))
+		screen.buttonPrint(Common::Point(ENV_POINTS[4][2], CONTROLS_Y), COMMAND_FOREGROUND, true, "Down");
+
+	color = (btnIndex == 5) ? COMMAND_HIGHLIGHTED : COMMAND_FOREGROUND;
+	screen.buttonPrint(Common::Point(ENV_POINTS[5][2], CONTROLS_Y), color, 1, "Quit");
+}
+
+bool ScalpelSaveManager::checkGameOnScreen(int slot) {
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+
+	// Check if it's already on-screen
+	if (slot != -1 && (slot < _savegameIndex || slot >= (_savegameIndex + ONSCREEN_FILES_COUNT))) {
+		_savegameIndex = slot;
+
+		screen._backBuffer1.fillRect(Common::Rect(3, CONTROLS_Y + 11, SHERLOCK_SCREEN_WIDTH - 2,
+			SHERLOCK_SCREEN_HEIGHT - 1), INV_BACKGROUND);
+
+		for (int idx = _savegameIndex; idx < (_savegameIndex + 5); ++idx) {
+			screen.gPrint(Common::Point(6, CONTROLS_Y + 11 + (idx - _savegameIndex) * 10),
+				INV_FOREGROUND, "%d.", idx + 1);
+			screen.gPrint(Common::Point(24, CONTROLS_Y + 11 + (idx - _savegameIndex) * 10),
+				INV_FOREGROUND, "%s", _savegames[idx].c_str());
+		}
+
+		screen.slamRect(Common::Rect(3, CONTROLS_Y + 11, 318, SHERLOCK_SCREEN_HEIGHT));
+
+		byte color = !_savegameIndex ? COMMAND_NULL : COMMAND_FOREGROUND;
+		screen.buttonPrint(Common::Point(ENV_POINTS[3][2], CONTROLS_Y), color, 1, "Up");
+
+		color = (_savegameIndex == (MAX_SAVEGAME_SLOTS - 5)) ? COMMAND_NULL : COMMAND_FOREGROUND;
+		screen.buttonPrint(Common::Point(ENV_POINTS[4][2], CONTROLS_Y), color, 1, "Down");
+
+		return true;
+	}
+
+	return false;
+}
+
+bool ScalpelSaveManager::promptForDescription(int slot) {
+	Events &events = *_vm->_events;
+	Scene &scene = *_vm->_scene;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	int xp, yp;
+	bool flag = false;
+
+	screen.buttonPrint(Common::Point(ENV_POINTS[0][2], CONTROLS_Y), COMMAND_NULL, true, "Exit");
+	screen.buttonPrint(Common::Point(ENV_POINTS[1][2], CONTROLS_Y), COMMAND_NULL, true, "Load");
+	screen.buttonPrint(Common::Point(ENV_POINTS[2][2], CONTROLS_Y), COMMAND_NULL, true, "Save");
+	screen.buttonPrint(Common::Point(ENV_POINTS[3][2], CONTROLS_Y), COMMAND_NULL, true, "Up");
+	screen.buttonPrint(Common::Point(ENV_POINTS[4][2], CONTROLS_Y), COMMAND_NULL, true, "Down");
+	screen.buttonPrint(Common::Point(ENV_POINTS[5][2], CONTROLS_Y), COMMAND_NULL, true, "Quit");
+
+	Common::String saveName = _savegames[slot];
+	if (isSlotEmpty(slot)) {
+		// It's an empty slot, so start off with an empty save name
+		saveName = "";
+
+		yp = CONTROLS_Y + 12 + (slot - _savegameIndex) * 10;
+		screen.vgaBar(Common::Rect(24, yp, 85, yp + 9), INV_BACKGROUND);
+	}
+
+	screen.print(Common::Point(6, CONTROLS_Y + 12 + (slot - _savegameIndex) * 10), TALK_FOREGROUND, "%d.", slot + 1);
+	screen.print(Common::Point(24, CONTROLS_Y + 12 + (slot - _savegameIndex) * 10), TALK_FOREGROUND, "%s", saveName.c_str());
+	xp = 24 + screen.stringWidth(saveName);
+	yp = CONTROLS_Y + 12 + (slot - _savegameIndex) * 10;
+
+	int done = 0;
+	do {
+		while (!_vm->shouldQuit() && !events.kbHit()) {
+			scene.doBgAnim();
+
+			if (talk._talkToAbort)
+				return false;
+
+			// Allow event processing
+			events.pollEventsAndWait();
+			events.setButtonState();
+
+			flag = !flag;
+			if (flag)
+				screen.vgaBar(Common::Rect(xp, yp - 1, xp + 8, yp + 9), INV_FOREGROUND);
+			else
+				screen.vgaBar(Common::Rect(xp, yp - 1, xp + 8, yp + 9), INV_BACKGROUND);
+		}
+		if (_vm->shouldQuit())
+			return false;
+
+		// Get the next keypress
+		Common::KeyState keyState = events.getKey();
+
+		if (keyState.keycode == Common::KEYCODE_BACKSPACE && saveName.size() > 0) {
+			// Delete character of save name
+			screen.vgaBar(Common::Rect(xp - screen.charWidth(saveName.lastChar()), yp - 1,
+				xp + 8, yp + 9), INV_BACKGROUND);
+			xp -= screen.charWidth(saveName.lastChar());
+			screen.vgaBar(Common::Rect(xp, yp - 1, xp + 8, yp + 9), INV_FOREGROUND);
+			saveName.deleteLastChar();
+		
+		} else if (keyState.keycode == Common::KEYCODE_RETURN && saveName.compareToIgnoreCase(EMPTY_SAVEGAME_SLOT)) {
+			done = 1;
+
+		} else if (keyState.keycode == Common::KEYCODE_ESCAPE) {
+			screen.vgaBar(Common::Rect(xp, yp - 1, xp + 8, yp + 9), INV_BACKGROUND);
+			done = -1;
+		
+		} else if (keyState.ascii >= ' ' && keyState.ascii <= 'z' && saveName.size() < 50
+				&& (xp + screen.charWidth(keyState.ascii)) < 308) {
+			char c = (char)keyState.ascii;
+
+			screen.vgaBar(Common::Rect(xp, yp - 1, xp + 8, yp + 9), INV_BACKGROUND);
+			screen.print(Common::Point(xp, yp), TALK_FOREGROUND, "%c", c);
+			xp += screen.charWidth(c);
+			screen.vgaBar(Common::Rect(xp, yp - 1, xp + 8, yp + 9), INV_FOREGROUND);
+			saveName += c;
+		}
+	} while (!done);
+
+	if (done == 1) {
+		// Enter key perssed
+		_savegames[slot] = saveName;
+	} else {
+		done = 0;
+		_envMode = SAVEMODE_NONE;
+		highlightButtons(-1);
+	}
+
+	return done == 1;
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_saveload.h b/engines/sherlock/scalpel/scalpel_saveload.h
new file mode 100644
index 0000000000..6b035cace3
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_saveload.h
@@ -0,0 +1,71 @@
+/* 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 SHERLOCK_SCALPEL_SAVELOAD_H
+#define SHERLOCK_SCALPEL_SAVELOAD_H
+
+#include "sherlock/saveload.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+extern const int ENV_POINTS[6][3];
+
+class ScalpelSaveManager: public SaveManager {
+public:
+	SaveMode _envMode;
+public:
+	ScalpelSaveManager(SherlockEngine *vm, const Common::String &target);
+	virtual ~ScalpelSaveManager() {}
+
+	/**
+	 * Shows the in-game dialog interface for loading and saving games
+	 */
+	void drawInterface();
+
+	/**
+	 * Return the index of the button the mouse is over, if any
+	 */
+	int getHighlightedButton() const;
+
+	/**
+	 * Handle highlighting buttons
+	 */
+	void highlightButtons(int btnIndex);
+
+	/**
+	 * Make sure that the selected savegame is on-screen
+	 */
+	bool checkGameOnScreen(int slot);
+
+	/**
+	 * Prompts the user to enter a description in a given slot
+	 */
+	bool promptForDescription(int slot);
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_scene.cpp b/engines/sherlock/scalpel/scalpel_scene.cpp
new file mode 100644
index 0000000000..b62703e0fb
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_scene.cpp
@@ -0,0 +1,758 @@
+/* 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 "sherlock/scalpel/scalpel_scene.h"
+#include "sherlock/scalpel/scalpel_map.h"
+#include "sherlock/scalpel/scalpel_people.h"
+#include "sherlock/scalpel/scalpel_user_interface.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/events.h"
+#include "sherlock/people.h"
+#include "sherlock/screen.h"
+#include "sherlock/sherlock.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+const int FS_TRANS[8] = {
+	STOP_UP, STOP_UPRIGHT, STOP_RIGHT, STOP_DOWNRIGHT, STOP_DOWN, STOP_DOWNLEFT, STOP_LEFT, STOP_UPLEFT
+};
+
+/*----------------------------------------------------------------*/
+
+ScalpelScene::~ScalpelScene() {
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx)
+		delete _canimShapes[idx];
+}
+
+bool ScalpelScene::loadScene(const Common::String &filename) {
+	ScalpelMap &map = *(ScalpelMap *)_vm->_map;
+	bool result = Scene::loadScene(filename);
+
+	if (!_vm->isDemo()) {
+		// Reset the previous map location and position on overhead map
+		map._oldCharPoint = _currentScene;
+
+		map._overPos.x = (map[_currentScene].x - 6) * FIXED_INT_MULTIPLIER;
+		map._overPos.y = (map[_currentScene].y + 9) * FIXED_INT_MULTIPLIER;
+
+	}
+
+	return result;
+}
+
+void ScalpelScene::drawAllShapes() {
+	People &people = *_vm->_people;
+	Screen &screen = *_vm->_screen;
+
+	// Restrict drawing window
+	screen.setDisplayBounds(Common::Rect(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCENE_HEIGHT));
+
+	// Draw all active shapes which are behind the person
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		if (_bgShapes[idx]._type == ACTIVE_BG_SHAPE && _bgShapes[idx]._misc == BEHIND)
+			screen._backBuffer->transBlitFrom(*_bgShapes[idx]._imageFrame, _bgShapes[idx]._position, _bgShapes[idx]._flags & OBJ_FLIPPED);
+	}
+
+	// Draw all canimations which are behind the person
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		if (_canimShapes[idx]->_type == ACTIVE_BG_SHAPE && _canimShapes[idx]->_misc == BEHIND)
+			screen._backBuffer->transBlitFrom(*_canimShapes[idx]->_imageFrame,
+			_canimShapes[idx]->_position, _canimShapes[idx]->_flags & OBJ_FLIPPED);
+	}
+
+	// Draw all active shapes which are normal and behind the person
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		if (_bgShapes[idx]._type == ACTIVE_BG_SHAPE && _bgShapes[idx]._misc == NORMAL_BEHIND)
+			screen._backBuffer->transBlitFrom(*_bgShapes[idx]._imageFrame, _bgShapes[idx]._position, _bgShapes[idx]._flags & OBJ_FLIPPED);
+	}
+
+	// Draw all canimations which are normal and behind the person
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		if (_canimShapes[idx]->_type == ACTIVE_BG_SHAPE && _canimShapes[idx]->_misc == NORMAL_BEHIND)
+			screen._backBuffer->transBlitFrom(*_canimShapes[idx]->_imageFrame, _canimShapes[idx]->_position,
+			_canimShapes[idx]->_flags & OBJ_FLIPPED);
+	}
+
+	// Draw any active characters
+	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+		Person &p = people[idx];
+		if (p._type == CHARACTER && p._walkLoaded) {
+			bool flipped = IS_SERRATED_SCALPEL && (
+				p._sequenceNumber == WALK_LEFT || p._sequenceNumber == STOP_LEFT ||
+				p._sequenceNumber == WALK_UPLEFT || p._sequenceNumber == STOP_UPLEFT ||
+				p._sequenceNumber == WALK_DOWNRIGHT || p._sequenceNumber == STOP_DOWNRIGHT);
+
+			screen._backBuffer->transBlitFrom(*p._imageFrame, Common::Point(p._position.x / FIXED_INT_MULTIPLIER,
+				p._position.y / FIXED_INT_MULTIPLIER - p.frameHeight()), flipped);
+		}
+	}
+
+	// Draw all static and active shapes that are NORMAL and are in front of the player
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		if ((_bgShapes[idx]._type == ACTIVE_BG_SHAPE || _bgShapes[idx]._type == STATIC_BG_SHAPE) &&
+			_bgShapes[idx]._misc == NORMAL_FORWARD)
+			screen._backBuffer->transBlitFrom(*_bgShapes[idx]._imageFrame, _bgShapes[idx]._position,
+			_bgShapes[idx]._flags & OBJ_FLIPPED);
+	}
+
+	// Draw all static and active canimations that are NORMAL and are in front of the player
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		if ((_canimShapes[idx]->_type == ACTIVE_BG_SHAPE || _canimShapes[idx]->_type == STATIC_BG_SHAPE) &&
+			_canimShapes[idx]->_misc == NORMAL_FORWARD)
+			screen._backBuffer->transBlitFrom(*_canimShapes[idx]->_imageFrame, _canimShapes[idx]->_position,
+			_canimShapes[idx]->_flags & OBJ_FLIPPED);
+	}
+
+	// Draw all static and active shapes that are FORWARD
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		_bgShapes[idx]._oldPosition = _bgShapes[idx]._position;
+		_bgShapes[idx]._oldSize = Common::Point(_bgShapes[idx].frameWidth(),
+			_bgShapes[idx].frameHeight());
+
+		if ((_bgShapes[idx]._type == ACTIVE_BG_SHAPE || _bgShapes[idx]._type == STATIC_BG_SHAPE) &&
+			_bgShapes[idx]._misc == FORWARD)
+			screen._backBuffer->transBlitFrom(*_bgShapes[idx]._imageFrame, _bgShapes[idx]._position,
+			_bgShapes[idx]._flags & OBJ_FLIPPED);
+	}
+
+	// Draw all static and active canimations that are forward
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		if ((_canimShapes[idx]->_type == ACTIVE_BG_SHAPE || _canimShapes[idx]->_type == STATIC_BG_SHAPE) &&
+			_canimShapes[idx]->_misc == FORWARD)
+			screen._backBuffer->transBlitFrom(*_canimShapes[idx]->_imageFrame, _canimShapes[idx]->_position,
+			_canimShapes[idx]->_flags & OBJ_FLIPPED);
+	}
+
+	screen.resetDisplayBounds();
+}
+
+void ScalpelScene::checkBgShapes() {
+	People &people = *_vm->_people;
+	Person &holmes = people[HOLMES];
+	Common::Point pt(holmes._position.x / FIXED_INT_MULTIPLIER, holmes._position.y / FIXED_INT_MULTIPLIER);
+
+	// Call the base scene method to handle bg shapes
+	Scene::checkBgShapes();
+
+	// Iterate through the canim list
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		Object &obj = *_canimShapes[idx];
+		if (obj._type == STATIC_BG_SHAPE || obj._type == ACTIVE_BG_SHAPE) {
+			if ((obj._flags & 5) == 1) {
+				obj._misc = (pt.y < (obj._position.y + obj._imageFrame->_frame.h - 1)) ?
+				NORMAL_FORWARD : NORMAL_BEHIND;
+			} else if (!(obj._flags & 1)) {
+				obj._misc = BEHIND;
+			} else if (obj._flags & 4) {
+				obj._misc = FORWARD;
+			}
+		}
+	}
+}
+
+void ScalpelScene::doBgAnimCheckCursor() {
+	Inventory &inv = *_vm->_inventory;
+	Events &events = *_vm->_events;
+	UserInterface &ui = *_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+	events.animateCursorIfNeeded();
+
+	if (ui._menuMode == LOOK_MODE) {
+		if (mousePos.y > CONTROLS_Y1)
+			events.setCursor(ARROW);
+		else if (mousePos.y < CONTROLS_Y)
+			events.setCursor(MAGNIFY);
+	}
+
+	// Check for setting magnifying glass cursor
+	if (ui._menuMode == INV_MODE || ui._menuMode == USE_MODE || ui._menuMode == GIVE_MODE) {
+		if (inv._invMode == INVMODE_LOOK) {
+			// Only show Magnifying glass cursor if it's not on the inventory command line
+			if (mousePos.y < CONTROLS_Y || mousePos.y >(CONTROLS_Y1 + 13))
+				events.setCursor(MAGNIFY);
+			else
+				events.setCursor(ARROW);
+		} else {
+			events.setCursor(ARROW);
+		}
+	}
+}
+
+void ScalpelScene::doBgAnim() {
+	ScalpelEngine &vm = *((ScalpelEngine *)_vm);
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+
+	doBgAnimCheckCursor();
+
+	screen.setDisplayBounds(Common::Rect(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCENE_HEIGHT));
+	talk._talkToAbort = false;
+
+	if (_restoreFlag) {
+		for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+			if (people[idx]._type == CHARACTER)
+				people[idx].checkSprite();
+		}
+
+		for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+			if (_bgShapes[idx]._type == ACTIVE_BG_SHAPE)
+				_bgShapes[idx].checkObject();
+		}
+
+		if (people._portraitLoaded && people._portrait._type == ACTIVE_BG_SHAPE)
+			people._portrait.checkObject();
+
+		for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+			if (_canimShapes[idx]->_type != INVALID && _canimShapes[idx]->_type != REMOVE)
+				_canimShapes[idx]->checkObject();
+		}
+
+		if (_currentScene == DRAWING_ROOM)
+			vm.eraseBrumwellMirror();
+
+		// Restore the back buffer from the back buffer 2 in the changed area
+		Common::Rect bounds(people[HOLMES]._oldPosition.x, people[HOLMES]._oldPosition.y,
+			people[HOLMES]._oldPosition.x + people[HOLMES]._oldSize.x,
+			people[HOLMES]._oldPosition.y + people[HOLMES]._oldSize.y);
+		Common::Point pt(bounds.left, bounds.top);
+
+		if (people[HOLMES]._type == CHARACTER)
+			screen.restoreBackground(bounds);
+		else if (people[HOLMES]._type == REMOVE)
+			screen._backBuffer->blitFrom(screen._backBuffer2, pt, bounds);
+
+		for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+			Object &o = _bgShapes[idx];
+			if (o._type == ACTIVE_BG_SHAPE || o._type == HIDE_SHAPE || o._type == REMOVE)
+				screen.restoreBackground(o.getOldBounds());
+		}
+
+		if (people._portraitLoaded)
+			screen.restoreBackground(Common::Rect(
+				people._portrait._oldPosition.x, people._portrait._oldPosition.y,
+				people._portrait._oldPosition.x + people._portrait._oldSize.x,
+				people._portrait._oldPosition.y + people._portrait._oldSize.y
+			));
+
+		for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+			Object &o = _bgShapes[idx];
+			if (o._type == NO_SHAPE && ((o._flags & OBJ_BEHIND) == 0)) {
+				// Restore screen area
+				screen._backBuffer->blitFrom(screen._backBuffer2, o._position,
+					Common::Rect(o._position.x, o._position.y,
+					o._position.x + o._noShapeSize.x, o._position.y + o._noShapeSize.y));
+
+				o._oldPosition = o._position;
+				o._oldSize = o._noShapeSize;
+			}
+		}
+
+		for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+			Object &o = *_canimShapes[idx];
+			if (o._type == ACTIVE_BG_SHAPE || o._type == HIDE_SHAPE || o._type == REMOVE)
+				screen.restoreBackground(Common::Rect(o._oldPosition.x, o._oldPosition.y,
+					o._oldPosition.x + o._oldSize.x, o._oldPosition.y + o._oldSize.y));
+		}
+	}
+
+	//
+	// Update the background objects and canimations
+	//
+
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &o = _bgShapes[idx];
+		if (o._type == ACTIVE_BG_SHAPE || o._type == NO_SHAPE)
+			o.adjustObject();
+	}
+
+	if (people._portraitLoaded && people._portrait._type == ACTIVE_BG_SHAPE)
+		people._portrait.adjustObject();
+
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		if (_canimShapes[idx]->_type != INVALID)
+			_canimShapes[idx]->adjustObject();
+	}
+
+	if (people[HOLMES]._type == CHARACTER && people._holmesOn)
+		people[HOLMES].adjustSprite();
+
+	// Flag the bg shapes which need to be redrawn
+	checkBgShapes();
+
+	if (_currentScene == DRAWING_ROOM)
+		vm.doBrumwellMirror();
+
+	// Draw all active shapes which are behind the person
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &o = _bgShapes[idx];
+		if (o._type == ACTIVE_BG_SHAPE && o._misc == BEHIND)
+			screen._backBuffer->transBlitFrom(*o._imageFrame, o._position, o._flags & OBJ_FLIPPED);
+	}
+
+	// Draw all canimations which are behind the person
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		Object &o = *_canimShapes[idx];
+		if (o._type == ACTIVE_BG_SHAPE && o._misc == BEHIND) {
+			screen._backBuffer->transBlitFrom(*o._imageFrame, o._position, o._flags & OBJ_FLIPPED);
+		}
+	}
+
+	// Draw all active shapes which are HAPPEN and behind the person
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &o = _bgShapes[idx];
+		if (o._type == ACTIVE_BG_SHAPE && o._misc == NORMAL_BEHIND)
+			screen._backBuffer->transBlitFrom(*o._imageFrame, o._position, o._flags & OBJ_FLIPPED);
+	}
+
+	// Draw all canimations which are NORMAL and behind the person
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		Object &o = *_canimShapes[idx];
+		if (o._type == ACTIVE_BG_SHAPE && o._misc == NORMAL_BEHIND) {
+			screen._backBuffer->transBlitFrom(*o._imageFrame, o._position, o._flags & OBJ_FLIPPED);
+		}
+	}
+
+	// Draw the player if he's active and his walk has been loaded into memory
+	if (people[HOLMES]._type == CHARACTER && people[HOLMES]._walkLoaded && people._holmesOn) {
+		// If Holmes is too far to the right, move him back so he's on-screen
+		int xRight = SHERLOCK_SCREEN_WIDTH - 2 - people[HOLMES]._imageFrame->_frame.w;
+		int tempX = MIN(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER, xRight);
+
+		bool flipped = people[HOLMES]._sequenceNumber == WALK_LEFT || people[HOLMES]._sequenceNumber == STOP_LEFT ||
+			people[HOLMES]._sequenceNumber == WALK_UPLEFT || people[HOLMES]._sequenceNumber == STOP_UPLEFT ||
+			people[HOLMES]._sequenceNumber == WALK_DOWNRIGHT || people[HOLMES]._sequenceNumber == STOP_DOWNRIGHT;
+		screen._backBuffer->transBlitFrom(*people[HOLMES]._imageFrame,
+			Common::Point(tempX, people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES]._imageFrame->_frame.h), flipped);
+	}
+
+	// Draw all static and active shapes are NORMAL and are in front of the person
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &o = _bgShapes[idx];
+		if ((o._type == ACTIVE_BG_SHAPE || o._type == STATIC_BG_SHAPE) && o._misc == NORMAL_FORWARD)
+			screen._backBuffer->transBlitFrom(*o._imageFrame, o._position, o._flags & OBJ_FLIPPED);
+	}
+
+	// Draw all static and active canimations that are NORMAL and are in front of the person
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		Object &o = *_canimShapes[idx];
+		if ((o._type == ACTIVE_BG_SHAPE || o._type == STATIC_BG_SHAPE) && o._misc == NORMAL_FORWARD) {
+			screen._backBuffer->transBlitFrom(*o._imageFrame, o._position, o._flags & OBJ_FLIPPED);
+		}
+	}
+
+	// Draw all static and active shapes that are in front of the person
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &o = _bgShapes[idx];
+		if ((o._type == ACTIVE_BG_SHAPE || o._type == STATIC_BG_SHAPE) && o._misc == FORWARD)
+			screen._backBuffer->transBlitFrom(*o._imageFrame, o._position, o._flags & OBJ_FLIPPED);
+	}
+
+	// Draw any active portrait
+	if (people._portraitLoaded && people._portrait._type == ACTIVE_BG_SHAPE)
+		screen._backBuffer->transBlitFrom(*people._portrait._imageFrame,
+			people._portrait._position, people._portrait._flags & OBJ_FLIPPED);
+
+	// Draw all static and active canimations that are in front of the person
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		Object &o = *_canimShapes[idx];
+		if ((o._type == ACTIVE_BG_SHAPE || o._type == STATIC_BG_SHAPE) && o._misc == FORWARD) {
+			screen._backBuffer->transBlitFrom(*o._imageFrame, o._position, o._flags & OBJ_FLIPPED);
+		}
+	}
+
+	// Draw all NO_SHAPE shapes which have flag bit 0 clear
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &o = _bgShapes[idx];
+		if (o._type == NO_SHAPE && (o._flags & OBJ_BEHIND) == 0)
+			screen._backBuffer->transBlitFrom(*o._imageFrame, o._position, o._flags & OBJ_FLIPPED);
+	}
+
+	// Bring the newly built picture to the screen
+	if (_animating == 2) {
+		_animating = 0;
+		screen.slamRect(Common::Rect(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCENE_HEIGHT));
+	} else {
+		if (people[HOLMES]._type != INVALID && ((_goToScene == -1 || _canimShapes.empty()))) {
+			if (people[HOLMES]._type == REMOVE) {
+				screen.slamRect(Common::Rect(
+					people[HOLMES]._oldPosition.x, people[HOLMES]._oldPosition.y,
+					people[HOLMES]._oldPosition.x + people[HOLMES]._oldSize.x,
+					people[HOLMES]._oldPosition.y + people[HOLMES]._oldSize.y
+				));
+				people[HOLMES]._type = INVALID;
+			} else {
+				screen.flushImage(people[HOLMES]._imageFrame,
+					Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER,
+						people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES].frameHeight()),
+					&people[HOLMES]._oldPosition.x, &people[HOLMES]._oldPosition.y,
+					&people[HOLMES]._oldSize.x, &people[HOLMES]._oldSize.y);
+			}
+		}
+
+		if (_currentScene == DRAWING_ROOM)
+			vm.flushBrumwellMirror();
+
+		for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+			Object &o = _bgShapes[idx];
+			if ((o._type == ACTIVE_BG_SHAPE || o._type == REMOVE) && _goToScene == -1) {
+				screen.flushImage(o._imageFrame, o._position,
+					&o._oldPosition.x, &o._oldPosition.y, &o._oldSize.x, &o._oldSize.y);
+			}
+		}
+
+		if (people._portraitLoaded) {
+			if (people._portrait._type == REMOVE)
+				screen.slamRect(Common::Rect(
+					people._portrait._position.x, people._portrait._position.y,
+					people._portrait._position.x + people._portrait._delta.x,
+					people._portrait._position.y + people._portrait._delta.y
+				));
+			else
+				screen.flushImage(people._portrait._imageFrame, people._portrait._position,
+					&people._portrait._oldPosition.x, &people._portrait._oldPosition.y,
+					&people._portrait._oldSize.x, &people._portrait._oldSize.y);
+
+			if (people._portrait._type == REMOVE)
+				people._portrait._type = INVALID;
+		}
+
+		if (_goToScene == -1) {
+			for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+				Object &o = _bgShapes[idx];
+				if (o._type == NO_SHAPE && (o._flags & OBJ_BEHIND) == 0) {
+					screen.slamArea(o._position.x, o._position.y, o._oldSize.x, o._oldSize.y);
+					screen.slamArea(o._oldPosition.x, o._oldPosition.y, o._oldSize.x, o._oldSize.y);
+				} else if (o._type == HIDE_SHAPE) {
+					// Hiding shape, so flush it out and mark it as hidden
+					screen.flushImage(o._imageFrame, o._position,
+						&o._oldPosition.x, &o._oldPosition.y, &o._oldSize.x, &o._oldSize.y);
+					o._type = HIDDEN;
+				}
+			}
+		}
+
+		for (int idx = _canimShapes.size() - 1; idx >= 0; --idx) {
+			Object &o = *_canimShapes[idx];
+
+			if (o._type == INVALID) {
+				// Anim shape was invalidated by checkEndOfSequence, so at this point we can remove it
+				delete _canimShapes[idx];
+				_canimShapes.remove_at(idx);
+			} else  if (o._type == REMOVE) {
+				if (_goToScene == -1)
+					screen.slamArea(o._position.x, o._position.y, o._delta.x, o._delta.y);
+
+				// Shape for an animation is no longer needed, so remove it completely
+				delete _canimShapes[idx];
+				_canimShapes.remove_at(idx);
+			} else if (o._type == ACTIVE_BG_SHAPE) {
+				screen.flushImage(o._imageFrame, o._position,
+					&o._oldPosition.x, &o._oldPosition.y, &o._oldSize.x, &o._oldSize.y);
+			}
+		}
+	}
+
+	_restoreFlag = true;
+	_doBgAnimDone = true;
+
+	events.wait(3);
+	screen.resetDisplayBounds();
+
+	// Check if the method was called for calling a portrait, and a talk was
+	// interrupting it. This talk file would not have been executed at the time,
+	// since we needed to finish the 'doBgAnim' to finish clearing the portrait
+	if (people._clearingThePortrait && talk._scriptMoreFlag == 3) {
+		// Reset the flags and call to talk
+		people._clearingThePortrait = false;
+		talk._scriptMoreFlag = 0;
+		talk.talkTo(talk._scriptName);
+	}
+}
+
+int ScalpelScene::startCAnim(int cAnimNum, int playRate) {
+	Events &events = *_vm->_events;
+	ScalpelMap &map = *(ScalpelMap *)_vm->_map;
+	People &people = *_vm->_people;
+	Resources &res = *_vm->_res;
+	Talk &talk = *_vm->_talk;
+	ScalpelUserInterface &ui = *(ScalpelUserInterface *)_vm->_ui;
+	Point32 tpPos, walkPos;
+	int tpDir, walkDir;
+	int tFrames = 0;
+	int gotoCode = -1;
+	Object *cObj;
+
+	// Validation
+	if (cAnimNum >= (int)_cAnim.size())
+		// number out of bounds
+		return -1;
+	if (_canimShapes.size() >= 3 || playRate == 0)
+		// Too many active animations, or invalid play rate
+		return 0;
+
+	CAnim &cAnim = _cAnim[cAnimNum];
+	if (playRate < 0) {
+		// Reverse direction
+		walkPos = cAnim._teleport[0];
+		walkDir = cAnim._teleport[0]._facing;
+		tpPos = cAnim._goto[0];
+		tpDir = cAnim._goto[0]._facing;
+	} else {
+		// Forward direction
+		walkPos = cAnim._goto[0];
+		walkDir = cAnim._goto[0]._facing;
+		tpPos = cAnim._teleport[0];
+		tpDir = cAnim._teleport[0]._facing;
+	}
+
+	CursorId oldCursor = events.getCursor();
+	events.setCursor(WAIT);
+
+	if (walkPos.x != -1) {
+		// Holmes must walk to the walk point before the cAnimation is started
+		if (people[HOLMES]._position != walkPos)
+			people[HOLMES].walkToCoords(walkPos, walkDir);
+	}
+
+	if (talk._talkToAbort)
+		return 1;
+
+	// Add new anim shape entry for displaying the animation
+	cObj = new Object();
+	_canimShapes.push_back(cObj);
+
+	// Copy the canimation into the bgShapes type canimation structure so it can be played
+	cObj->_allow = cAnimNum + 1;				// Keep track of the parent structure
+	cObj->_name = _cAnim[cAnimNum]._name;	// Copy name
+
+	// Remove any attempt to draw object frame
+	if (cAnim._type == NO_SHAPE && cAnim._sequences[0] < 100)
+		cAnim._sequences[0] = 0;
+
+	cObj->_sequences = cAnim._sequences;
+	cObj->_images = nullptr;
+	cObj->_position = cAnim._position;
+	cObj->_delta = Common::Point(0, 0);
+	cObj->_type = cAnim._type;
+	cObj->_flags = cAnim._flags;
+
+	cObj->_maxFrames = 0;
+	cObj->_frameNumber = -1;
+	cObj->_sequenceNumber = cAnimNum;
+	cObj->_oldPosition = Common::Point(0, 0);
+	cObj->_oldSize = Common::Point(0, 0);
+	cObj->_goto = Common::Point(0, 0);
+	cObj->_status = 0;
+	cObj->_misc = 0;
+	cObj->_imageFrame = nullptr;
+
+	if (cAnim._name.size() > 0 && cAnim._type != NO_SHAPE) {
+		if (tpPos.x != -1)
+			people[HOLMES]._type = REMOVE;
+
+		Common::String fname = cAnim._name + ".vgs";
+		if (!res.isInCache(fname)) {
+			// Set up RRM scene data
+			Common::SeekableReadStream *roomStream = res.load(_roomFilename);
+			roomStream->seek(cAnim._dataOffset);
+			//rrmStream->seek(44 + cAnimNum * 4);
+			//rrmStream->seek(rrmStream->readUint32LE());
+
+			// Load the canimation into the cache
+			Common::SeekableReadStream *imgStream = !_compressed ? roomStream->readStream(cAnim._dataSize) :
+				Resources::decompressLZ(*roomStream, cAnim._dataSize);
+			res.addToCache(fname, *imgStream);
+
+			delete imgStream;
+			delete roomStream;
+		}
+
+		// Now load the resource as an image
+		if (!IS_3DO) {
+			cObj->_images = new ImageFile(fname);
+		} else {
+			cObj->_images = new ImageFile3DO(fname, kImageFile3DOType_RoomFormat);
+		}
+		cObj->_imageFrame = &(*cObj->_images)[0];
+		cObj->_maxFrames = cObj->_images->size();
+
+		int frames = 0;
+		if (playRate < 0) {
+			// Reverse direction
+			// Count number of frames
+			while (frames < MAX_FRAME && cObj->_sequences[frames])
+				++frames;
+		} else {
+			// Forward direction
+			BaseObject::_countCAnimFrames = true;
+
+			while (cObj->_type == ACTIVE_BG_SHAPE) {
+				cObj->checkObject();
+				++frames;
+
+				if (frames >= 1000)
+					error("CAnim has infinite loop sequence");
+			}
+
+			if (frames > 1)
+				--frames;
+
+			BaseObject::_countCAnimFrames = false;
+
+			cObj->_type = cAnim._type;
+			cObj->_frameNumber = -1;
+			cObj->_position = cAnim._position;
+			cObj->_delta = Common::Point(0, 0);
+		}
+
+		// Return if animation has no frames in it
+		if (frames == 0)
+			return -2;
+
+		++frames;
+		int repeat = ABS(playRate);
+		int dir;
+
+		if (playRate < 0) {
+			// Play in reverse
+			dir = -2;
+			cObj->_frameNumber = frames - 3;
+		} else {
+			dir = 0;
+		}
+
+		tFrames = frames - 1;
+		int pauseFrame = (_cAnimFramePause) ? frames - _cAnimFramePause : -1;
+
+		while (--frames) {
+			if (frames == pauseFrame)
+				ui.printObjectDesc();
+
+			doBgAnim();
+
+			// Repeat same frame
+			int temp = repeat;
+			while (--temp > 0) {
+				cObj->_frameNumber--;
+				doBgAnim();
+
+				if (_vm->shouldQuit())
+					return 0;
+			}
+
+			cObj->_frameNumber += dir;
+		}
+
+		people[HOLMES]._type = CHARACTER;
+	}
+
+	// Teleport to ending coordinates if necessary
+	if (tpPos.x != -1) {
+		people[HOLMES]._position = tpPos;	// Place the player
+		people[HOLMES]._sequenceNumber = tpDir;
+		people[HOLMES].gotoStand();
+	}
+
+	if (playRate < 0)
+		// Reverse direction - set to end sequence
+		cObj->_frameNumber = tFrames - 1;
+
+	if (cObj->_frameNumber <= 26)
+		gotoCode = cObj->_sequences[cObj->_frameNumber + 3];
+
+	// Unless anim shape has already been removed, do a final check to allow it to become REMOVEd
+	for (uint idx = 0; idx < _canimShapes.size(); ++idx) {
+		if (_canimShapes[idx] == cObj) {
+			cObj->checkObject();
+			break;
+		}
+	}
+
+	if (gotoCode > 0 && !talk._talkToAbort) {
+		_goToScene = gotoCode;
+
+		if (_goToScene < 97 && map[_goToScene].x) {
+			map._overPos = map[_goToScene];
+		}
+	}
+
+	people.loadWalk();
+
+	if (tpPos.x != -1 && !talk._talkToAbort) {
+		// Teleport to ending coordinates
+		people[HOLMES]._position = tpPos;
+		people[HOLMES]._sequenceNumber = tpDir;
+
+		people[HOLMES].gotoStand();
+	}
+
+	events.setCursor(oldCursor);
+
+	return 1;
+}
+
+int ScalpelScene::closestZone(const Common::Point &pt) {
+	int dist = 1000;
+	int zone = -1;
+
+	for (uint idx = 0; idx < _zones.size(); ++idx) {
+		Common::Point zc((_zones[idx].left + _zones[idx].right) / 2,
+			(_zones[idx].top + _zones[idx].bottom) / 2);
+		int d = ABS(zc.x - pt.x) + ABS(zc.y - pt.y);
+
+		if (d < dist) {
+			// Found a closer zone
+			dist = d;
+			zone = idx;
+		}
+	}
+
+	return zone;
+}
+
+int ScalpelScene::findBgShape(const Common::Point &pt) {
+	if (!_doBgAnimDone)
+		// New frame hasn't been drawn yet
+		return -1;
+
+	for (int idx = (int)_bgShapes.size() - 1; idx >= 0; --idx) {
+		Object &o = _bgShapes[idx];
+		if (o._type != INVALID && o._type != NO_SHAPE && o._type != HIDDEN
+			&& o._aType <= PERSON) {
+			if (o.getNewBounds().contains(pt))
+				return idx;
+		} else if (o._type == NO_SHAPE) {
+			if (o.getNoShapeBounds().contains(pt))
+				return idx;
+		}
+	}
+
+	return -1;
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_scene.h b/engines/sherlock/scalpel/scalpel_scene.h
new file mode 100644
index 0000000000..8711fea2d0
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_scene.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 SHERLOCK_SCALPEL_SCENE_H
+#define SHERLOCK_SCALPEL_SCENE_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/rect.h"
+#include "common/serializer.h"
+#include "sherlock/objects.h"
+#include "sherlock/scene.h"
+#include "sherlock/screen.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+extern const int FS_TRANS[8];
+
+enum { BLACKWOOD_CAPTURE = 2, BAKER_STREET = 4, DRAWING_ROOM = 12, STATION = 17, PUB_INTERIOR = 19,
+	LAWYER_OFFICE = 27, BAKER_ST_EXTERIOR = 39, RESCUE_ANNA = 52, MOOREHEAD_DEATH = 53, EXIT_GAME = 55,
+	BRUMWELL_SUICIDE = 70, OVERHEAD_MAP2 = 98, DARTS_GAME = 99, OVERHEAD_MAP = 100 };
+
+class ScalpelScene : public Scene {
+private:
+	void doBgAnimCheckCursor();
+protected:
+	/**
+	 * Loads the data associated for a given scene. The room resource file's format is:
+	 * BGHEADER: Holds an index for the rest of the file
+	 * STRUCTS:  The objects for the scene
+	 * IMAGES:   The graphic information for the structures
+	 *
+	 * The _misc field of the structures contains the number of the graphic image
+	 * that it should point to after loading; _misc is then set to 0.
+	 */
+	virtual bool loadScene(const Common::String &filename);
+
+	/**
+	 * Checks all the background shapes. If a background shape is animating,
+	 * it will flag it as needing to be drawn. If a non-animating shape is
+	 * colliding with another shape, it will also flag it as needing drawing
+	 */
+	virtual void checkBgShapes();
+
+	/**
+	 * Draw all the shapes, people and NPCs in the correct order
+	 */
+	virtual void drawAllShapes();
+
+	/**
+	 * Returns the index of the closest zone to a given point.
+	 */
+	virtual int closestZone(const Common::Point &pt);
+public:
+	ScalpelScene(SherlockEngine *vm) : Scene(vm) {}
+
+	virtual ~ScalpelScene();
+
+	/**
+	 * Draw all objects and characters.
+	 */
+	virtual void doBgAnim();
+
+	/**
+	 * Attempt to start a canimation sequence. It will load the requisite graphics, and
+	 * then copy the canim object into the _canimShapes array to start the animation.
+	 *
+	 * @param cAnimNum		The canim object within the current scene
+	 * @param playRate		Play rate. 0 is invalid; 1=normal speed, 2=1/2 speed, etc.
+	 *		A negative playRate can also be specified to play the animation in reverse
+	 */
+	virtual int startCAnim(int cAnimNum, int playRate = 1);
+
+	/**
+	 * Attempts to find a background shape within the passed bounds. If found,
+	 * it will return the shape number, or -1 on failure.
+	 */
+	virtual int findBgShape(const Common::Point &pt);
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_screen.cpp b/engines/sherlock/scalpel/scalpel_screen.cpp
new file mode 100644
index 0000000000..71bcca5dc5
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_screen.cpp
@@ -0,0 +1,342 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "sherlock/scalpel/scalpel.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+ScalpelScreen::ScalpelScreen(SherlockEngine *vm) : Screen(vm) {
+}
+
+void ScalpelScreen::makeButton(const Common::Rect &bounds, int textX,
+		const Common::String &str) {
+
+	Surface &bb = *_backBuffer;
+	bb.fillRect(Common::Rect(bounds.left, bounds.top, bounds.right, bounds.top + 1), BUTTON_TOP);
+	bb.fillRect(Common::Rect(bounds.left, bounds.top, bounds.left + 1, bounds.bottom), BUTTON_TOP);
+	bb.fillRect(Common::Rect(bounds.right - 1, bounds.top, bounds.right, bounds.bottom), BUTTON_BOTTOM);
+	bb.fillRect(Common::Rect(bounds.left + 1, bounds.bottom - 1, bounds.right, bounds.bottom), BUTTON_BOTTOM);
+	bb.fillRect(Common::Rect(bounds.left + 1, bounds.top + 1, bounds.right - 1, bounds.bottom - 1), BUTTON_MIDDLE);
+
+	gPrint(Common::Point(textX, bounds.top), COMMAND_HIGHLIGHTED, "%c", str[0]);
+	gPrint(Common::Point(textX + charWidth(str[0]), bounds.top),
+		COMMAND_FOREGROUND, "%s", str.c_str() + 1);
+}
+
+void ScalpelScreen::buttonPrint(const Common::Point &pt, uint color, bool slamIt,
+		const Common::String &str) {
+	int xStart = pt.x - stringWidth(str) / 2;
+
+	if (color == COMMAND_FOREGROUND) {
+		// First character needs to be highlighted
+		if (slamIt) {
+			print(Common::Point(xStart, pt.y + 1), COMMAND_HIGHLIGHTED, "%c", str[0]);
+			print(Common::Point(xStart + charWidth(str[0]), pt.y + 1),
+				COMMAND_FOREGROUND, "%s", str.c_str() + 1);
+		} else {
+			gPrint(Common::Point(xStart, pt.y), COMMAND_HIGHLIGHTED, "%c", str[0]);
+			gPrint(Common::Point(xStart + charWidth(str[0]), pt.y),
+				COMMAND_FOREGROUND, "%s", str.c_str() + 1);
+		}
+	} else if (slamIt) {
+		print(Common::Point(xStart, pt.y + 1), color, "%s", str.c_str());
+	} else {
+		gPrint(Common::Point(xStart, pt.y), color, "%s", str.c_str());
+	}
+}
+
+void ScalpelScreen::makePanel(const Common::Rect &r) {
+	_backBuffer->fillRect(r, BUTTON_MIDDLE);
+	_backBuffer->hLine(r.left, r.top, r.right - 2, BUTTON_TOP);
+	_backBuffer->hLine(r.left + 1, r.top + 1, r.right - 3, BUTTON_TOP);
+	_backBuffer->vLine(r.left, r.top, r.bottom - 1, BUTTON_TOP);
+	_backBuffer->vLine(r.left + 1, r.top + 1, r.bottom - 2, BUTTON_TOP);
+
+	_backBuffer->vLine(r.right - 1, r.top, r.bottom - 1, BUTTON_BOTTOM);
+	_backBuffer->vLine(r.right - 2, r.top + 1, r.bottom - 2, BUTTON_BOTTOM);
+	_backBuffer->hLine(r.left, r.bottom - 1, r.right - 1, BUTTON_BOTTOM);
+	_backBuffer->hLine(r.left + 1, r.bottom - 2, r.right - 1, BUTTON_BOTTOM);
+}
+
+void ScalpelScreen::makeField(const Common::Rect &r) {
+	_backBuffer->fillRect(r, BUTTON_MIDDLE);
+	_backBuffer->hLine(r.left, r.top, r.right - 1, BUTTON_BOTTOM);
+	_backBuffer->hLine(r.left + 1, r.bottom - 1, r.right - 1, BUTTON_TOP);
+	_backBuffer->vLine(r.left, r.top + 1, r.bottom - 1, BUTTON_BOTTOM);
+	_backBuffer->vLine(r.right - 1, r.top + 1, r.bottom - 2, BUTTON_TOP);
+}
+
+/*----------------------------------------------------------------*/
+
+void Scalpel3DOScreen::blitFrom(const Graphics::Surface &src, const Common::Point &pt, const Common::Rect &srcBounds) {
+	if (!_vm->_isScreenDoubled) {
+		ScalpelScreen::blitFrom(src, pt, srcBounds);
+		return;
+	}
+
+	Common::Rect srcRect = srcBounds;
+	Common::Rect destRect(pt.x, pt.y, pt.x + srcRect.width(), pt.y + srcRect.height());
+
+	if (!srcRect.isValidRect() || !clip(srcRect, destRect))
+		return;
+
+	// Add dirty area remapped to the 640x200 surface
+	addDirtyRect(Common::Rect(destRect.left * 2, destRect.top * 2, destRect.right * 2, destRect.bottom * 2));
+
+	// Transfer the area, doubling each pixel
+	for (int yp = 0; yp < srcRect.height(); ++yp) {
+		const uint16 *srcP = (const uint16 *)src.getBasePtr(srcRect.left, srcRect.top + yp);
+		uint16 *destP = (uint16 *)getBasePtr(destRect.left * 2, (destRect.top + yp) * 2);
+
+		for (int xp = srcRect.left; xp < srcRect.right; ++xp, ++srcP, destP += 2) {
+			*destP = *srcP;
+			*(destP + 1) = *srcP;
+			*(destP + 640) = *srcP;
+			*(destP + 640 + 1) = *srcP;
+		}
+	}
+}
+
+void Scalpel3DOScreen::transBlitFromUnscaled(const Graphics::Surface &src, const Common::Point &pt,
+		bool flipped, int overrideColor) {
+	if (!_vm->_isScreenDoubled) {
+		ScalpelScreen::transBlitFromUnscaled(src, pt, flipped, overrideColor);
+		return;
+	}
+
+	Common::Rect drawRect(0, 0, src.w, src.h);
+	Common::Rect destRect(pt.x, pt.y, pt.x + src.w, pt.y + src.h);
+
+	// Clip the display area to on-screen
+	if (!clip(drawRect, destRect))
+		// It's completely off-screen
+		return;
+
+	if (flipped)
+		drawRect = Common::Rect(src.w - drawRect.right, src.h - drawRect.bottom,
+		src.w - drawRect.left, src.h - drawRect.top);
+
+	Common::Point destPt(destRect.left, destRect.top);
+	addDirtyRect(Common::Rect(destPt.x * 2, destPt.y * 2, (destPt.x + drawRect.width()) * 2,
+		(destPt.y + drawRect.height()) * 2));
+
+	assert(src.format.bytesPerPixel == 2 && _surface.format.bytesPerPixel == 2);
+
+	for (int yp = 0; yp < drawRect.height(); ++yp) {
+		const uint16 *srcP = (const uint16 *)src.getBasePtr(
+			flipped ? drawRect.right - 1 : drawRect.left, drawRect.top + yp);
+		uint16 *destP = (uint16 *)getBasePtr(destPt.x * 2, (destPt.y + yp) * 2);
+
+		for (int xp = 0; xp < drawRect.width(); ++xp, destP += 2) {
+			// RGB 0, 0, 0 -> transparent on 3DO
+			if (*srcP) {
+				*destP = *srcP;
+				*(destP + 1) = *srcP;
+				*(destP + 640) = *srcP;
+				*(destP + 640 + 1) = *srcP;
+			}
+
+			srcP = flipped ? srcP - 1 : srcP + 1;
+		}
+	}
+}
+
+void Scalpel3DOScreen::fillRect(const Common::Rect &r, uint color) {
+	if (_vm->_isScreenDoubled)
+		ScalpelScreen::fillRect(Common::Rect(r.left * 2, r.top * 2, r.right * 2, r.bottom * 2), color);
+	else
+		ScalpelScreen::fillRect(r, color);
+}
+
+void Scalpel3DOScreen::fadeIntoScreen3DO(int speed) {
+	Events &events = *_vm->_events;
+	uint16 *currentScreenBasePtr = (uint16 *)getPixels();
+	uint16 *targetScreenBasePtr = (uint16 *)_backBuffer->getPixels();
+	uint16  currentScreenPixel = 0;
+	uint16  targetScreenPixel = 0;
+
+	uint16  currentScreenPixelRed = 0;
+	uint16  currentScreenPixelGreen = 0;
+	uint16  currentScreenPixelBlue = 0;
+
+	uint16  targetScreenPixelRed = 0;
+	uint16  targetScreenPixelGreen = 0;
+	uint16  targetScreenPixelBlue = 0;
+
+	uint16  screenWidth = SHERLOCK_SCREEN_WIDTH;
+	uint16  screenHeight = SHERLOCK_SCREEN_HEIGHT;
+	uint16  screenX = 0;
+	uint16  screenY = 0;
+	uint16  pixelsChanged = 0;
+
+	clearDirtyRects();
+
+	do {
+		pixelsChanged = 0;
+		uint16 *currentScreenPtr = currentScreenBasePtr;
+		uint16 *targetScreenPtr = targetScreenBasePtr;
+
+		for (screenY = 0; screenY < screenHeight; screenY++) {
+			for (screenX = 0; screenX < screenWidth; screenX++) {
+				currentScreenPixel = *currentScreenPtr;
+				targetScreenPixel = *targetScreenPtr;
+
+				if (currentScreenPixel != targetScreenPixel) {
+					// pixel doesn't match, adjust accordingly
+					currentScreenPixelRed = currentScreenPixel & 0xF800;
+					currentScreenPixelGreen = currentScreenPixel & 0x07E0;
+					currentScreenPixelBlue = currentScreenPixel & 0x001F;
+					targetScreenPixelRed = targetScreenPixel & 0xF800;
+					targetScreenPixelGreen = targetScreenPixel & 0x07E0;
+					targetScreenPixelBlue = targetScreenPixel & 0x001F;
+
+					if (currentScreenPixelRed != targetScreenPixelRed) {
+						if (currentScreenPixelRed < targetScreenPixelRed) {
+							currentScreenPixelRed += 0x0800;
+						} else {
+							currentScreenPixelRed -= 0x0800;
+						}
+					}
+					if (currentScreenPixelGreen != targetScreenPixelGreen) {
+						// Adjust +2/-2 because we are running RGB555 at RGB565
+						if (currentScreenPixelGreen < targetScreenPixelGreen) {
+							currentScreenPixelGreen += 0x0040;
+						} else {
+							currentScreenPixelGreen -= 0x0040;
+						}
+					}
+					if (currentScreenPixelBlue != targetScreenPixelBlue) {
+						if (currentScreenPixelBlue < targetScreenPixelBlue) {
+							currentScreenPixelBlue += 0x0001;
+						} else {
+							currentScreenPixelBlue -= 0x0001;
+						}
+					}
+
+					uint16 v = currentScreenPixelRed | currentScreenPixelGreen | currentScreenPixelBlue;
+					*currentScreenPtr = v;
+					if (_vm->_isScreenDoubled) {
+						*(currentScreenPtr + 1) = v;
+						*(currentScreenPtr + 640) = v;
+						*(currentScreenPtr + 640 + 1) = v;
+					}
+
+					pixelsChanged++;
+				}
+
+				currentScreenPtr += _vm->_isScreenDoubled ? 2 : 1;
+				targetScreenPtr++;
+			}
+
+			if (_vm->_isScreenDoubled)
+				currentScreenPtr += 640;
+		}
+
+		// Too much considered dirty at the moment
+		if (_vm->_isScreenDoubled)
+			addDirtyRect(Common::Rect(0, 0, screenWidth * 2, screenHeight * 2));
+		else
+			addDirtyRect(Common::Rect(0, 0, screenWidth, screenHeight));
+
+		events.pollEvents();
+		events.delay(10 * speed);
+	} while ((pixelsChanged) && (!_vm->shouldQuit()));
+}
+
+void Scalpel3DOScreen::blitFrom3DOcolorLimit(uint16 limitColor) {
+	uint16 *currentScreenPtr = (uint16 *)getPixels();
+	uint16 *targetScreenPtr = (uint16 *)_backBuffer->getPixels();
+	uint16  currentScreenPixel = 0;
+
+	uint16  screenWidth = SHERLOCK_SCREEN_WIDTH;
+	uint16  screenHeight = SHERLOCK_SCREEN_HEIGHT;
+	uint16  screenX = 0;
+	uint16  screenY = 0;
+
+	uint16  currentScreenPixelRed = 0;
+	uint16  currentScreenPixelGreen = 0;
+	uint16  currentScreenPixelBlue = 0;
+
+	uint16  limitPixelRed = limitColor & 0xF800;
+	uint16  limitPixelGreen = limitColor & 0x07E0;
+	uint16  limitPixelBlue = limitColor & 0x001F;
+
+	for (screenY = 0; screenY < screenHeight; screenY++) {
+		for (screenX = 0; screenX < screenWidth; screenX++) {
+			currentScreenPixel = *targetScreenPtr;
+
+			currentScreenPixelRed = currentScreenPixel & 0xF800;
+			currentScreenPixelGreen = currentScreenPixel & 0x07E0;
+			currentScreenPixelBlue = currentScreenPixel & 0x001F;
+
+			if (currentScreenPixelRed < limitPixelRed)
+				currentScreenPixelRed = limitPixelRed;
+			if (currentScreenPixelGreen < limitPixelGreen)
+				currentScreenPixelGreen = limitPixelGreen;
+			if (currentScreenPixelBlue < limitPixelBlue)
+				currentScreenPixelBlue = limitPixelBlue;
+
+			uint16 v = currentScreenPixelRed | currentScreenPixelGreen | currentScreenPixelBlue;
+			*currentScreenPtr = v;
+			if (_vm->_isScreenDoubled) {
+				*(currentScreenPtr + 1) = v;
+				*(currentScreenPtr + 640) = v;
+				*(currentScreenPtr + 640 + 1) = v;
+			}
+
+			currentScreenPtr += _vm->_isScreenDoubled ? 2 : 1;
+			targetScreenPtr++;
+		}
+
+		if (_vm->_isScreenDoubled)
+			currentScreenPtr += 640;
+	}
+
+	// Too much considered dirty at the moment
+	if (_vm->_isScreenDoubled)
+		addDirtyRect(Common::Rect(0, 0, screenWidth * 2, screenHeight * 2));
+	else
+		addDirtyRect(Common::Rect(0, 0, screenWidth, screenHeight));
+}
+
+uint16 Scalpel3DOScreen::w() const {
+	return _vm->_isScreenDoubled ? _surface.w / 2 : _surface.w;
+}
+
+uint16 Scalpel3DOScreen::h() const {
+	return _vm->_isScreenDoubled ? _surface.h / 2 : _surface.h;
+}
+
+void Scalpel3DOScreen::rawBlitFrom(const Graphics::Surface &src, const Common::Point &pt) {
+	Common::Rect srcRect(0, 0, src.w, src.h);
+	Common::Rect destRect(pt.x, pt.y, pt.x + src.w, pt.y + src.h);
+
+	addDirtyRect(destRect);
+	_surface.copyRectToSurface(src, destRect.left, destRect.top, srcRect);
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_screen.h b/engines/sherlock/scalpel/scalpel_screen.h
new file mode 100644
index 0000000000..d6018a44a0
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_screen.h
@@ -0,0 +1,104 @@
+/* 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 SHERLOCK_SCALPEL_SCREEN_H
+#define SHERLOCK_SCALPEL_SCREEN_H
+
+#include "sherlock/screen.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Scalpel {
+
+class ScalpelScreen : public Screen {
+public:
+	ScalpelScreen(SherlockEngine *vm);
+	virtual ~ScalpelScreen() {}
+
+	/**
+	 * Draws a button for use in the inventory, talk, and examine dialogs.
+	 */
+	void makeButton(const Common::Rect &bounds, int textX, const Common::String &str);
+
+	/**
+	 * Prints an interface command with the first letter highlighted to indicate
+	 * what keyboard shortcut is associated with it
+	 */
+	void buttonPrint(const Common::Point &pt, uint color, bool slamIt, const Common::String &str);
+
+	/**
+	 * Draw a panel in the back buffer with a raised area effect around the edges
+	 */
+	void makePanel(const Common::Rect &r);
+
+	/**
+	 * Draw a field in the back buffer with a raised area effect around the edges,
+	 * suitable for text input.
+	 */
+	void makeField(const Common::Rect &r);
+};
+
+class Scalpel3DOScreen : public ScalpelScreen {
+protected:
+	/**
+	 * Draws a sub-section of a surface at a given position within this surface
+	 * Overriden for the 3DO to automatically double the size of everything to the underlying 640x400 surface
+	 */
+	virtual void blitFrom(const Graphics::Surface &src, const Common::Point &pt, const Common::Rect &srcBounds);
+
+	/**
+	 * Draws a surface at a given position within this surface with transparency
+	 */
+	virtual void transBlitFromUnscaled(const Graphics::Surface &src, const Common::Point &pt, bool flipped, 
+		int overrideColor);
+public:
+	Scalpel3DOScreen(SherlockEngine *vm) : ScalpelScreen(vm) {}
+	virtual ~Scalpel3DOScreen() {}
+
+	/**
+	 * Draws a sub-section of a surface at a given position within this surface
+	 */
+	void rawBlitFrom(const Graphics::Surface &src, const Common::Point &pt);
+
+	/**
+	 * Fade backbuffer 1 into screen (3DO RGB!)
+	 */
+	void fadeIntoScreen3DO(int speed);
+
+	void blitFrom3DOcolorLimit(uint16 color);
+
+	/**
+	 * Fill a given area of the surface with a given color
+	 */
+	virtual void fillRect(const Common::Rect &r, uint color);
+
+	virtual uint16 w() const;
+	virtual uint16 h() const;
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_talk.cpp b/engines/sherlock/scalpel/scalpel_talk.cpp
new file mode 100644
index 0000000000..2c447b09ab
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_talk.cpp
@@ -0,0 +1,1027 @@
+/* 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 "sherlock/scalpel/scalpel_talk.h"
+#include "sherlock/scalpel/scalpel_fixed_text.h"
+#include "sherlock/scalpel/scalpel_journal.h"
+#include "sherlock/scalpel/scalpel_map.h"
+#include "sherlock/scalpel/scalpel_people.h"
+#include "sherlock/scalpel/scalpel_scene.h"
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "sherlock/scalpel/scalpel_user_interface.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/screen.h"
+#include "sherlock/scalpel/3do/movie_decoder.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+const byte SCALPEL_OPCODES[] = {
+	128,	// OP_SWITCH_SPEAKER
+	129,	// OP_RUN_CANIMATION
+	130,	// OP_ASSIGN_PORTRAIT_LOCATION
+	131,	// OP_PAUSE
+	132,	// OP_REMOVE_PORTRAIT
+	133,	// OP_CLEAR_WINDOW
+	134,	// OP_ADJUST_OBJ_SEQUENCE
+	135,	// OP_WALK_TO_COORDS
+	136,	// OP_PAUSE_WITHOUT_CONTROL
+	137,	// OP_BANISH_WINDOW
+	138,	// OP_SUMMON_WINDOW
+	139,	// OP_SET_FLAG
+	140,	// OP_SFX_COMMAND
+	141,	// OP_TOGGLE_OBJECT
+	142,	// OP_STEALTH_MODE_ACTIVE
+	143,	// OP_IF_STATEMENT
+	144,	// OP_ELSE_STATEMENT
+	145,	// OP_END_IF_STATEMENT
+	146,	// OP_STEALTH_MODE_DEACTIVATE
+	147,	// OP_TURN_HOLMES_OFF
+	148,	// OP_TURN_HOLMES_ON
+	149,	// OP_GOTO_SCENE
+	150,	// OP_PLAY_PROLOGUE
+	151,	// OP_ADD_ITEM_TO_INVENTORY
+	152,	// OP_SET_OBJECT
+	153,	// OP_CALL_TALK_FILE
+	143,	// OP_MOVE_MOUSE
+	155,	// OP_DISPLAY_INFO_LINE
+	156,	// OP_CLEAR_INFO_LINE
+	157,	// OP_WALK_TO_CANIMATION
+	158,	// OP_REMOVE_ITEM_FROM_INVENTORY
+	159,	// OP_ENABLE_END_KEY
+	160,	// OP_DISABLE_END_KEY
+	161,	// OP_END_TEXT_WINDOW
+	0,		// OP_MOUSE_ON_OFF
+	0,		// OP_SET_WALK_CONTROL
+	0,		// OP_SET_TALK_SEQUENCE
+	0,		// OP_PLAY_SONG
+	0,		// OP_WALK_HOLMES_AND_NPC_TO_CANIM
+	0,		// OP_SET_NPC_PATH_DEST
+	0,		// OP_NEXT_SONG
+	0,		// OP_SET_NPC_PATH_PAUSE
+	0,		// OP_PASSWORD
+	0,		// OP_SET_SCENE_ENTRY_FLAG
+	0,		// OP_WALK_NPC_TO_CANIM
+	0,		// OP_WALK_HOLMES_AND_NPC_TO_COORDS
+	0,		// OP_WALK_HOLMES_AND_NPC_TO_COORDS
+	0,		// OP_SET_NPC_TALK_FILE
+	0,		// OP_TURN_NPC_OFF
+	0,		// OP_TURN_NPC_ON
+	0,		// OP_NPC_DESC_ON_OFF
+	0,		// OP_NPC_PATH_PAUSE_TAKING_NOTES
+	0,		// OP_NPC_PATH_PAUSE_LOOKING_HOLMES
+	0,		// OP_ENABLE_TALK_INTERRUPTS
+	0,		// OP_DISABLE_TALK_INTERRUPTS
+	0,		// OP_SET_NPC_INFO_LINE
+	0,		// OP_SET_NPC_POSITION
+	0,		// OP_NPC_PATH_LABEL
+	0,		// OP_PATH_GOTO_LABEL
+	0,		// OP_PATH_IF_FLAG_GOTO_LABEL
+	0,		// OP_NPC_WALK_GRAPHICS
+	0,		// OP_NPC_VERB
+	0,		// OP_NPC_VERB_CANIM
+	0,		// OP_NPC_VERB_SCRIPT
+	0,		// OP_RESTORE_PEOPLE_SEQUENCE
+	0,		// OP_NPC_VERB_TARGET
+	0,		// OP_TURN_SOUNDS_OFF
+	0		// OP_NULL
+};
+
+/*----------------------------------------------------------------*/
+
+ScalpelTalk::ScalpelTalk(SherlockEngine *vm) : Talk(vm) {
+	static OpcodeMethod OPCODE_METHODS[] = {
+		(OpcodeMethod)&ScalpelTalk::cmdSwitchSpeaker,
+		(OpcodeMethod)&ScalpelTalk::cmdRunCAnimation,
+		(OpcodeMethod)&ScalpelTalk::cmdAssignPortraitLocation,
+
+		(OpcodeMethod)&ScalpelTalk::cmdPause,
+		(OpcodeMethod)&ScalpelTalk::cmdRemovePortrait,
+		(OpcodeMethod)&ScalpelTalk::cmdClearWindow,
+		(OpcodeMethod)&ScalpelTalk::cmdAdjustObjectSequence,
+		(OpcodeMethod)&ScalpelTalk::cmdWalkToCoords,
+		(OpcodeMethod)&ScalpelTalk::cmdPauseWithoutControl,
+		(OpcodeMethod)&ScalpelTalk::cmdBanishWindow,
+		(OpcodeMethod)&ScalpelTalk::cmdSummonWindow,
+		(OpcodeMethod)&ScalpelTalk::cmdSetFlag,
+		(OpcodeMethod)&ScalpelTalk::cmdSfxCommand,
+
+		(OpcodeMethod)&ScalpelTalk::cmdToggleObject,
+		(OpcodeMethod)&ScalpelTalk::cmdStealthModeActivate,
+		(OpcodeMethod)&ScalpelTalk::cmdIf,
+		(OpcodeMethod)&ScalpelTalk::cmdElse,
+		nullptr,
+		(OpcodeMethod)&ScalpelTalk::cmdStealthModeDeactivate,
+		(OpcodeMethod)&ScalpelTalk::cmdHolmesOff,
+		(OpcodeMethod)&ScalpelTalk::cmdHolmesOn,
+		(OpcodeMethod)&ScalpelTalk::cmdGotoScene,
+		(OpcodeMethod)&ScalpelTalk::cmdPlayPrologue,
+		
+		(OpcodeMethod)&ScalpelTalk::cmdAddItemToInventory,
+		(OpcodeMethod)&ScalpelTalk::cmdSetObject,
+		(OpcodeMethod)&ScalpelTalk::cmdCallTalkFile,
+		(OpcodeMethod)&ScalpelTalk::cmdMoveMouse,
+		(OpcodeMethod)&ScalpelTalk::cmdDisplayInfoLine,
+		(OpcodeMethod)&ScalpelTalk::cmdClearInfoLine,
+		(OpcodeMethod)&ScalpelTalk::cmdWalkToCAnimation,
+		(OpcodeMethod)&ScalpelTalk::cmdRemoveItemFromInventory,
+		(OpcodeMethod)&ScalpelTalk::cmdEnableEndKey,
+		(OpcodeMethod)&ScalpelTalk::cmdDisableEndKey,
+		
+		(OpcodeMethod)&ScalpelTalk::cmdEndTextWindow,
+		nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+		nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+		nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+		nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+		nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+		nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+		nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr
+	};
+
+	_opcodeTable = OPCODE_METHODS;
+	_opcodes = SCALPEL_OPCODES;
+
+	if (vm->getLanguage() == Common::DE_DEU || vm->getLanguage() == Common::ES_ESP) {
+		// The German and Spanish versions use a different opcode range
+		static byte opcodes[sizeof(SCALPEL_OPCODES)];
+		for (uint idx = 0; idx < sizeof(SCALPEL_OPCODES); ++idx)
+			opcodes[idx] = SCALPEL_OPCODES[idx] ? SCALPEL_OPCODES[idx] + 47 : 0;
+
+		_opcodes = opcodes;
+	}
+
+}
+
+void ScalpelTalk::talkTo(const Common::String filename) {
+	ScalpelUserInterface &ui = *(ScalpelUserInterface *)_vm->_ui;
+
+	Talk::talkTo(filename);
+
+	if (filename == "Tube59c") {
+		// WORKAROUND: Original game bug causes the results of testing the powdery substance
+		// to disappear too quickly. Introduce a delay to allow it to be properly displayed
+		ui._menuCounter = 30;
+	}
+}
+
+void ScalpelTalk::talkInterface(const byte *&str) {
+	FixedText &fixedText = *_vm->_fixedText;
+	People &people = *_vm->_people;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	UserInterface &ui = *_vm->_ui;
+
+	if (_vm->getLanguage() == Common::DE_DEU)
+		skipBadText(str);
+
+	// If the window isn't yet open, draw the window before printing starts
+	if (!ui._windowOpen && _noTextYet) {
+		_noTextYet = false;
+		drawInterface();
+
+		if (_talkTo != -1) {
+			Common::String fixedText_Exit = fixedText.getText(kFixedText_Window_Exit);
+			Common::String fixedText_Up   = fixedText.getText(kFixedText_Window_Up);
+			Common::String fixedText_Down = fixedText.getText(kFixedText_Window_Down);
+			screen.buttonPrint(Common::Point(119, CONTROLS_Y), COMMAND_NULL, false, fixedText_Exit);
+			screen.buttonPrint(Common::Point(159, CONTROLS_Y), COMMAND_NULL, false, fixedText_Up);
+			screen.buttonPrint(Common::Point(200, CONTROLS_Y), COMMAND_NULL, false, fixedText_Down);
+		}
+	}
+
+	// If it's the first line, display the speaker
+	if (!_line && _speaker >= 0 && _speaker < (int)people._characters.size()) {
+		// If the window is open, display the name directly on-screen.
+		// Otherwise, simply draw it on the back buffer
+		if (ui._windowOpen) {
+			screen.print(Common::Point(16, _yp), TALK_FOREGROUND, "%s",
+				people._characters[_speaker & 127]._name);
+		} else {
+			screen.gPrint(Common::Point(16, _yp - 1), TALK_FOREGROUND, "%s",
+				people._characters[_speaker & 127]._name);
+			_openTalkWindow = true;
+		}
+
+		_yp += 9;
+	}
+
+	// Find amount of text that will fit on the line
+	int width = 0, idx = 0;
+	do {
+		width += screen.charWidth(str[idx]);
+		++idx;
+		++_charCount;
+	} while (width < 298 && str[idx] && str[idx] != '{' && (!isOpcode(str[idx])));
+
+	if (str[idx] || width >= 298) {
+		if ((!isOpcode(str[idx])) && str[idx] != '{') {
+			--idx;
+			--_charCount;
+		}
+	} else {
+		_endStr = true;
+	}
+
+	// If word wrap is needed, find the start of the current word
+	if (width >= 298) {
+		while (str[idx] != ' ') {
+			--idx;
+			--_charCount;
+		}
+	}
+
+	// Print the line
+	Common::String lineStr((const char *)str, (const char *)str + idx);
+
+	// If the speaker indicates a description file, print it in yellow
+	if (_speaker != -1) {
+		if (ui._windowOpen) {
+			screen.print(Common::Point(16, _yp), COMMAND_FOREGROUND, "%s", lineStr.c_str());
+		} else {
+			screen.gPrint(Common::Point(16, _yp - 1), COMMAND_FOREGROUND, "%s", lineStr.c_str());
+			_openTalkWindow = true;
+		}
+	} else {
+		if (ui._windowOpen) {
+			screen.print(Common::Point(16, _yp), COMMAND_FOREGROUND, "%s", lineStr.c_str());
+		} else {
+			screen.gPrint(Common::Point(16, _yp - 1), COMMAND_FOREGROUND, "%s", lineStr.c_str());
+			_openTalkWindow = true;
+		}
+	}
+
+	// Move to end of displayed line
+	str += idx;
+
+	// If line wrap occurred, then move to after the separating space between the words
+	if ((!isOpcode(str[0])) && str[0] != '{')
+		++str;
+
+	_yp += 9;
+	++_line;
+
+	// Certain different conditions require a wait
+	if ((_line == 4 && str < _scriptEnd && str[0] != _opcodes[OP_SFX_COMMAND] && str[0] != _opcodes[OP_PAUSE] && _speaker != -1) ||
+		(_line == 5 && str < _scriptEnd && str[0] != _opcodes[OP_PAUSE] && _speaker == -1) ||
+		_endStr) {
+		_wait = 1;
+	}
+
+	byte v = (str >= _scriptEnd ? 0 : str[0]);
+	if (v == _opcodes[OP_SWITCH_SPEAKER] || v == _opcodes[OP_ASSIGN_PORTRAIT_LOCATION] ||
+		v == _opcodes[OP_BANISH_WINDOW] || v == _opcodes[OP_IF_STATEMENT] ||
+		v == _opcodes[OP_ELSE_STATEMENT] || v == _opcodes[OP_END_IF_STATEMENT] ||
+		v == _opcodes[OP_GOTO_SCENE] || v == _opcodes[OP_CALL_TALK_FILE]) {
+		_wait = 1;
+	}
+}
+
+OpcodeReturn ScalpelTalk::cmdSwitchSpeaker(const byte *&str) {
+	ScalpelPeople &people = *(ScalpelPeople *)_vm->_people;
+	UserInterface &ui = *_vm->_ui;
+
+	if (!(_speaker & SPEAKER_REMOVE))
+		people.clearTalking();
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	ui.clearWindow();
+	_yp = CONTROLS_Y + 12;
+	_charCount = _line = 0;
+
+	_speaker = *++str - 1;
+	people.setTalking(_speaker);
+	pullSequence();
+	pushSequence(_speaker);
+	people.setTalkSequence(_speaker);
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdGotoScene(const byte *&str) {
+	ScalpelMap &map = *(ScalpelMap *)_vm->_map;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	scene._goToScene = str[1] - 1;
+
+	if (scene._goToScene != OVERHEAD_MAP) {
+		// Not going to the map overview
+		map._oldCharPoint = scene._goToScene;
+		map._overPos.x = (map[scene._goToScene].x - 6) * FIXED_INT_MULTIPLIER;
+		map._overPos.y = (map[scene._goToScene].y + 9) * FIXED_INT_MULTIPLIER;
+
+		// Run a canimation?
+		if (str[2] > 100) {
+			people._savedPos = PositionFacing(160, 100, str[2]);
+		} else {
+			int32 posX = (str[3] - 1) * 256 + str[4] - 1;
+			int32 posY = str[5] - 1;
+			people._savedPos = PositionFacing(posX, posY, str[2] - 1);
+		}
+	}
+
+	str += 6;
+
+	_scriptMoreFlag = (scene._goToScene == 100) ? 2 : 1;
+	_scriptSaveIndex = str - _scriptStart;
+	_endStr = true;
+	_wait = 0;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdAssignPortraitLocation(const byte *&str) {
+	People &people = *_vm->_people;
+
+	++str;
+	switch (str[0] & 15) {
+	case 1:
+		people._portraitSide = 20;
+		break;
+	case 2:
+		people._portraitSide = 220;
+		break;
+	case 3:
+		people._portraitSide = 120;
+		break;
+	default:
+		break;
+	}
+
+	if (str[0] > 15)
+		people._speakerFlip = true;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdClearInfoLine(const byte *&str) {
+	UserInterface &ui = *_vm->_ui;
+
+	ui._infoFlag = true;
+	ui.clearInfo();
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdClearWindow(const byte *&str) {
+	UserInterface &ui = *_vm->_ui;
+	
+	ui.clearWindow();
+	_yp = CONTROLS_Y + 12;
+	_charCount = _line = 0;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdDisplayInfoLine(const byte *&str) {
+	Screen &screen = *_vm->_screen;
+	UserInterface &ui = *_vm->_ui;
+	Common::String tempString;
+
+	++str;
+	for (int idx = 0; idx < str[0]; ++idx)
+		tempString += str[idx + 1];
+	str += str[0];
+
+	screen.print(Common::Point(0, INFO_LINE + 1), INFO_FOREGROUND, "%s", tempString.c_str());
+	ui._menuCounter = 30;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdElse(const byte *&str) {
+	// If this is encountered here, it means that a preceeding IF statement was found,
+	// and evaluated to true. Now all the statements for the true block are finished,
+	// so skip over the block of code that would have executed if the result was false
+	_wait = 0;
+	do {
+		++str;
+	} while (str[0] && str[0] != _opcodes[OP_END_IF_STATEMENT]);
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdIf(const byte *&str) {
+	++str;
+	int flag = (str[0] - 1) * 256 + str[1] - 1 - (str[1] == 1 ? 1 : 0);
+	++str;
+	_wait = 0;
+
+	bool result = flag < 0x8000;
+	if (_vm->readFlags(flag & 0x7fff) != result) {
+		do {
+			++str;
+		} while (str[0] && str[0] != _opcodes[OP_ELSE_STATEMENT] && str[0] != _opcodes[OP_END_IF_STATEMENT]);
+
+		if (!str[0])
+			_endStr = true;
+	}
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdMoveMouse(const byte *&str) {
+	Events &events = *_vm->_events;
+
+	++str;
+	events.warpMouse(Common::Point((str[0] - 1) * 256 + str[1] - 1, str[2]));
+	if (_talkToAbort)
+		return RET_EXIT;
+	str += 3;
+	
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdPlayPrologue(const byte *&str) {
+	Animation &anim = *_vm->_animation;
+	Common::String tempString;
+
+	++str;
+	for (int idx = 0; idx < 8 && str[idx] != '~'; ++idx)
+		tempString += str[idx];
+
+	anim.play(tempString, false, 1, 3, true, 4);
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdRemovePortrait(const byte *&str) {
+	People &people = *_vm->_people;
+
+	if (_speaker >= 0 && _speaker < SPEAKER_REMOVE)
+		people.clearTalking();
+	pullSequence();
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	_speaker |= SPEAKER_REMOVE;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdWalkToCoords(const byte *&str) {
+	People &people = *_vm->_people;
+	++str;
+
+	people[HOLMES].walkToCoords(Point32(((str[0] - 1) * 256 + str[1] - 1) * FIXED_INT_MULTIPLIER,
+		str[2] * FIXED_INT_MULTIPLIER), str[3] - 1);
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	str += 3;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdSfxCommand(const byte *&str) {
+	Sound &sound = *_vm->_sound;
+	Common::String tempString;
+
+	++str;
+	if (sound._voices) {
+		for (int idx = 0; idx < 8 && str[idx] != '~'; ++idx)
+			tempString += str[idx];
+		sound.playSpeech(tempString);
+
+		// Set voices to wait for more
+		sound._voices = 2;
+	}
+
+	_wait = 1;
+	str += 7;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn ScalpelTalk::cmdSummonWindow(const byte *&str) {
+	Events       &events = *_vm->_events;
+	FixedText &fixedText = *_vm->_fixedText;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+
+	drawInterface();
+	events._pressed = events._released = false;
+	events.clearKeyboard();
+	_noTextYet = false;
+
+	if (_speaker != -1) {
+		Common::String fixedText_Exit = fixedText.getText(kFixedText_Window_Exit);
+		Common::String fixedText_Up   = fixedText.getText(kFixedText_Window_Up);
+		Common::String fixedText_Down = fixedText.getText(kFixedText_Window_Down);
+		screen.buttonPrint(Common::Point(119, CONTROLS_Y), COMMAND_NULL, false, fixedText_Exit);
+		screen.buttonPrint(Common::Point(159, CONTROLS_Y), COMMAND_NULL, false, fixedText_Up);
+		screen.buttonPrint(Common::Point(200, CONTROLS_Y), COMMAND_NULL, false, fixedText_Down);
+	}
+
+	return RET_SUCCESS;
+}
+
+void ScalpelTalk::loadTalkFile(const Common::String &filename) {
+	Talk::loadTalkFile(filename);
+	_3doSpeechIndex = 0;
+}
+
+void ScalpelTalk::talkWait(const byte *&str) {
+	UserInterface &ui = *_vm->_ui;
+	bool pauseFlag = _pauseFlag;
+
+	Talk::talkWait(str);
+
+	// Clear the window unless the wait was due to a PAUSE command
+	if (!pauseFlag && _wait != -1 && str < _scriptEnd && str[0] != _opcodes[OP_SFX_COMMAND]) {
+		if (!_talkStealth)
+			ui.clearWindow();
+		_yp = CONTROLS_Y + 12;
+		_charCount = _line = 0;
+	}
+}
+
+void ScalpelTalk::nothingToSay() {
+	error("Character had no talk options available");
+}
+
+void ScalpelTalk::switchSpeaker() {
+}
+
+int ScalpelTalk::waitForMore(int delay) {
+	Events &events = *_vm->_events;
+
+	if (!IS_3DO) {
+		return Talk::waitForMore(delay);
+	}
+
+	// Hide the cursor
+	events.hideCursor();
+	events.wait(1);
+
+	switchSpeaker();
+
+	// Play the video
+	talk3DOMovieTrigger(_3doSpeechIndex++);
+
+	// Adjust _talkStealth mode:
+	// mode 1 - It was by a pause without stealth being on before the pause, so reset back to 0
+	// mode 3 - It was set by a pause with stealth being on before the pause, to set it to active
+	// mode 0/2 (Inactive/active) No change
+	switch (_talkStealth) {
+	case 1:
+		_talkStealth = 0;
+		break;
+	case 2:
+		_talkStealth = 2;
+		break;
+	default:
+		break;
+	}
+
+	events.showCursor();
+	events._pressed = events._released = false;
+
+	return 254;
+}
+
+bool ScalpelTalk::talk3DOMovieTrigger(int subIndex) {
+	ScalpelEngine &vm = *(ScalpelEngine *)_vm;
+	Screen &screen = *_vm->_screen;
+
+	// Find out a few things that we need
+	int userSelector = _vm->_ui->_selector;
+	int scriptSelector = _scriptSelect;
+	int selector = 0;
+	int roomNr = _vm->_scene->_currentScene;
+
+	if (userSelector >= 0) {
+		// User-selected dialog
+		selector = userSelector;
+	} else {
+		if (scriptSelector >= 0) {
+			// Script-selected dialog
+			selector = scriptSelector;
+		} else {
+			warning("talk3DOMovieTrigger: unable to find selector");
+			return true;
+		}
+	}
+
+	// Make a quick update, so that current text is shown on screen
+	screen.update();
+
+	// Figure out that movie filename
+	Common::String movieFilename;
+
+	movieFilename = _scriptName;
+	movieFilename.deleteChar(1); // remove 2nd character of scriptname
+	// cut scriptname to 6 characters
+	while (movieFilename.size() > 6) {
+		movieFilename.deleteChar(6);
+	}
+
+	movieFilename.insertChar(selector + 'a', movieFilename.size());
+	movieFilename.insertChar(subIndex + 'a', movieFilename.size());
+	movieFilename = Common::String::format("movies/%02d/%s.stream", roomNr, movieFilename.c_str());
+
+	warning("3DO movie player:");
+	warning("room: %d", roomNr);
+	warning("script: %s", _scriptName.c_str());
+	warning("selector: %d", selector);
+	warning("subindex: %d", subIndex);
+
+	bool result = vm.play3doMovie(movieFilename, get3doPortraitPosition(), true);
+
+	// Restore screen HACK
+	_vm->_screen->makeAllDirty();
+
+	return result;
+}
+
+Common::Point ScalpelTalk::get3doPortraitPosition() const {
+	// TODO: This current method is only an assumption of how the original figured 
+	// out where to place each character's portrait movie.
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	const int PORTRAIT_W = 100;
+	const int PORTRAIT_H = 76;
+
+	if (_speaker == -1)
+		return Common::Point();
+
+	// Get the position of the character
+	Common::Point pt;
+	if (_speaker == HOLMES) {
+		pt = Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER,
+			people[HOLMES]._position.y / FIXED_INT_MULTIPLIER);
+	} else {
+		int objNum = people.findSpeaker(_speaker);
+		if (objNum == -1)
+			return Common::Point();
+
+		pt = scene._bgShapes[objNum]._position;
+	}
+	
+	// Adjust the top-left so the center of the portrait will be on the character,
+	// but ensure the portrait will be entirely on-screen
+	pt -= Common::Point(PORTRAIT_W / 2, PORTRAIT_H / 2);
+	pt.x = CLIP((int)pt.x, 10, SHERLOCK_SCREEN_WIDTH - 10 - PORTRAIT_W);
+	pt.y = CLIP((int)pt.y, 10, CONTROLS_Y - PORTRAIT_H - 10);
+
+	return pt;
+}
+
+void ScalpelTalk::drawInterface() {
+	FixedText &fixedText = *_vm->_fixedText;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	Surface &bb = *screen._backBuffer;
+
+	bb.fillRect(Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH, CONTROLS_Y1 + 10), BORDER_COLOR);
+	bb.fillRect(Common::Rect(0, CONTROLS_Y + 10, 2, SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+	bb.fillRect(Common::Rect(SHERLOCK_SCREEN_WIDTH - 2, CONTROLS_Y + 10,
+		SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+	bb.fillRect(Common::Rect(0, SHERLOCK_SCREEN_HEIGHT - 1, SHERLOCK_SCREEN_WIDTH - 2,
+		SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+	bb.fillRect(Common::Rect(2, CONTROLS_Y + 10, SHERLOCK_SCREEN_WIDTH - 2,
+		SHERLOCK_SCREEN_HEIGHT - 2), INV_BACKGROUND);
+
+	if (_talkTo != -1) {
+		Common::String fixedText_Exit = fixedText.getText(kFixedText_Window_Exit);
+		Common::String fixedText_Up   = fixedText.getText(kFixedText_Window_Up);
+		Common::String fixedText_Down = fixedText.getText(kFixedText_Window_Down);
+
+		screen.makeButton(Common::Rect(99, CONTROLS_Y, 139, CONTROLS_Y + 10),
+			119 - screen.stringWidth(fixedText_Exit) / 2, fixedText_Exit);
+		screen.makeButton(Common::Rect(140, CONTROLS_Y, 180, CONTROLS_Y + 10),
+			159 - screen.stringWidth(fixedText_Up) / 2, fixedText_Up);
+		screen.makeButton(Common::Rect(181, CONTROLS_Y, 221, CONTROLS_Y + 10),
+			200 - screen.stringWidth(fixedText_Down) / 2, fixedText_Down);
+	} else {
+		Common::String fixedText_PressKeyToContinue = fixedText.getText(kFixedText_PressKey_ToContinue);
+		Common::String fixedText_PressKeyToContinueHotkey = fixedText.getText(kFixedText_PressKey_ToContinueHotkey);
+		int fixedText_PressKeyToContinueLen = screen.stringWidth(fixedText_PressKeyToContinue);
+
+		screen.makeButton(Common::Rect(46, CONTROLS_Y, 273, CONTROLS_Y + 10),
+			160 - fixedText_PressKeyToContinueLen / 2, fixedText_PressKeyToContinue);
+		screen.gPrint(Common::Point(160 - fixedText_PressKeyToContinueLen / 2, CONTROLS_Y), COMMAND_FOREGROUND, 
+			"%s", fixedText_PressKeyToContinueHotkey.c_str());
+	}
+}
+
+bool ScalpelTalk::displayTalk(bool slamIt) {
+	FixedText &fixedText = *_vm->_fixedText;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	int yp = CONTROLS_Y + 14;
+	int lineY = -1;
+	_moreTalkDown = _moreTalkUp = false;
+
+	for (uint idx = 0; idx < _statements.size(); ++idx) {
+		_statements[idx]._talkPos.top = _statements[idx]._talkPos.bottom = -1;
+	}
+
+	if (_talkIndex) {
+		for (int idx = 0; idx < _talkIndex && !_moreTalkUp; ++idx) {
+			if (_statements[idx]._talkMap != -1)
+				_moreTalkUp = true;
+		}
+	}
+
+	// Display the up arrow and enable Up button if the first option is scrolled off-screen
+	Common::String fixedText_Up   = fixedText.getText(kFixedText_Window_Up);
+	Common::String fixedText_Down = fixedText.getText(kFixedText_Window_Down);
+	if (_moreTalkUp) {
+		if (slamIt) {
+			screen.print(Common::Point(5, CONTROLS_Y + 13), INV_FOREGROUND, "~");
+			screen.buttonPrint(Common::Point(159, CONTROLS_Y), COMMAND_FOREGROUND, true, fixedText_Up);
+		} else {
+			screen.gPrint(Common::Point(5, CONTROLS_Y + 12), INV_FOREGROUND, "~");
+			screen.buttonPrint(Common::Point(159, CONTROLS_Y), COMMAND_FOREGROUND, false, fixedText_Up);
+		}
+	} else {
+		if (slamIt) {
+			screen.buttonPrint(Common::Point(159, CONTROLS_Y), COMMAND_NULL, true, fixedText_Up);
+			screen.vgaBar(Common::Rect(5, CONTROLS_Y + 11, 15, CONTROLS_Y + 22), INV_BACKGROUND);
+		} else {
+			screen.buttonPrint(Common::Point(159, CONTROLS_Y), COMMAND_NULL, false, fixedText_Up);
+			screen._backBuffer1.fillRect(Common::Rect(5, CONTROLS_Y + 11,
+				15, CONTROLS_Y + 22), INV_BACKGROUND);
+		}
+	}
+
+	// Loop through the statements
+	bool done = false;
+	for (uint idx = _talkIndex; idx < _statements.size() && !done; ++idx) {
+		Statement &statement = _statements[idx];
+
+		if (statement._talkMap != -1) {
+			bool flag = _talkHistory[_converseNum][idx];
+			lineY = talkLine(idx, statement._talkMap, flag ? (byte)TALK_NULL : (byte)INV_FOREGROUND,
+				yp, slamIt);
+
+			if (lineY != -1) {
+				statement._talkPos.top = yp;
+				yp = lineY;
+				statement._talkPos.bottom = yp;
+
+				if (yp == SHERLOCK_SCREEN_HEIGHT)
+					done = true;
+			} else {
+				done = true;
+			}
+		}
+	}
+
+	// Display the down arrow and enable down button if there are more statements available down off-screen
+	if (lineY == -1 || lineY == SHERLOCK_SCREEN_HEIGHT) {
+		_moreTalkDown = true;
+
+		if (slamIt) {
+			screen.print(Common::Point(5, 190), INV_FOREGROUND, "|");
+			screen.buttonPrint(Common::Point(200, CONTROLS_Y), COMMAND_FOREGROUND, true, fixedText_Down);
+		} else {
+			screen.gPrint(Common::Point(5, 189), INV_FOREGROUND, "|");
+			screen.buttonPrint(Common::Point(200, CONTROLS_Y), COMMAND_FOREGROUND, false, fixedText_Down);
+		}
+	} else {
+		if (slamIt) {
+			screen.buttonPrint(Common::Point(200, CONTROLS_Y), COMMAND_NULL, true, fixedText_Down);
+			screen.vgaBar(Common::Rect(5, 189, 16, 199), INV_BACKGROUND);
+		} else {
+			screen.buttonPrint(Common::Point(200, CONTROLS_Y), COMMAND_NULL, false, fixedText_Down);
+			screen._backBuffer1.fillRect(Common::Rect(5, 189, 16, 199), INV_BACKGROUND);
+		}
+	}
+
+	return done;
+}
+
+int ScalpelTalk::talkLine(int lineNum, int stateNum, byte color, int lineY, bool slamIt) {
+	Screen &screen = *_vm->_screen;
+	int idx = lineNum;
+	Common::String msg, number;
+	bool numberFlag = false;
+
+	// Get the statement to display as well as optional number prefix
+	if (idx < SPEAKER_REMOVE) {
+		number = Common::String::format("%d.", stateNum + 1);
+		numberFlag = true;
+	} else {
+		idx -= SPEAKER_REMOVE;
+	}
+	msg = _statements[idx]._statement;
+
+	// Handle potentially multiple lines needed to display entire statement
+	const char *lineStartP = msg.c_str();
+	int maxWidth = 298 - (numberFlag ? 18 : 0);
+	for (;;) {
+		// Get as much of the statement as possible will fit on the
+		Common::String sLine;
+		const char *lineEndP = lineStartP;
+		int width = 0;
+		do {
+			width += screen.charWidth(*lineEndP);
+		} while (*++lineEndP && width < maxWidth);
+
+		// Check if we need to wrap the line
+		if (width >= maxWidth) {
+			// Work backwards to the prior word's end
+			while (*--lineEndP != ' ')
+				;
+
+			sLine = Common::String(lineStartP, lineEndP++);
+		} else {
+			// Can display remainder of the statement on the current line
+			sLine = Common::String(lineStartP);
+		}
+
+
+		if (lineY <= (SHERLOCK_SCREEN_HEIGHT - 10)) {
+			// Need to directly display on-screen?
+			if (slamIt) {
+				// See if a numer prefix is needed or not
+				if (numberFlag) {
+					// Are we drawing the first line?
+					if (lineStartP == msg.c_str()) {
+						// We are, so print the number and then the text
+						screen.print(Common::Point(16, lineY), color, "%s", number.c_str());
+					}
+
+					// Draw the line with an indent
+					screen.print(Common::Point(30, lineY), color, "%s", sLine.c_str());
+				} else {
+					screen.print(Common::Point(16, lineY), color, "%s", sLine.c_str());
+				}
+			} else {
+				if (numberFlag) {
+					if (lineStartP == msg.c_str()) {
+						screen.gPrint(Common::Point(16, lineY - 1), color, "%s", number.c_str());
+					}
+
+					screen.gPrint(Common::Point(30, lineY - 1), color, "%s", sLine.c_str());
+				} else {
+					screen.gPrint(Common::Point(16, lineY - 1), color, "%s", sLine.c_str());
+				}
+			}
+
+			// Move to next line, if any
+			lineY += 9;
+			lineStartP = lineEndP;
+
+			if (!*lineEndP)
+				break;
+		} else {
+			// We're close to the bottom of the screen, so stop display
+			lineY = -1;
+			break;
+		}
+	}
+
+	if (lineY == -1 && lineStartP != msg.c_str())
+		lineY = SHERLOCK_SCREEN_HEIGHT;
+
+	// Return the Y position of the next line to follow this one
+	return lineY;
+}
+
+void ScalpelTalk::showTalk() {
+	FixedText &fixedText = *_vm->_fixedText;
+	People &people = *_vm->_people;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	ScalpelUserInterface &ui = *(ScalpelUserInterface *)_vm->_ui;
+	Common::String fixedText_Exit = fixedText.getText(kFixedText_Window_Exit);
+	byte color = ui._endKeyActive ? COMMAND_FOREGROUND : COMMAND_NULL;
+
+	clearSequences();
+	pushSequence(_talkTo);
+	people.setListenSequence(_talkTo);
+
+	ui._selector = ui._oldSelector = -1;
+
+	if (!ui._windowOpen) {
+		// Draw the talk interface on the back buffer
+		drawInterface();
+		displayTalk(false);
+	} else {
+		displayTalk(true);
+	}
+
+	// If the window is already open, simply draw. Otherwise, do it
+	// to the back buffer and then summon the window
+	if (ui._windowOpen) {
+		screen.buttonPrint(Common::Point(119, CONTROLS_Y), color, true, fixedText_Exit);
+	} else {
+		screen.buttonPrint(Common::Point(119, CONTROLS_Y), color, false, fixedText_Exit);
+
+		if (!ui._slideWindows) {
+			screen.slamRect(Common::Rect(0, CONTROLS_Y,
+				SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+		} else {
+			ui.summonWindow();
+		}
+
+		ui._windowOpen = true;
+	}
+}
+
+OpcodeReturn ScalpelTalk::cmdCallTalkFile(const byte *&str) {
+	Common::String tempString;
+
+	++str;
+	for (int idx = 0; idx < 8 && str[idx] != '~'; ++idx)
+		tempString += str[idx];
+	str += 8;
+
+	int scriptCurrentIndex = str - _scriptStart;
+
+	// Save the current script position and new talk file
+	if (_scriptStack.size() < 9) {
+		ScriptStackEntry rec1;
+		rec1._name = _scriptName;
+		rec1._currentIndex = scriptCurrentIndex;
+		rec1._select = _scriptSelect;
+		_scriptStack.push(rec1);
+
+		// Push the new talk file onto the stack
+		ScriptStackEntry rec2;
+		rec2._name = tempString;
+		rec2._currentIndex = 0;
+		rec2._select = 100;
+		_scriptStack.push(rec2);
+	} else {
+		error("Script stack overflow");
+	}
+
+	_scriptMoreFlag = 1;
+	_endStr = true;
+	_wait = 0;
+
+	return RET_SUCCESS;
+}
+
+void ScalpelTalk::pushSequenceEntry(Object *obj) {
+	Scene &scene = *_vm->_scene;
+	SequenceEntry seqEntry;
+	seqEntry._objNum = scene._bgShapes.indexOf(*obj);
+
+	if (seqEntry._objNum != -1) {
+		for (uint idx = 0; idx < MAX_TALK_SEQUENCES; ++idx)
+			seqEntry._sequences.push_back(obj->_sequences[idx]);
+
+		seqEntry._frameNumber = obj->_frameNumber;
+		seqEntry._seqTo = obj->_seqTo;
+	}
+
+	_sequenceStack.push(seqEntry);
+	if (_scriptStack.size() >= 5)
+		error("script stack overflow");
+}
+
+void ScalpelTalk::pullSequence(int slot) {
+	Scene &scene = *_vm->_scene;
+
+	if (_sequenceStack.empty())
+		return;
+
+	SequenceEntry seq = _sequenceStack.pop();
+	if (seq._objNum != -1) {
+		Object &obj = scene._bgShapes[seq._objNum];
+
+		if (obj._seqSize < MAX_TALK_SEQUENCES) {
+			warning("Tried to restore too few frames");
+		} else {
+			for (int idx = 0; idx < MAX_TALK_SEQUENCES; ++idx)
+				obj._sequences[idx] = seq._sequences[idx];
+
+			obj._frameNumber = seq._frameNumber;
+			obj._seqTo = seq._seqTo;
+		}
+	}
+}
+
+void ScalpelTalk::clearSequences() {
+	_sequenceStack.clear();
+}
+
+void ScalpelTalk::skipBadText(const byte *&msgP) {
+	// WORKAROUND: Skip over bad text in the original game
+	const char *BAD_PHRASE1 = "Change Speaker to Sherlock Holmes ";
+
+	if (!strncmp((const char *)msgP, BAD_PHRASE1, strlen(BAD_PHRASE1)))
+		msgP += strlen(BAD_PHRASE1);
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_talk.h b/engines/sherlock/scalpel/scalpel_talk.h
new file mode 100644
index 0000000000..3ba61dadc1
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_talk.h
@@ -0,0 +1,165 @@
+/* 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 SHERLOCK_SCALPEL_TALK_H
+#define SHERLOCK_SCALPEL_TALK_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/rect.h"
+#include "common/serializer.h"
+#include "common/stream.h"
+#include "common/stack.h"
+#include "sherlock/talk.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+class ScalpelTalk : public Talk {
+private:
+	Common::Stack<SequenceEntry> _sequenceStack;
+
+	/**
+	 * Get the center position for the current speaker, if any
+	 */
+	Common::Point get3doPortraitPosition() const;
+
+	OpcodeReturn cmdSwitchSpeaker(const byte *&str);
+	OpcodeReturn cmdAssignPortraitLocation(const byte *&str);
+	OpcodeReturn cmdGotoScene(const byte *&str);
+	OpcodeReturn cmdCallTalkFile(const byte *&str);
+	OpcodeReturn cmdClearInfoLine(const byte *&str);
+	OpcodeReturn cmdClearWindow(const byte *&str);
+	OpcodeReturn cmdDisplayInfoLine(const byte *&str);
+	OpcodeReturn cmdElse(const byte *&str);
+	OpcodeReturn cmdIf(const byte *&str);
+	OpcodeReturn cmdMoveMouse(const byte *&str);
+	OpcodeReturn cmdPlayPrologue(const byte *&str);
+	OpcodeReturn cmdRemovePortrait(const byte *&str);
+	OpcodeReturn cmdSfxCommand(const byte *&str);
+	OpcodeReturn cmdSummonWindow(const byte *&str);
+	OpcodeReturn cmdWalkToCoords(const byte *&str);
+protected:
+	/**
+	 * Display the talk interface window
+	 */
+	virtual void talkInterface(const byte *&str);
+
+	/**
+	 * Pause when displaying a talk dialog on-screen
+	 */
+	virtual void talkWait(const byte *&str);
+
+	/**
+	 * Called when the active speaker is switched
+	 */
+	virtual void switchSpeaker();
+
+	/**
+	 * Called when a character being spoken to has no talk options to display
+	 */
+	virtual void nothingToSay();
+
+	/**
+	 * Show the talk display
+	 */
+	virtual void showTalk();
+public:
+	ScalpelTalk(SherlockEngine *vm);
+	virtual ~ScalpelTalk() {}
+
+	/**
+	 * Opens the talk file 'talk.tlk' and searches the index for the specified
+	 * conversation. If found, the data for that conversation is loaded
+	 */
+	virtual void loadTalkFile(const Common::String &filename);
+
+	/**
+	 * Called whenever a conversation or item script needs to be run. For standard conversations,
+	 * it opens up a description window similar to how 'talk' does, but shows a 'reply' directly
+	 * instead of waiting for a statement option.
+	 * @remarks		It seems that at some point, all item scripts were set up to use this as well.
+	 *	In their case, the conversation display is simply suppressed, and control is passed on to
+	 *	doScript to implement whatever action is required.
+	 */
+	virtual void talkTo(const Common::String filename);
+
+	/**
+	 * When the talk window has been displayed, waits a period of time proportional to
+	 * the amount of text that's been displayed
+	 */
+	virtual int waitForMore(int delay);
+
+	/**
+	 * Draws the interface for conversation display
+	 */
+	void drawInterface();
+
+	/**
+	 * Display a list of statements in a window at the bottom of the screen that the
+	 * player can select from.
+	 */
+	bool displayTalk(bool slamIt);
+
+	/**
+	 * Prints a single conversation option in the interface window
+	 */
+	int talkLine(int lineNum, int stateNum, byte color, int lineY, bool slamIt);
+
+	/**
+	 * Trigger to play a 3DO talk dialog movie
+	 */
+	bool talk3DOMovieTrigger(int subIndex);
+
+	/**
+	 * Handles skipping over bad text in conversations
+	 */
+	static void skipBadText(const byte *&msgP);
+
+	/**
+	 * Push the details of a passed object onto the saved sequences stack
+	 */
+	virtual void pushSequenceEntry(Object *obj);
+
+	/**
+	 * Pulls a background object sequence from the sequence stack and restore's the
+	 * object's sequence
+	 */
+	virtual void pullSequence(int slot = -1);
+
+	/**
+	 * Returns true if the script stack is empty
+	 */
+	virtual bool isSequencesEmpty() const { return _sequenceStack.empty(); }
+
+	/**
+	 * Clears the stack of pending object sequences associated with speakers in the scene
+	 */
+	virtual void clearSequences();
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/scalpel_user_interface.cpp b/engines/sherlock/scalpel/scalpel_user_interface.cpp
new file mode 100644
index 0000000000..79d74ba999
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_user_interface.cpp
@@ -0,0 +1,2215 @@
+/* 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 "sherlock/scalpel/scalpel_user_interface.h"
+#include "sherlock/scalpel/scalpel_fixed_text.h"
+#include "sherlock/scalpel/scalpel_inventory.h"
+#include "sherlock/scalpel/scalpel_journal.h"
+#include "sherlock/scalpel/scalpel_people.h"
+#include "sherlock/scalpel/scalpel_saveload.h"
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "sherlock/scalpel/scalpel_talk.h"
+#include "sherlock/scalpel/settings.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/sherlock.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+// Main user interface menu control locations
+const int MENU_POINTS[12][4] = {
+	{ 13, 153, 72, 165 },
+	{ 13, 169, 72, 181 },
+	{ 13, 185, 72, 197 },
+	{ 88, 153, 152, 165 },
+	{ 88, 169, 152, 181 },
+	{ 88, 185, 152, 197 },
+	{ 165, 153, 232, 165 },
+	{ 165, 169, 232, 181 },
+	{ 165, 185, 233, 197 },
+	{ 249, 153, 305, 165 },
+	{ 249, 169, 305, 181 },
+	{ 249, 185, 305, 197 }
+};
+
+// Inventory control locations */
+const int INVENTORY_POINTS[8][3] = {
+	{ 4, 50, 29 },
+	{ 52, 99, 77 },
+	{ 101, 140, 123 },
+	{ 142, 187, 166 },
+	{ 189, 219, 198 },
+	{ 221, 251, 234 },
+	{ 253, 283, 266 },
+	{ 285, 315, 294 }
+};
+
+const char COMMANDS[13] = "LMTPOCIUGJFS";
+const char COMMANDS_3DO[13] = "LMTPOCIUGSFF";
+const char INVENTORY_COMMANDS[9] = { "ELUG-+,." };
+const int UI_OFFSET_3DO = 16;	// (320 - 288) / 2
+
+/*----------------------------------------------------------------*/
+
+
+ScalpelUserInterface::ScalpelUserInterface(SherlockEngine *vm): UserInterface(vm) {
+	if (_vm->_interactiveFl) {
+		if (!IS_3DO) {
+			// PC
+			_controls = new ImageFile("menu.all");
+			_controlPanel = new ImageFile("controls.vgs");
+		} else {
+			// 3DO
+			_controls = new ImageFile3DO("menu.all", kImageFile3DOType_RoomFormat);
+			_controlPanel = new ImageFile3DO("controls.vgs", kImageFile3DOType_RoomFormat);
+		}
+	} else {
+		_controls = nullptr;
+		_controlPanel = nullptr;
+	}
+
+	_keyPress = '\0';
+	_lookHelp = 0;
+	_help = _oldHelp = 0;
+	_key = _oldKey = '\0';
+	_temp = _oldTemp = 0;
+	_oldLook = 0;
+	_keyboardInput = false;
+	_pause = false;
+	_cNum = 0;
+	_find = 0;
+	_oldUse = 0;
+}
+
+ScalpelUserInterface::~ScalpelUserInterface() {
+	delete _controls;
+	delete _controlPanel;
+}
+
+void ScalpelUserInterface::reset() {
+	UserInterface::reset();
+	_help = _oldHelp = -1;
+}
+
+void ScalpelUserInterface::drawInterface(int bufferNum) {
+	Screen &screen = *_vm->_screen;
+
+	const ImageFrame &src = (*_controlPanel)[0];
+	int16 x = (!IS_3DO) ? 0 : UI_OFFSET_3DO;
+
+	if (bufferNum & 1) {
+		if (IS_3DO)
+			screen._backBuffer1.fillRect(Common::Rect(0, CONTROLS_Y,
+				SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT), BLACK);
+		screen._backBuffer1.transBlitFrom(src, Common::Point(x, CONTROLS_Y));
+	}
+	if (bufferNum & 2) {
+		if (IS_3DO)
+			screen._backBuffer2.fillRect(Common::Rect(0, CONTROLS_Y,
+				SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT), BLACK);
+		screen._backBuffer2.transBlitFrom(src, Common::Point(x, CONTROLS_Y));
+	}
+	if (bufferNum == 3)
+		screen._backBuffer2.fillRect(0, INFO_LINE, SHERLOCK_SCREEN_WIDTH, INFO_LINE + 10, INFO_BLACK);
+}
+
+void ScalpelUserInterface::handleInput() {
+	Events &events = *_vm->_events;
+	Inventory &inv = *_vm->_inventory;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+
+	if (_menuCounter)
+		whileMenuCounter();
+
+	Common::Point pt = events.mousePos();
+	_bgFound = scene.findBgShape(pt);
+	_keyPress = '\0';
+
+	// Check kbd and set the mouse released flag if Enter or space is pressed.
+	// Otherwise, the pressed _key is stored for later use
+	if (events.kbHit()) {
+		Common::KeyState keyState = events.getKey();
+		_keyPress = keyState.ascii;
+
+		if (keyState.keycode == Common::KEYCODE_x && keyState.flags & Common::KBD_ALT) {
+			_vm->quitGame();
+			events.pollEvents();
+			return;
+		}
+	}
+
+	// Do button highlighting check
+	if (!talk._scriptMoreFlag) {	// Don't if scripts are running
+		if (((events._rightPressed || events._rightReleased) && _helpStyle) ||
+				(!_helpStyle && !_menuCounter)) {
+			// Handle any default commands if we're in STD_MODE
+			if (_menuMode == STD_MODE) {
+				if (pt.y < CONTROLS_Y &&
+					(events._rightPressed || (!_helpStyle && !events._released)) &&
+					(_bgFound != -1) && (_bgFound < 1000) &&
+					(scene._bgShapes[_bgFound]._defaultCommand ||
+					!scene._bgShapes[_bgFound]._description.empty())) {
+					// If there is no default command, so set it to Look
+					if (scene._bgShapes[_bgFound]._defaultCommand)
+						_help = scene._bgShapes[_bgFound]._defaultCommand - 1;
+					else
+						_help = 0;
+
+					// Reset 'help' if it is an invalid command
+					if (_help > 5)
+						_help = -1;
+				} else if (pt.y < CONTROLS_Y &&
+					((events._rightReleased && _helpStyle) || (events._released && !_helpStyle)) &&
+					(_bgFound != -1 && _bgFound < 1000) &&
+					(scene._bgShapes[_bgFound]._defaultCommand ||
+					!scene._bgShapes[_bgFound]._description.empty())) {
+					// If there is no default command, set it to Look
+					if (scene._bgShapes[_bgFound]._defaultCommand)
+						_menuMode = (MenuMode)scene._bgShapes[_bgFound]._defaultCommand;
+					else
+						_menuMode = LOOK_MODE;
+					events._released = true;
+					events._pressed = events._oldButtons = false;
+					_help = _oldHelp = -1;
+
+					if (_menuMode == LOOK_MODE) {
+						// Set the flag to tell the game that this was a right-click
+						// call to look and should exit without the look button being pressed
+						_lookHelp = true;
+					}
+				} else {
+					_help = -1;
+				}
+
+				// Check if highlighting a different button than last time
+				if (_help != _oldHelp) {
+					// If another button was highlighted previously, restore it
+					if (_oldHelp != -1)
+						restoreButton(_oldHelp);
+
+					// If we're highlighting a new button, then draw it pressed
+					if (_help != -1)
+						depressButton(_help);
+
+					_oldHelp = _help;
+				}
+
+				if (_bgFound != _oldBgFound || _oldBgFound == -1) {
+					_infoFlag = true;
+					clearInfo();
+
+					if (_help != -1 && !scene._bgShapes[_bgFound]._description.empty()
+							&& scene._bgShapes[_bgFound]._description[0] != ' ')
+						screen.print(Common::Point(0, INFO_LINE + 1),
+						INFO_FOREGROUND, "%s", scene._bgShapes[_bgFound]._description.c_str());
+
+					_oldBgFound = _bgFound;
+				}
+			} else {
+				// We're not in STD_MODE
+				// If there isn't a window open, then revert back to STD_MODE
+				if (!_windowOpen && events._rightReleased) {
+					// Restore all buttons
+					for (int idx = 0; idx < 12; ++idx)
+						restoreButton(idx);
+
+					_menuMode = STD_MODE;
+					_key = _oldKey = -1;
+					_temp = _oldTemp = _lookHelp = _invLookFlag = 0;
+					events.clearEvents();
+				}
+			}
+		}
+	}
+
+	// Reset the old bgshape number if the mouse button is released, so that
+	// it can e re-highlighted when we come back here
+	if ((events._rightReleased && _helpStyle) || (events._released && !_helpStyle))
+		_oldBgFound = -1;
+
+	// Do routines that should be done before input processing
+	switch (_menuMode) {
+	case LOOK_MODE:
+		if (!_windowOpen) {
+			if (events._released && _bgFound >= 0 && _bgFound < 1000) {
+				if (!scene._bgShapes[_bgFound]._examine.empty())
+					examine();
+			} else {
+				lookScreen(pt);
+			}
+		}
+		break;
+
+	case MOVE_MODE:
+	case OPEN_MODE:
+	case CLOSE_MODE:
+	case PICKUP_MODE:
+		lookScreen(pt);
+		break;
+
+	case TALK_MODE:
+		if (!_windowOpen) {
+			bool personFound;
+
+			if (_bgFound >= 1000) {
+				personFound = false;
+				if (!events._released)
+					lookScreen(pt);
+			} else {
+				personFound = _bgFound != -1 && scene._bgShapes[_bgFound]._aType == PERSON;
+			}
+
+			if (events._released && personFound)
+				talk.initTalk(_bgFound);
+			else if (personFound)
+				lookScreen(pt);
+			else if (_bgFound < 1000)
+				clearInfo();
+		}
+		break;
+
+	case USE_MODE:
+	case GIVE_MODE:
+	case INV_MODE:
+		if (inv._invMode == INVMODE_LOOK || inv._invMode == INVMODE_USE || inv._invMode == INVMODE_GIVE) {
+			if (pt.y > CONTROLS_Y)
+				lookInv();
+			else
+				lookScreen(pt);
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	//
+	// Do input processing
+	//
+	if (events._pressed || events._released || events._rightPressed || _keyPress || _pause) {
+		if (((events._released && (_helpStyle || _help == -1)) || (events._rightReleased && !_helpStyle)) &&
+				(pt.y <= CONTROLS_Y) && (_menuMode == STD_MODE)) {
+			// The mouse was clicked in the playing area with no action buttons down.
+			// Check if the mouse was clicked in a script zone. If it was,
+			// then execute the script. Otherwise, walk to the given position
+			if (scene.checkForZones(pt, SCRIPT_ZONE) != 0 ||
+					scene.checkForZones(pt, NOWALK_ZONE) != 0) {
+				// Mouse clicked in script zone
+				events._pressed = events._released = false;
+			} else {
+				people._allowWalkAbort = false;
+				people[HOLMES]._walkDest = pt;
+				people[HOLMES].goAllTheWay();
+			}
+
+			if (_oldKey != -1) {
+				restoreButton(_oldTemp);
+				_oldKey = -1;
+			}
+		}
+
+		// Handle action depending on selected mode
+		switch (_menuMode) {
+		case LOOK_MODE:
+			if (_windowOpen)
+				doLookControl();
+			break;
+
+		case MOVE_MODE:
+			doMiscControl(ALLOW_MOVE);
+			break;
+
+		case TALK_MODE:
+			if (_windowOpen)
+				doTalkControl();
+			break;
+
+		case OPEN_MODE:
+			doMiscControl(ALLOW_OPEN);
+			break;
+
+		case CLOSE_MODE:
+			doMiscControl(ALLOW_CLOSE);
+			break;
+
+		case PICKUP_MODE:
+			doPickControl();
+			break;
+
+		case USE_MODE:
+		case GIVE_MODE:
+		case INV_MODE:
+			doInvControl();
+			break;
+
+		case FILES_MODE:
+			doEnvControl();
+			break;
+
+		default:
+			break;
+		}
+
+		// As long as there isn't an open window, do main input processing.
+		// Windows are opened when in TALK, USE, INV, and GIVE modes
+		if ((!_windowOpen && !_menuCounter && pt.y > CONTROLS_Y) ||
+				_keyPress) {
+			if (events._pressed || events._released || _pause || _keyPress)
+				doMainControl();
+		}
+
+		if (pt.y < CONTROLS_Y && events._pressed && _oldTemp != (int)(_menuMode - 1) && _oldKey != -1)
+			restoreButton(_oldTemp);
+	}
+}
+
+void ScalpelUserInterface::depressButton(int num) {
+	Screen &screen = *_vm->_screen;
+	Common::Point pt(MENU_POINTS[num][0], MENU_POINTS[num][1]);
+	offsetButton3DO(pt, num);
+
+	ImageFrame &frame = (*_controls)[num];
+	screen._backBuffer1.transBlitFrom(frame, pt);
+	screen.slamArea(pt.x, pt.y, pt.x + frame._width, pt.y + frame._height);
+}
+
+void ScalpelUserInterface::restoreButton(int num) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	Common::Point pt(MENU_POINTS[num][0], MENU_POINTS[num][1]);
+	offsetButton3DO(pt, num);
+
+	Graphics::Surface &frame = (*_controls)[num]._frame;
+
+	// Reset the cursor
+	events.setCursor(ARROW);
+
+	// Restore the UI on the back buffer
+	screen._backBuffer1.blitFrom(screen._backBuffer2, pt,
+		Common::Rect(pt.x, pt.y, pt.x + 90, pt.y + 19));
+	screen.slamArea(pt.x, pt.y, pt.x + frame.w, pt.y + frame.h);
+
+	if (!_menuCounter) {
+		_infoFlag = true;
+		clearInfo();
+	}
+}
+
+void ScalpelUserInterface::pushButton(int num) {
+	Events &events = *_vm->_events;
+	_oldKey = -1;
+
+	if (!events._released) {
+		if (_oldHelp != -1)
+			restoreButton(_oldHelp);
+		if (_help != -1)
+			restoreButton(_help);
+
+		depressButton(num);
+		events.wait(6);
+	}
+
+	restoreButton(num);
+}
+
+void ScalpelUserInterface::toggleButton(int num) {
+	Screen &screen = *_vm->_screen;
+
+	if (_menuMode != (MenuMode)(num + 1)) {
+		_menuMode = (MenuMode)(num + 1);
+		_oldKey = COMMANDS[num];
+		_oldTemp = num;
+
+		if (_keyboardInput) {
+			if (_oldHelp != -1 && _oldHelp != num)
+				restoreButton(_oldHelp);
+			if (_help != -1 && _help != num)
+				restoreButton(_help);
+
+			_keyboardInput = false;
+
+			ImageFrame &frame = (*_controls)[num];
+			Common::Point pt(MENU_POINTS[num][0], MENU_POINTS[num][1]);
+			offsetButton3DO(pt, num);
+			screen._backBuffer1.transBlitFrom(frame, pt);
+			screen.slamArea(pt.x, pt.y, pt.x + frame._width, pt.y + frame._height);
+		}
+	} else {
+		_menuMode = STD_MODE;
+		_oldKey = -1;
+		restoreButton(num);
+	}
+}
+
+void ScalpelUserInterface::clearInfo() {
+	if (_infoFlag) {
+		_vm->_screen->vgaBar(Common::Rect(IS_3DO ? 33 : 16, INFO_LINE, 
+			SHERLOCK_SCREEN_WIDTH - (IS_3DO ? 33 : 19), INFO_LINE + 10), INFO_BLACK);
+		_infoFlag = false;
+		_oldLook = -1;
+	}
+}
+
+void ScalpelUserInterface::clearWindow() {
+	if (_windowOpen) {
+		_vm->_screen->vgaBar(Common::Rect(3, CONTROLS_Y + 11, SHERLOCK_SCREEN_WIDTH - 2,
+			SHERLOCK_SCREEN_HEIGHT - 2), INV_BACKGROUND);
+	}
+}
+
+void ScalpelUserInterface::whileMenuCounter() {
+	if (!(--_menuCounter) || _vm->_events->checkInput()) {
+		_menuCounter = 0;
+		_infoFlag = true;
+		clearInfo();
+	}
+}
+
+void ScalpelUserInterface::examine() {
+	Events &events = *_vm->_events;
+	Inventory &inv = *_vm->_inventory;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Talk &talk = *_vm->_talk;
+	Common::Point pt = events.mousePos();
+
+	if (pt.y < (CONTROLS_Y + 9)) {
+		Object &obj = scene._bgShapes[_bgFound];
+
+		if (obj._lookcAnim != 0) {
+			int canimSpeed = ((obj._lookcAnim & 0xe0) >> 5) + 1;
+			scene._cAnimFramePause = obj._lookFrames;
+			_cAnimStr = obj._examine;
+			_cNum = (obj._lookcAnim & 0x1f) - 1;
+
+			scene.startCAnim(_cNum, canimSpeed);
+		} else if (obj._lookPosition.y != 0) {
+			// Need to walk to the object to be examined
+			people[HOLMES].walkToCoords(obj._lookPosition, obj._lookPosition._facing);
+		}
+
+		if (!talk._talkToAbort) {
+			_cAnimStr = obj._examine;
+			if (obj._lookFlag)
+				_vm->setFlags(obj._lookFlag);
+		}
+	} else {
+		// Looking at an inventory item
+		_cAnimStr = inv[_selector]._examine;
+		if (inv[_selector]._lookFlag)
+			_vm->setFlags(inv[_selector]._lookFlag);
+	}
+
+	if (_invLookFlag) {
+		// Don't close the inventory window when starting an examine display, since its
+		// window will slide up to replace the inventory display
+		_windowOpen = false;
+		_menuMode = LOOK_MODE;
+	}
+
+	if (!talk._talkToAbort) {
+		if (!scene._cAnimFramePause)
+			printObjectDesc(_cAnimStr, true);
+		else
+			// description was already printed in startCAnimation
+			scene._cAnimFramePause = 0;
+	}
+}
+
+void ScalpelUserInterface::lookScreen(const Common::Point &pt) {
+	Events &events = *_vm->_events;
+	Inventory &inv = *_vm->_inventory;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Common::Point mousePos = events.mousePos();
+	int temp;
+	Common::String tempStr;
+
+	// Don't display anything for right button command
+	if ((events._rightPressed || events._rightReleased) && !events._pressed)
+		return;
+
+	if (mousePos.y < CONTROLS_Y && (temp = _bgFound) != -1) {
+		if (temp != _oldLook) {
+			_infoFlag = true;
+			clearInfo();
+
+			if (temp < 1000)
+				tempStr = scene._bgShapes[temp]._description;
+			else
+				tempStr = scene._bgShapes[temp - 1000]._description;
+
+			_infoFlag = true;
+			clearInfo();
+
+			// Only print description if there is one
+			if (!tempStr.empty() && tempStr[0] != ' ') {
+				// If inventory is active and an item is selected for a Use or Give action
+				if ((_menuMode == INV_MODE || _menuMode == USE_MODE || _menuMode == GIVE_MODE) &&
+						(inv._invMode == INVMODE_USE || inv._invMode == INVMODE_GIVE)) {
+					int width1 = 0, width2 = 0;
+					int x, width;
+					if (inv._invMode == INVMODE_USE) {
+						// Using an object
+						x = width = screen.stringWidth("Use ");
+
+						if (temp < 1000 && scene._bgShapes[temp]._aType != PERSON)
+							// It's not a person, so make it lowercase
+							tempStr.setChar(tolower(tempStr[0]), 0);
+
+						x += screen.stringWidth(tempStr);
+
+						// If we're using an inventory object, add in the width
+						// of the object name and the " on "
+						if (_selector != -1) {
+							width1 = screen.stringWidth(inv[_selector]._name);
+							x += width1;
+							width2 = screen.stringWidth(" on ");
+							x += width2;
+						}
+
+						// If the line will be too long, keep cutting off characters
+						// until the string will fit
+						while (x > 280) {
+							x -= screen.charWidth(tempStr.lastChar());
+							tempStr.deleteLastChar();
+						}
+
+						int xStart = (SHERLOCK_SCREEN_WIDTH - x) / 2;
+						screen.print(Common::Point(xStart, INFO_LINE + 1),
+							INFO_FOREGROUND, "Use ");
+
+						if (_selector != -1) {
+							screen.print(Common::Point(xStart + width, INFO_LINE + 1),
+								TALK_FOREGROUND, "%s", inv[_selector]._name.c_str());
+							screen.print(Common::Point(xStart + width + width1, INFO_LINE + 1),
+								INFO_FOREGROUND, " on ");
+							screen.print(Common::Point(xStart + width + width1 + width2, INFO_LINE + 1),
+								INFO_FOREGROUND, "%s", tempStr.c_str());
+						} else {
+							screen.print(Common::Point(xStart + width, INFO_LINE + 1),
+								INFO_FOREGROUND, "%s", tempStr.c_str());
+						}
+					} else if (temp >= 0 && temp < 1000 && _selector != -1 &&
+							scene._bgShapes[temp]._aType == PERSON) {
+						// Giving an object to a person
+						width1 = screen.stringWidth(inv[_selector]._name);
+						x = width = screen.stringWidth("Give ");
+						x += width1;
+						width2 = screen.stringWidth(" to ");
+						x += width2;
+						x += screen.stringWidth(tempStr);
+
+						// Ensure string will fit on-screen
+						while (x > 280) {
+							x -= screen.charWidth(tempStr.lastChar());
+							tempStr.deleteLastChar();
+						}
+
+						int xStart = (SHERLOCK_SCREEN_WIDTH - x) / 2;
+						screen.print(Common::Point(xStart, INFO_LINE + 1),
+							INFO_FOREGROUND, "Give ");
+						screen.print(Common::Point(xStart + width, INFO_LINE + 1),
+							TALK_FOREGROUND, "%s", inv[_selector]._name.c_str());
+						screen.print(Common::Point(xStart + width + width1, INFO_LINE + 1),
+							INFO_FOREGROUND, " to ");
+						screen.print(Common::Point(xStart + width + width1 + width2, INFO_LINE + 1),
+							INFO_FOREGROUND, "%s", tempStr.c_str());
+					}
+				} else {
+					screen.print(Common::Point(0, INFO_LINE + 1), INFO_FOREGROUND, "%s", tempStr.c_str());
+				}
+
+				_infoFlag = true;
+				_oldLook = temp;
+			}
+		}
+	} else {
+		clearInfo();
+	}
+}
+
+void ScalpelUserInterface::lookInv() {
+	Events &events = *_vm->_events;
+	Inventory &inv = *_vm->_inventory;
+	Screen &screen = *_vm->_screen;
+	Common::Point mousePos = events.mousePos();
+
+	if (mousePos.x > 15 && mousePos.x < 314 && mousePos.y > (CONTROLS_Y1 + 11)
+			&& mousePos.y < (SHERLOCK_SCREEN_HEIGHT - 2)) {
+		int temp = (mousePos.x - 6) / 52 + inv._invIndex;
+		if (temp < inv._holdings) {
+			if (temp < inv._holdings) {
+				clearInfo();
+				screen.print(Common::Point(0, INFO_LINE + 1), INFO_FOREGROUND,
+					"%s", inv[temp]._description.c_str());
+				_infoFlag = true;
+				_oldLook = temp;
+			}
+		} else {
+			clearInfo();
+		}
+	} else {
+		clearInfo();
+	}
+}
+
+void ScalpelUserInterface::doEnvControl() {
+	Events &events = *_vm->_events;
+	ScalpelSaveManager &saves = *(ScalpelSaveManager *)_vm->_saves;
+	Scene &scene = *_vm->_scene;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	Common::Point mousePos = events.mousePos();
+	static const char ENV_COMMANDS[7] = "ELSUDQ";
+
+	byte color;
+
+	_key = _oldKey = -1;
+	_keyboardInput = false;
+	int found = saves.getHighlightedButton();
+
+	if (events._pressed || events._released) {
+		events.clearKeyboard();
+
+		// Check for a filename entry being highlighted
+		if ((events._pressed || events._released) && mousePos.y > (CONTROLS_Y + 10)) {
+			int found1 = 0;
+			for (_selector = 0; (_selector < ONSCREEN_FILES_COUNT) && !found1; ++_selector)
+				if (mousePos.y > (CONTROLS_Y + 11 + _selector * 10) && mousePos.y < (CONTROLS_Y + 21 + _selector * 10))
+					found1 = 1;
+
+			if (_selector + saves._savegameIndex - 1 < MAX_SAVEGAME_SLOTS + (saves._envMode != SAVEMODE_LOAD))
+				_selector = _selector + saves._savegameIndex - 1;
+			else
+				_selector = -1;
+
+			if (!found1)
+				_selector = -1;
+		}
+
+		// Handle selecting buttons, if any
+		saves.highlightButtons(found);
+
+		if (found == 0 || found == 5)
+			saves._envMode = SAVEMODE_NONE;
+	}
+
+	if (_keyPress) {
+		_key = toupper(_keyPress);
+
+		// Escape _key will close the dialog
+		if (_key == Common::KEYCODE_ESCAPE)
+			_key = 'E';
+
+		if (_key == 'E' || _key == 'L' || _key == 'S' || _key == 'U' || _key == 'D' || _key == 'Q') {
+			const char *chP = strchr(ENV_COMMANDS, _key);
+			int btnIndex = !chP ? -1 : chP - ENV_COMMANDS;
+			saves.highlightButtons(btnIndex);
+			_keyboardInput = true;
+
+			if (_key == 'E' || _key == 'Q') {
+				saves._envMode = SAVEMODE_NONE;
+			} else if (_key >= '1' && _key <= '9') {
+				_keyboardInput = true;
+				_selector = _key - '1';
+				if (_selector >= MAX_SAVEGAME_SLOTS + (saves._envMode == SAVEMODE_LOAD ? 0 : 1))
+					_selector = -1;
+
+				if (saves.checkGameOnScreen(_selector))
+					_oldSelector = _selector;
+			} else {
+				_selector = -1;
+			}
+		}
+	}
+
+	if (_selector != _oldSelector)  {
+		if (_oldSelector != -1 && _oldSelector >= saves._savegameIndex && _oldSelector < (saves._savegameIndex + ONSCREEN_FILES_COUNT)) {
+			screen.print(Common::Point(6, CONTROLS_Y + 12 + (_oldSelector - saves._savegameIndex) * 10),
+				INV_FOREGROUND, "%d.", _oldSelector + 1);
+			screen.print(Common::Point(24, CONTROLS_Y + 12 + (_oldSelector - saves._savegameIndex) * 10),
+				INV_FOREGROUND, "%s", saves._savegames[_oldSelector].c_str());
+		}
+
+		if (_selector != -1) {
+			screen.print(Common::Point(6, CONTROLS_Y + 12 + (_selector - saves._savegameIndex) * 10),
+				TALK_FOREGROUND, "%d.", _selector + 1);
+			screen.print(Common::Point(24, CONTROLS_Y + 12 + (_selector - saves._savegameIndex) * 10),
+				TALK_FOREGROUND, "%s", saves._savegames[_selector].c_str());
+		}
+
+		_oldSelector = _selector;
+	}
+
+	if (events._released || _keyboardInput) {
+		if ((found == 0 && events._released) || _key == 'E') {
+			banishWindow();
+			_windowBounds.top = CONTROLS_Y1;
+
+			events._pressed = events._released = _keyboardInput = false;
+			_keyPress = '\0';
+		} else if ((found == 1 && events._released) || _key == 'L') {
+			saves._envMode = SAVEMODE_LOAD;
+			if (_selector != -1) {
+				saves.loadGame(_selector);
+			}
+		} else if ((found == 2 && events._released) || _key == 'S') {
+			saves._envMode = SAVEMODE_SAVE;
+			if (_selector != -1) {
+				if (saves.checkGameOnScreen(_selector))
+					_oldSelector = _selector;
+
+				if (saves.promptForDescription(_selector)) {
+					saves.saveGame(_selector, saves._savegames[_selector]);
+
+					banishWindow(1);
+					_windowBounds.top = CONTROLS_Y1;
+					_key = _oldKey = -1;
+					_keyPress = '\0';
+					_keyboardInput = false;
+				} else {
+					if (!talk._talkToAbort) {
+						screen._backBuffer1.fillRect(Common::Rect(6, CONTROLS_Y + 11 + (_selector - saves._savegameIndex) * 10,
+							SHERLOCK_SCREEN_WIDTH - 2, CONTROLS_Y + 20 + (_selector - saves._savegameIndex) * 10), INV_BACKGROUND);
+						screen.gPrint(Common::Point(6, CONTROLS_Y + 11 + (_selector - saves._savegameIndex) * 10), INV_FOREGROUND,
+							"%d.", _selector + 1);
+						screen.gPrint(Common::Point(24, CONTROLS_Y + 11 + (_selector - saves._savegameIndex) * 10), INV_FOREGROUND,
+							"%s", saves._savegames[_selector].c_str());
+
+						screen.slamArea(6, CONTROLS_Y + 11 + (_selector - saves._savegameIndex) * 10, 311, 10);
+						_selector = _oldSelector = -1;
+					}
+				}
+			}
+		} else if (((found == 3 && events._released) || _key == 'U') && saves._savegameIndex) {
+			bool moreKeys;
+			do {
+				saves._savegameIndex--;
+				screen._backBuffer1.fillRect(Common::Rect(3, CONTROLS_Y + 11, SHERLOCK_SCREEN_WIDTH - 2,
+					SHERLOCK_SCREEN_HEIGHT - 1), INV_BACKGROUND);
+
+				for (int idx = saves._savegameIndex; idx < (saves._savegameIndex + ONSCREEN_FILES_COUNT); ++idx) {
+					color = INV_FOREGROUND;
+					if (idx == _selector && idx >= saves._savegameIndex && idx < (saves._savegameIndex + ONSCREEN_FILES_COUNT))
+						color = TALK_FOREGROUND;
+
+					screen.gPrint(Common::Point(6, CONTROLS_Y + 11 + (idx - saves._savegameIndex) * 10), color, "%d.", idx + 1);
+					screen.gPrint(Common::Point(24, CONTROLS_Y + 11 + (idx - saves._savegameIndex) * 10), color, "%s", saves._savegames[idx].c_str());
+				}
+
+				screen.slamRect(Common::Rect(3, CONTROLS_Y + 11, SHERLOCK_SCREEN_WIDTH - 2, SHERLOCK_SCREEN_HEIGHT));
+
+				color = !saves._savegameIndex ? COMMAND_NULL : COMMAND_FOREGROUND;
+				screen.buttonPrint(Common::Point(ENV_POINTS[3][2], CONTROLS_Y), color, true, "Up");
+				color = (saves._savegameIndex == MAX_SAVEGAME_SLOTS - ONSCREEN_FILES_COUNT) ? COMMAND_NULL : COMMAND_FOREGROUND;
+				screen.buttonPrint(Common::Point(ENV_POINTS[4][2], CONTROLS_Y), color, true, "Down");
+
+				// Check whether there are more pending U keys pressed
+				moreKeys = false;
+				if (events.kbHit()) {
+					Common::KeyState keyState = events.getKey();
+
+					_key = toupper(keyState.keycode);
+					moreKeys = _key == 'U';
+				}
+			} while ((saves._savegameIndex) && moreKeys);
+		} else if (((found == 4 && events._released) || _key == 'D') && saves._savegameIndex < (MAX_SAVEGAME_SLOTS - ONSCREEN_FILES_COUNT)) {
+			bool moreKeys;
+			do {
+				saves._savegameIndex++;
+				screen._backBuffer1.fillRect(Common::Rect(3, CONTROLS_Y + 11, SHERLOCK_SCREEN_WIDTH - 2,
+					SHERLOCK_SCREEN_HEIGHT - 1), INV_BACKGROUND);
+
+				for (int idx = saves._savegameIndex; idx < (saves._savegameIndex + ONSCREEN_FILES_COUNT); ++idx) {
+					if (idx == _selector && idx >= saves._savegameIndex && idx < (saves._savegameIndex + ONSCREEN_FILES_COUNT))
+						color = TALK_FOREGROUND;
+					else
+						color = INV_FOREGROUND;
+
+					screen.gPrint(Common::Point(6, CONTROLS_Y + 11 + (idx - saves._savegameIndex) * 10), color,
+						"%d.", idx + 1);
+					screen.gPrint(Common::Point(24, CONTROLS_Y + 11 + (idx - saves._savegameIndex) * 10), color,
+						"%s", saves._savegames[idx].c_str());
+				}
+
+				screen.slamRect(Common::Rect(3, CONTROLS_Y + 11, SHERLOCK_SCREEN_WIDTH - 2, SHERLOCK_SCREEN_HEIGHT));
+
+				color = (!saves._savegameIndex) ? COMMAND_NULL : COMMAND_FOREGROUND;
+				screen.buttonPrint(Common::Point(ENV_POINTS[3][2], CONTROLS_Y), color, true, "Up");
+
+				color = (saves._savegameIndex == MAX_SAVEGAME_SLOTS - ONSCREEN_FILES_COUNT) ? COMMAND_NULL : COMMAND_FOREGROUND;
+				screen.buttonPrint(Common::Point(ENV_POINTS[4][2], CONTROLS_Y), color, true, "Down");
+
+				// Check whether there are more pending D keys pressed
+				moreKeys = false;
+				if (events.kbHit()) {
+					Common::KeyState keyState = events.getKey();
+					_key = toupper(keyState.keycode);
+
+					moreKeys = _key == 'D';
+				}
+			} while (saves._savegameIndex < (MAX_SAVEGAME_SLOTS - ONSCREEN_FILES_COUNT) && moreKeys);
+		} else if ((found == 5 && events._released) || _key == 'Q') {
+			clearWindow();
+			screen.print(Common::Point(0, CONTROLS_Y + 20), INV_FOREGROUND, "Are you sure you wish to Quit ?");
+			screen.vgaBar(Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH, CONTROLS_Y + 10), BORDER_COLOR);
+
+			screen.makeButton(Common::Rect(112, CONTROLS_Y, 160, CONTROLS_Y + 10), 136 - screen.stringWidth("Yes") / 2, "Yes");
+			screen.makeButton(Common::Rect(161, CONTROLS_Y, 209, CONTROLS_Y + 10), 184 - screen.stringWidth("No") / 2, "No");
+			screen.slamArea(112, CONTROLS_Y, 97, 10);
+
+			do {
+				scene.doBgAnim();
+
+				if (talk._talkToAbort)
+					return;
+
+				events.pollEventsAndWait();
+				events.setButtonState();
+				mousePos = events.mousePos();
+
+				if (events.kbHit()) {
+					Common::KeyState keyState = events.getKey();
+					_key = toupper(keyState.keycode);
+
+					if (_key == 'X' && (keyState.flags & Common::KBD_ALT) != 0) {
+						_vm->quitGame();
+						events.pollEvents();
+						return;
+					}
+
+					if (_key == Common::KEYCODE_ESCAPE)
+						_key = 'N';
+
+					if (_key == Common::KEYCODE_RETURN || _key == ' ') {
+						events._pressed = false;
+						events._released = true;
+						events._oldButtons = 0;
+						_keyPress = '\0';
+					}
+				}
+
+				if (events._pressed || events._released) {
+					if (mousePos.x > 112 && mousePos.x < 159 && mousePos.y > CONTROLS_Y && mousePos.y < (CONTROLS_Y + 9))
+						color = COMMAND_HIGHLIGHTED;
+					else
+						color = COMMAND_FOREGROUND;
+					screen.buttonPrint(Common::Point(136, CONTROLS_Y), color, true, "Yes");
+
+					if (mousePos.x > 161 && mousePos.x < 208 && mousePos.y > CONTROLS_Y && mousePos.y < (CONTROLS_Y + 9))
+						color = COMMAND_HIGHLIGHTED;
+					else
+						color = COMMAND_FOREGROUND;
+					screen.buttonPrint(Common::Point(184, CONTROLS_Y), color, true, "No");
+				}
+
+				if (mousePos.x > 112 && mousePos.x < 159 && mousePos.y > CONTROLS_Y && mousePos.y < (CONTROLS_Y + 9) && events._released)
+					_key = 'Y';
+
+				if (mousePos.x > 161 && mousePos.x < 208 && mousePos.y > CONTROLS_Y && mousePos.y < (CONTROLS_Y + 9) && events._released)
+					_key = 'N';
+			} while (!_vm->shouldQuit() && _key != 'Y' && _key != 'N');
+
+			if (_key == 'Y') {
+				_vm->quitGame();
+				events.pollEvents();
+				return;
+			} else {
+				screen.buttonPrint(Common::Point(184, CONTROLS_Y), COMMAND_HIGHLIGHTED, true, "No");
+				banishWindow(1);
+				_windowBounds.top = CONTROLS_Y1;
+				_key = -1;
+			}
+		} else {
+			if (_selector != -1) {
+				// Are we already in Load mode?
+				if (saves._envMode == SAVEMODE_LOAD) {
+					saves.loadGame(_selector);
+				} else if (saves._envMode == SAVEMODE_SAVE || saves.isSlotEmpty(_selector)) {
+					// We're already in save mode, or pointing to an empty save slot
+					if (saves.checkGameOnScreen(_selector))
+						_oldSelector = _selector;
+
+					if (saves.promptForDescription(_selector)) {
+						saves.saveGame(_selector, saves._savegames[_selector]);
+						banishWindow();
+						_windowBounds.top = CONTROLS_Y1;
+						_key = _oldKey = -1;
+						_keyPress = '\0';
+						_keyboardInput = false;
+					} else {
+						if (!talk._talkToAbort) {
+							screen._backBuffer1.fillRect(Common::Rect(6, CONTROLS_Y + 11 + (_selector - saves._savegameIndex) * 10,
+								317, CONTROLS_Y + 20 + (_selector - saves._savegameIndex) * 10), INV_BACKGROUND);
+							screen.gPrint(Common::Point(6, CONTROLS_Y + 11 + (_selector - saves._savegameIndex) * 10),
+								INV_FOREGROUND, "%d.", _selector + 1);
+							screen.gPrint(Common::Point(24, CONTROLS_Y + 11 + (_selector - saves._savegameIndex) * 10),
+								INV_FOREGROUND, "%s", saves._savegames[_selector].c_str());
+							screen.slamArea(6, CONTROLS_Y + 11 + (_selector - saves._savegameIndex) * 10, 311, 10);
+							_selector = _oldSelector = -1;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void ScalpelUserInterface::doInvControl() {
+	Events &events = *_vm->_events;
+	FixedText &fixedText = *_vm->_fixedText;
+	ScalpelInventory &inv = *(ScalpelInventory *)_vm->_inventory;
+	Scene &scene = *_vm->_scene;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	int colors[8];
+	Common::Point mousePos = events.mousePos();
+
+	_key = _oldKey = -1;
+	_keyboardInput = false;
+
+	// Check whether any inventory slot is highlighted
+	int found = -1;
+	Common::fill(&colors[0], &colors[8], (int)COMMAND_FOREGROUND);
+	for (int idx = 0; idx < 8; ++idx) {
+		Common::Rect r(INVENTORY_POINTS[idx][0], CONTROLS_Y1,
+			INVENTORY_POINTS[idx][1], CONTROLS_Y1 + 10);
+		if (r.contains(mousePos)) {
+			found = idx;
+			break;
+		}
+	}
+
+	if (events._pressed || events._released) {
+		events.clearKeyboard();
+
+		Common::String fixedText_Exit = fixedText.getText(kFixedText_Inventory_Exit);
+		Common::String fixedText_Look = fixedText.getText(kFixedText_Inventory_Look);
+		Common::String fixedText_Use  = fixedText.getText(kFixedText_Inventory_Use);
+		Common::String fixedText_Give = fixedText.getText(kFixedText_Inventory_Give);
+
+		if (found != -1)
+			// If a slot highlighted, set its color
+			colors[found] = COMMAND_HIGHLIGHTED;
+		screen.buttonPrint(Common::Point(INVENTORY_POINTS[0][2], CONTROLS_Y1), colors[0], true, fixedText_Exit);
+
+		if (found >= 0 && found <= 3) {
+			screen.buttonPrint(Common::Point(INVENTORY_POINTS[1][2], CONTROLS_Y1), colors[1], true, fixedText_Look);
+			screen.buttonPrint(Common::Point(INVENTORY_POINTS[2][2], CONTROLS_Y1), colors[2], true, fixedText_Use);
+			screen.buttonPrint(Common::Point(INVENTORY_POINTS[3][2], CONTROLS_Y1), colors[3], true, fixedText_Give);
+			inv._invMode = (InvMode)found;
+			_selector = -1;
+		}
+
+		if (inv._invIndex) {
+			screen.print(Common::Point(INVENTORY_POINTS[4][2], CONTROLS_Y1 + 1), colors[4], "^^");
+			screen.print(Common::Point(INVENTORY_POINTS[5][2], CONTROLS_Y1 + 1), colors[5], "^");
+		}
+
+		if ((inv._holdings - inv._invIndex) > 6) {
+			screen.print(Common::Point(INVENTORY_POINTS[6][2], CONTROLS_Y1 + 1), colors[6], "_");
+			screen.print(Common::Point(INVENTORY_POINTS[7][2], CONTROLS_Y1 + 1), colors[7], "__");
+		}
+
+		bool flag = false;
+		if (inv._invMode == INVMODE_LOOK || inv._invMode == INVMODE_USE || inv._invMode == INVMODE_GIVE) {
+			Common::Rect r(15, CONTROLS_Y1 + 11, 314, SHERLOCK_SCREEN_HEIGHT - 2);
+			if (r.contains(mousePos)) {
+				_selector = (mousePos.x - 6) / 52 + inv._invIndex;
+				if (_selector < inv._holdings)
+					flag = true;
+			}
+		}
+
+		if (!flag && mousePos.y >(CONTROLS_Y1 + 11))
+			_selector = -1;
+	}
+
+	if (_keyPress) {
+		_key = toupper(_keyPress);
+
+		if (_key == Common::KEYCODE_ESCAPE)
+			// Escape will also 'E'xit out of inventory display
+			_key = 'E';
+
+		if (_key == 'E' || _key == 'L' || _key == 'U' || _key == 'G'
+				|| _key == '-' || _key == '+') {
+			InvMode temp = inv._invMode;
+
+			const char *chP = strchr(INVENTORY_COMMANDS, _key);
+			inv._invMode = !chP ? INVMODE_INVALID : (InvMode)(chP - INVENTORY_COMMANDS);
+			inv.invCommands(true);
+
+			inv._invMode = temp;
+			_keyboardInput = true;
+			if (_key == 'E')
+				inv._invMode = INVMODE_EXIT;
+			_selector = -1;
+		} else {
+			_selector = -1;
+		}
+	}
+
+	if (_selector != _oldSelector) {
+		if (_oldSelector != -1) {
+			// Un-highlight
+			if (_oldSelector >= inv._invIndex && _oldSelector < (inv._invIndex + 6))
+				inv.highlight(_oldSelector, BUTTON_MIDDLE);
+		}
+
+		if (_selector != -1)
+			inv.highlight(_selector, BUTTON_BACKGROUND);
+
+		_oldSelector = _selector;
+	}
+
+	if (events._released || _keyboardInput) {
+		if ((found == 0 && events._released) || _key == 'E') {
+			inv.freeInv();
+			_infoFlag = true;
+			clearInfo();
+			banishWindow(false);
+			_key = -1;
+			events.clearEvents();
+			events.setCursor(ARROW);
+		} else if ((found == 1 && events._released) || (_key == 'L')) {
+			inv._invMode = INVMODE_LOOK;
+		} else if ((found == 2 && events._released) || (_key == 'U')) {
+			inv._invMode = INVMODE_USE;
+		} else if ((found == 3 && events._released) || (_key == 'G')) {
+			inv._invMode = INVMODE_GIVE;
+		} else if (((found == 4 && events._released) || _key == ',') && inv._invIndex) {
+			if (inv._invIndex >= 6)
+				inv._invIndex -= 6;
+			else
+				inv._invIndex = 0;
+
+			screen.print(Common::Point(INVENTORY_POINTS[4][2], CONTROLS_Y1 + 1),
+				COMMAND_HIGHLIGHTED, "^^");
+			inv.freeGraphics();
+			inv.loadGraphics();
+			inv.putInv(SLAM_DISPLAY);
+			inv.invCommands(true);
+		} else if (((found == 5 && events._released) || _key == '-') && inv._invIndex > 0) {
+			--inv._invIndex;
+			screen.print(Common::Point(INVENTORY_POINTS[4][2], CONTROLS_Y1 + 1), COMMAND_HIGHLIGHTED, "^");
+			inv.freeGraphics();
+			inv.loadGraphics();
+			inv.putInv(SLAM_DISPLAY);
+			inv.invCommands(true);
+		} else if (((found == 6 && events._released) || _key == '+') &&  (inv._holdings - inv._invIndex) > 6) {
+			++inv._invIndex;
+			screen.print(Common::Point(INVENTORY_POINTS[6][2], CONTROLS_Y1 + 1), COMMAND_HIGHLIGHTED, "_");
+			inv.freeGraphics();
+			inv.loadGraphics();
+			inv.putInv(SLAM_DISPLAY);
+			inv.invCommands(true);
+		} else if (((found == 7 && events._released) || _key == '.') && (inv._holdings - inv._invIndex) > 6) {
+			inv._invIndex += 6;
+			if ((inv._holdings - 6) < inv._invIndex)
+				inv._invIndex = inv._holdings - 6;
+
+			screen.print(Common::Point(INVENTORY_POINTS[7][2], CONTROLS_Y1 + 1), COMMAND_HIGHLIGHTED, "_");
+			inv.freeGraphics();
+			inv.loadGraphics();
+			inv.putInv(SLAM_DISPLAY);
+			inv.invCommands(true);
+		} else {
+			// If something is being given, make sure it's being given to a person
+			if (inv._invMode == INVMODE_GIVE) {
+				if (_bgFound != -1 && scene._bgShapes[_bgFound]._aType == PERSON)
+					_find = _bgFound;
+				else
+					_find = -1;
+			} else {
+				_find = _bgFound;
+			}
+
+			if ((mousePos.y < CONTROLS_Y1) && (inv._invMode == INVMODE_LOOK) && (_find >= 0) && (_find < 1000)) {
+				if (!scene._bgShapes[_find]._examine.empty() &&
+						scene._bgShapes[_find]._examine[0] >= ' ')
+					inv.refreshInv();
+			} else if (_selector != -1 || _find >= 0) {
+				// Selector is the inventory object that was clicked on, or selected.
+				// If it's -1, then no inventory item is highlighted yet. Otherwise,
+				// an object in the scene has been clicked.
+
+				if (_selector != -1 && inv._invMode == INVMODE_LOOK
+						&& mousePos.y >(CONTROLS_Y1 + 11))
+					inv.refreshInv();
+
+				if (talk._talkToAbort)
+					return;
+
+				// Now check for the Use and Give actions. If inv_mode is INVMODE_GIVE,
+				// that means GIVE is in effect, _selector is the object being
+				// given, and _find is the target.
+				// The same applies to USE, except if _selector is -1, then USE
+				// is being tried on an object in the scene without an inventory
+				// object being highlighted first.
+
+				if ((inv._invMode == INVMODE_USE || (_selector != -1 && inv._invMode == INVMODE_GIVE)) && _find >= 0) {
+					events._pressed = events._released = false;
+					_infoFlag = true;
+					clearInfo();
+
+					int tempSel = _selector;	// Save the selector
+					_selector = -1;
+
+					inv.putInv(SLAM_DISPLAY);
+					_selector = tempSel;		// Restore it
+					InvMode tempMode = inv._invMode;
+					inv._invMode = INVMODE_USE55;
+					inv.invCommands(true);
+
+					_infoFlag = true;
+					clearInfo();
+					banishWindow(false);
+					_key = -1;
+
+					inv.freeInv();
+
+					bool giveFl = (tempMode >= INVMODE_GIVE);
+					if (_selector >= 0)
+						// Use/Give inv object with scene object
+						checkUseAction(&scene._bgShapes[_find]._use[0], inv[_selector]._name, kFixedTextAction_Use, _find, giveFl);
+					else
+						// Now inv object has been highlighted
+						checkUseAction(&scene._bgShapes[_find]._use[0], "*SELF*", kFixedTextAction_Use, _find, giveFl);
+
+					_selector = _oldSelector = -1;
+				}
+			}
+		}
+	}
+}
+
+void ScalpelUserInterface::doLookControl() {
+	Events &events = *_vm->_events;
+	ScalpelInventory &inv = *(ScalpelInventory *)_vm->_inventory;
+	Screen &screen = *_vm->_screen;
+
+	_key = _oldKey = -1;
+	_keyboardInput = (_keyPress != '\0');
+
+	if (events._released || events._rightReleased || _keyboardInput) {
+		// Is an inventory object being looked at?
+		if (!_invLookFlag) {
+			// Is there any remaining text to display?
+			if (!_descStr.empty()) {
+				printObjectDesc(_descStr, false);
+			} else if (!_lookHelp) {
+				// Need to close the window and depress the Look button
+				Common::Point pt(MENU_POINTS[0][0], MENU_POINTS[0][1]);
+				offsetButton3DO(pt, 0);
+				screen._backBuffer2.blitFrom((*_controls)[0], pt);
+				banishWindow(true);
+
+				_windowBounds.top = CONTROLS_Y1;
+				_key = _oldKey = COMMANDS[LOOK_MODE - 1];
+				_temp = _oldTemp = 0;
+				_menuMode = LOOK_MODE;
+				events.clearEvents();
+
+				// Restore UI
+				drawInterface();
+			} else {
+				events.setCursor(ARROW);
+				banishWindow(true);
+				_windowBounds.top = CONTROLS_Y1;
+				_key = _oldKey = -1;
+				_temp = _oldTemp = 0;
+				_menuMode = STD_MODE;
+				events.clearEvents();
+			}
+		} else {
+			// Looking at an inventory object
+			// Backup the user interface
+			Surface tempSurface(SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT - CONTROLS_Y1);
+			tempSurface.blitFrom(screen._backBuffer2, Common::Point(0, 0),
+				Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+
+			inv.drawInventory(INVENTORY_DONT_DISPLAY);
+			banishWindow(true);
+
+			// Restore the ui
+			screen._backBuffer2.blitFrom(tempSurface, Common::Point(0, CONTROLS_Y1));
+
+			_windowBounds.top = CONTROLS_Y1;
+			_key = _oldKey = COMMANDS[LOOK_MODE - 1];
+			_temp = _oldTemp = 0;
+			events.clearEvents();
+			_invLookFlag = false;
+			_menuMode = INV_MODE;
+			_windowOpen = true;
+		}
+	}
+}
+
+void ScalpelUserInterface::doMainControl() {
+	ScalpelEngine &vm = *(ScalpelEngine *)_vm;
+	Events &events = *_vm->_events;
+	ScalpelInventory &inv = *(ScalpelInventory *)_vm->_inventory;
+	ScalpelSaveManager &saves = *(ScalpelSaveManager *)_vm->_saves;
+	Common::Point pt = events.mousePos();
+	const char *commands = IS_3DO ? COMMANDS_3DO : COMMANDS;
+
+	if ((events._pressed || events._released) && pt.y > CONTROLS_Y) {
+		events.clearKeyboard();
+		_key = -1;
+
+		// Check whether the mouse is in any of the command areas
+		for (_temp = 0; (_temp < 12) && (_key == -1); ++_temp) {
+			Common::Rect r(MENU_POINTS[_temp][0], MENU_POINTS[_temp][1],
+				MENU_POINTS[_temp][2], MENU_POINTS[_temp][3]);
+			if (IS_3DO && _temp >= 0 && _temp <= 2) {
+				r.left += UI_OFFSET_3DO - 1;
+				r.right += UI_OFFSET_3DO - 1;
+			}
+			if (r.contains(pt))
+				_key = commands[_temp];
+		}
+		--_temp;
+	} else if (_keyPress) {
+		// Keyboard control
+		_keyboardInput = true;
+
+		char key = toupper(_keyPress);
+		const char *c = strchr(commands, key);
+		if (c) {
+			_temp = c - commands;
+			_key = key;
+		} else {
+			_temp = 12;
+		}
+
+		if (_temp == 12)
+			_key = -1;
+
+		if (events._rightPressed) {
+			_temp = 12;
+			_key = -1;
+		}
+	} else if (!events._released) {
+		_key = -1;
+	}
+
+	// Check if the button being pointed to has changed
+	if (_oldKey != _key && !_windowOpen) {
+		// Clear the info line
+		_infoFlag = true;
+		clearInfo();
+
+		// If there was an old button selected, restore it
+		if (_oldKey != -1) {
+			_menuMode = STD_MODE;
+			restoreButton(_oldTemp);
+		}
+
+		// If a new button is being pointed to, highlight it
+		if (_key != -1 && _temp < 12 && !_keyboardInput)
+			depressButton(_temp);
+
+		// Save the new button selection
+		_oldKey = _key;
+		_oldTemp = _temp;
+	}
+
+	if (!events._pressed && !_windowOpen) {
+		switch (_key) {
+		case 'L':
+			toggleButton(0);
+			break;
+		case 'M':
+			toggleButton(1);
+			break;
+		case 'T':
+			toggleButton(2);
+			break;
+		case 'P':
+			toggleButton(3);
+			break;
+		case 'O':
+			toggleButton(4);
+			break;
+		case 'C':
+			toggleButton(5);
+			break;
+		case 'I':
+			pushButton(6);
+			_selector = _oldSelector = -1;
+			_menuMode = INV_MODE;
+			inv.drawInventory(PLAIN_INVENTORY);
+			break;
+		case 'U':
+			pushButton(7);
+			_selector = _oldSelector = -1;
+			_menuMode = USE_MODE;
+			inv.drawInventory(USE_INVENTORY_MODE);
+			break;
+		case 'G':
+			pushButton(8);
+			_selector = _oldSelector = -1;
+			_menuMode = GIVE_MODE;
+			inv.drawInventory(GIVE_INVENTORY_MODE);
+			break;
+		case 'J':
+			pushButton(9);
+			_menuMode = JOURNAL_MODE;
+			journalControl();
+			break;
+		case 'F':
+			if (IS_3DO) {
+				if (_temp == 10) {
+					pushButton(10);
+					vm.showScummVMRestoreDialog();
+				} else if (_temp == 11) {
+					pushButton(11);
+					vm.showScummVMSaveDialog();
+				}
+			} else {
+				pushButton(10);
+
+				// Create a thumbnail of the current screen before the files dialog is shown, in case
+				// the user saves the game
+				saves.createThumbnail();
+
+				_selector = _oldSelector = -1;
+
+				if (_vm->_showOriginalSavesDialog) {
+					// Show the original dialog
+					_menuMode = FILES_MODE;
+					saves.drawInterface();
+					_windowOpen = true;
+				} else {
+					// Show the ScummVM GMM instead
+					_vm->_canLoadSave = true;
+					_vm->openMainMenuDialog();
+					_vm->_canLoadSave = false;
+				}
+			}
+			break;
+		case 'S':
+			pushButton(IS_3DO ? 9 : 11);
+			_menuMode = SETUP_MODE;
+			Settings::show(_vm);
+			break;
+		default:
+			break;
+		}
+
+		_help = _oldHelp = _oldBgFound = -1;
+	}
+}
+
+void ScalpelUserInterface::doMiscControl(int allowed) {
+	Events &events = *_vm->_events;
+	Scene &scene = *_vm->_scene;
+	Talk &talk = *_vm->_talk;
+
+	if (events._released) {
+		_temp = _bgFound;
+		if (_bgFound != -1) {
+			// Only allow pointing to objects, not people
+			if (_bgFound < 1000) {
+				events.clearEvents();
+				Object &obj = scene._bgShapes[_bgFound];
+
+				switch (allowed) {
+				case ALLOW_OPEN:
+					checkAction(obj._aOpen, _temp, kFixedTextAction_Open);
+					if (_menuMode != TALK_MODE && !talk._talkToAbort) {
+						_menuMode = STD_MODE;
+						restoreButton(OPEN_MODE - 1);
+						_key = _oldKey = -1;
+					}
+					break;
+
+				case ALLOW_CLOSE:
+					checkAction(obj._aClose, _temp, kFixedTextAction_Close);
+					if (_menuMode != TALK_MODE && !talk._talkToAbort) {
+						_menuMode = STD_MODE;
+						restoreButton(CLOSE_MODE - 1);
+						_key = _oldKey = -1;
+					}
+					break;
+
+				case ALLOW_MOVE:
+					checkAction(obj._aMove, _temp, kFixedTextAction_Move);
+					if (_menuMode != TALK_MODE && !talk._talkToAbort) {
+						_menuMode = STD_MODE;
+						restoreButton(MOVE_MODE - 1);
+						_key = _oldKey = -1;
+					}
+					break;
+
+				default:
+					break;
+				}
+			}
+		}
+	}
+}
+
+void ScalpelUserInterface::doPickControl() {
+	Events &events = *_vm->_events;
+	Scene &scene = *_vm->_scene;
+	Talk &talk = *_vm->_talk;
+
+	if (events._released) {
+		if ((_temp = _bgFound) != -1) {
+			events.clearEvents();
+
+			// Don't allow characters to be picked up
+			if (_bgFound < 1000) {
+				scene._bgShapes[_bgFound].pickUpObject(kFixedTextAction_Pick);
+
+				if (!talk._talkToAbort && _menuMode != TALK_MODE) {
+					_key = _oldKey = -1;
+					_menuMode = STD_MODE;
+					restoreButton(PICKUP_MODE - 1);
+				}
+			}
+		}
+	}
+}
+
+void ScalpelUserInterface::doTalkControl() {
+	Events &events = *_vm->_events;
+	FixedText &fixedText = *_vm->_fixedText;
+	ScalpelJournal &journal = *(ScalpelJournal *)_vm->_journal;
+	ScalpelPeople &people = *(ScalpelPeople *)_vm->_people;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	Sound &sound = *_vm->_sound;
+	ScalpelTalk &talk = *(ScalpelTalk *)_vm->_talk;
+	Common::Point mousePos = events.mousePos();
+
+	_key = _oldKey = -1;
+	_keyboardInput = false;
+
+	Common::String fixedText_Exit = fixedText.getText(kFixedText_Window_Exit);
+	Common::String fixedText_Up   = fixedText.getText(kFixedText_Window_Up);
+	Common::String fixedText_Down = fixedText.getText(kFixedText_Window_Down);
+
+	if (events._pressed || events._released) {
+		events.clearKeyboard();
+
+		// Handle button printing
+		if (mousePos.x > 99 && mousePos.x < 138 && mousePos.y > CONTROLS_Y && mousePos.y < (CONTROLS_Y + 10) && !_endKeyActive)
+			screen.buttonPrint(Common::Point(119, CONTROLS_Y), COMMAND_HIGHLIGHTED, true, fixedText_Exit);
+		else if (_endKeyActive)
+			screen.buttonPrint(Common::Point(119, CONTROLS_Y), COMMAND_FOREGROUND, true, fixedText_Exit);
+
+		if (mousePos.x > 140 && mousePos.x < 170 && mousePos.y > CONTROLS_Y && mousePos.y < (CONTROLS_Y + 10) && talk._moreTalkUp)
+			screen.buttonPrint(Common::Point(159, CONTROLS_Y), COMMAND_HIGHLIGHTED, true, fixedText_Up);
+		else if (talk._moreTalkUp)
+			screen.buttonPrint(Common::Point(159, CONTROLS_Y), COMMAND_FOREGROUND, true, fixedText_Up);
+
+		if (mousePos.x > 181&& mousePos.x < 220 && mousePos.y > CONTROLS_Y && mousePos.y < (CONTROLS_Y + 10) && talk._moreTalkDown)
+			screen.buttonPrint(Common::Point(200, CONTROLS_Y), COMMAND_HIGHLIGHTED, true, fixedText_Down);
+		else if (talk._moreTalkDown)
+			screen.buttonPrint(Common::Point(200, CONTROLS_Y), COMMAND_FOREGROUND, true, fixedText_Down);
+
+		bool found = false;
+		for (_selector = talk._talkIndex; _selector < (int)talk._statements.size() && !found; ++_selector) {
+			if (mousePos.y > talk._statements[_selector]._talkPos.top &&
+					mousePos.y < talk._statements[_selector]._talkPos.bottom)
+				found = true;
+		}
+		--_selector;
+		if (!found)
+			_selector = -1;
+	}
+
+	if (_keyPress) {
+		_key = toupper(_keyPress);
+		if (_key == Common::KEYCODE_ESCAPE)
+			_key = 'E';
+
+		// Check for number press indicating reply line
+		if (_key >= '1' && _key <= ('1' + (int)talk._statements.size() - 1)) {
+			for (uint idx = 0; idx < talk._statements.size(); ++idx) {
+				if (talk._statements[idx]._talkMap == (_key - '1')) {
+					// Found the given statement
+					_selector = idx;
+					_key = -1;
+					_keyboardInput = true;
+					break;
+				}
+			}
+		} else if (_key == 'E' || _key == 'U' || _key == 'D') {
+			_keyboardInput = true;
+		} else {
+			_selector = -1;
+		}
+	}
+
+	if (_selector != _oldSelector) {
+		// Remove highlighting from previous line, if any
+		if (_oldSelector != -1) {
+			if (!((talk._talkHistory[talk._converseNum][_oldSelector] >> (_oldSelector & 7)) & 1))
+				talk.talkLine(_oldSelector, talk._statements[_oldSelector]._talkMap, INV_FOREGROUND,
+					talk._statements[_oldSelector]._talkPos.top, true);
+			else
+				talk.talkLine(_oldSelector, talk._statements[_oldSelector]._talkMap, TALK_NULL,
+					talk._statements[_oldSelector]._talkPos.top, true);
+		}
+
+		// Add highlighting to new line, if any
+		if (_selector != -1)
+			talk.talkLine(_selector, talk._statements[_selector]._talkMap, TALK_FOREGROUND,
+				talk._statements[_selector]._talkPos.top, true);
+
+		_oldSelector = _selector;
+	}
+
+	if (events._released || _keyboardInput) {
+		if (((Common::Rect(99, CONTROLS_Y, 138, CONTROLS_Y + 10).contains(mousePos) && events._released)
+				|| _key == 'E') && _endKeyActive) {
+			talk.freeTalkVars();
+			talk.pullSequence();
+
+			drawInterface(2);
+			banishWindow();
+			_windowBounds.top = CONTROLS_Y1;
+		} else if (((Common::Rect(140, CONTROLS_Y, 179, CONTROLS_Y + 10).contains(mousePos) && events._released)
+				|| _key == 'U') && talk._moreTalkUp) {
+			while (talk._statements[--talk._talkIndex]._talkMap == -1)
+				;
+			screen._backBuffer1.fillRect(Common::Rect(5, CONTROLS_Y + 11, SHERLOCK_SCREEN_WIDTH - 2,
+				SHERLOCK_SCREEN_HEIGHT - 1), INV_BACKGROUND);
+			talk.displayTalk(false);
+
+			screen.slamRect(Common::Rect(5, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH - 5, SHERLOCK_SCREEN_HEIGHT - 2));
+		} else if (((Common::Rect(181, CONTROLS_Y, 220, CONTROLS_Y + 10).contains(mousePos) && events._released)
+				|| _key == 'D') && talk._moreTalkDown) {
+			do {
+				++talk._talkIndex;
+			} while (talk._talkIndex < (int)talk._statements.size() && talk._statements[talk._talkIndex]._talkMap == -1);
+
+			screen._backBuffer1.fillRect(Common::Rect(5, CONTROLS_Y + 11, SHERLOCK_SCREEN_WIDTH - 2,
+				SHERLOCK_SCREEN_HEIGHT - 1), INV_BACKGROUND);
+			talk.displayTalk(false);
+
+			screen.slamRect(Common::Rect(5, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH - 5, SHERLOCK_SCREEN_HEIGHT - 2));
+		} else if (_selector != -1) {
+			screen.buttonPrint(Common::Point(119, CONTROLS_Y), COMMAND_NULL, true, fixedText_Exit);
+			screen.buttonPrint(Common::Point(159, CONTROLS_Y), COMMAND_NULL, true, fixedText_Up);
+			screen.buttonPrint(Common::Point(200, CONTROLS_Y), COMMAND_NULL, true, fixedText_Down);
+
+			// If the reply is new, add it to the journal
+			if (!talk._talkHistory[talk._converseNum][_selector]) {
+				journal.record(talk._converseNum, _selector);
+
+				// Add any Holmes point to Holmes' total, if any
+				if (talk._statements[_selector]._quotient)
+					people._holmesQuotient += talk._statements[_selector]._quotient;
+			}
+
+			// Flag the response as having been used
+			talk._talkHistory[talk._converseNum][_selector] = true;
+
+			clearWindow();
+			screen.print(Common::Point(16, CONTROLS_Y + 12), TALK_FOREGROUND, "Sherlock Holmes");
+			talk.talkLine(_selector + 128, talk._statements[_selector]._talkMap, COMMAND_FOREGROUND, CONTROLS_Y + 21, true);
+
+			switch (talk._statements[_selector]._portraitSide & 3) {
+			case 0:
+			case 1:
+				people._portraitSide = 20;
+				break;
+			case 2:
+				people._portraitSide = 220;
+				break;
+			case 3:
+				people._portraitSide = 120;
+				break;
+			}
+
+			// Check for flipping Holmes
+			if (talk._statements[_selector]._portraitSide & REVERSE_DIRECTION)
+				people._holmesFlip = true;
+
+			talk._speaker = 0;
+			people.setTalking(0);
+
+			if (!talk._statements[_selector]._voiceFile.empty() && sound._voices) {
+				sound.playSpeech(talk._statements[_selector]._voiceFile);
+
+				// Set voices as an indicator for waiting
+				sound._voices = 2;
+			} else {
+				sound._speechPlaying = false;
+			}
+
+
+			talk.waitForMore(talk._statements[_selector]._statement.size());
+			if (talk._talkToAbort)
+				return;
+
+			people.clearTalking();
+			if (talk._talkToAbort)
+				return;
+
+			while (!_vm->shouldQuit()) {
+				talk._scriptSelect = _selector;
+				talk._speaker = talk._talkTo;
+				talk.doScript(talk._statements[_selector]._reply);
+
+				if (!talk._talkToAbort) {
+					if (!talk._talkStealth)
+						clearWindow();
+
+					if (!talk._statements[_selector]._modified.empty()) {
+						for (uint idx = 0; idx < talk._statements[_selector]._modified.size(); ++idx) {
+							_vm->setFlags(talk._statements[_selector]._modified[idx]);
+						}
+
+						talk.setTalkMap();
+					}
+
+					// Check for another linked talk file
+					Common::String linkFilename = talk._statements[_selector]._linkFile;
+					if (!linkFilename.empty() && !talk._scriptMoreFlag) {
+						talk.freeTalkVars();
+						talk.loadTalkFile(linkFilename);
+
+						// Find the first new statement
+						int select = _selector = _oldSelector = -1;
+						for (uint idx = 0; idx < talk._statements.size() && select == -1; ++idx) {
+							if (!talk._statements[idx]._talkMap)
+								select = talk._talkIndex = idx;
+						}
+
+						// See if the new statement is a stealth reply
+						talk._talkStealth = talk._statements[select]._statement.hasPrefix("^") ? 2 : 0;
+
+						// Is the new talk file a standard file, reply first file, or a stealth file
+						if (!talk._statements[select]._statement.hasPrefix("*") &&
+								!talk._statements[select]._statement.hasPrefix("^")) {
+							// Not a reply first file, so display the new selections
+							if (_endKeyActive)
+								screen.buttonPrint(Common::Point(119, CONTROLS_Y), COMMAND_FOREGROUND, true, fixedText_Exit);
+							else
+								screen.buttonPrint(Common::Point(119, CONTROLS_Y), COMMAND_NULL, true, fixedText_Exit);
+
+							talk.displayTalk(true);
+							events.setCursor(ARROW);
+							break;
+						} else {
+							_selector = select;
+
+							if (!talk._talkHistory[talk._converseNum][_selector])
+								journal.record(talk._converseNum, _selector);
+
+							talk._talkHistory[talk._converseNum][_selector] = true;
+						}
+					} else {
+						talk.freeTalkVars();
+						talk.pullSequence();
+						banishWindow();
+						_windowBounds.top = CONTROLS_Y1;
+						break;
+					}
+				} else {
+					break;
+				}
+			}
+
+			events._pressed = events._released = false;
+			events._oldButtons = 0;
+			talk._talkStealth = 0;
+
+			// If a script was pushed onto the script stack, restore it
+			if (!talk._scriptStack.empty()) {
+				ScriptStackEntry stackEntry = talk._scriptStack.pop();
+				talk._scriptName = stackEntry._name;
+				talk._scriptSaveIndex = stackEntry._currentIndex;
+				talk._scriptSelect = stackEntry._select;
+			}
+		}
+	}
+}
+
+void ScalpelUserInterface::journalControl() {
+	Events &events = *_vm->_events;
+	ScalpelJournal &journal = *(ScalpelJournal *)_vm->_journal;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	bool doneFlag = false;
+
+	// Draw the journal screen
+	journal.drawInterface();
+
+	// Handle journal events
+	do {
+		_key = -1;
+		events.setButtonState();
+
+		// Handle keypresses
+		if (events.kbHit()) {
+			Common::KeyState keyState = events.getKey();
+			if (keyState.keycode == Common::KEYCODE_x && (keyState.flags & Common::KBD_ALT)) {
+				_vm->quitGame();
+				return;
+			} else if (keyState.keycode == Common::KEYCODE_e || keyState.keycode == Common::KEYCODE_ESCAPE) {
+				doneFlag = true;
+			} else {
+				_key = toupper(keyState.keycode);
+			}
+		}
+
+		if (!doneFlag)
+			doneFlag = journal.handleEvents(_key);
+	} while (!_vm->shouldQuit() && !doneFlag);
+
+	// Finish up
+	_infoFlag = _keyboardInput = false;
+	_keyPress = '\0';
+	_windowOpen = false;
+	_windowBounds.top = CONTROLS_Y1;
+	_key = -1;
+	_menuMode = STD_MODE;
+
+	// Reset the palette
+	screen.setPalette(screen._cMap);
+
+	screen._backBuffer1.blitFrom(screen._backBuffer2);
+	scene.updateBackground();
+	screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+}
+
+void ScalpelUserInterface::printObjectDesc(const Common::String &str, bool firstTime) {
+	Events &events = *_vm->_events;
+	ScalpelInventory &inv = *(ScalpelInventory *)_vm->_inventory;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	FixedText &fixedText = *_vm->_fixedText;
+
+	if (str.hasPrefix("_")) {
+		_lookScriptFlag = true;
+		events.setCursor(MAGNIFY);
+		int savedSelector = _selector;
+		talk.talkTo(str.c_str() + 1);
+		_lookScriptFlag = false;
+
+		if (talk._talkToAbort) {
+			events.setCursor(ARROW);
+			return;
+		}
+
+		// Check if looking at an inventory object
+		if (!_invLookFlag) {
+			// See if this look was called by a right button click or not
+			if (!_lookHelp) {
+				// If it wasn't a right button click, then we need depress
+				// the look button before we close the window. So save a copy of the
+				// menu area, and draw the controls onto it
+				Surface tempSurface((*_controls)[0]._frame.w, (*_controls)[0]._frame.h);
+				Common::Point pt(MENU_POINTS[0][0], MENU_POINTS[0][1]);
+				offsetButton3DO(pt, 0);
+
+				tempSurface.blitFrom(screen._backBuffer2, Common::Point(0, 0),
+					Common::Rect(pt.x, pt.y, pt.x + tempSurface.w(), pt.y + tempSurface.h()));
+				screen._backBuffer2.transBlitFrom((*_controls)[0], pt);
+
+				banishWindow(1);
+				events.setCursor(MAGNIFY);
+				_windowBounds.top = CONTROLS_Y1;
+				_key = _oldKey = COMMANDS[LOOK_MODE - 1];
+				_temp = _oldTemp = 0;
+				_menuMode = LOOK_MODE;
+				events.clearEvents();
+
+				screen._backBuffer2.blitFrom(tempSurface, pt);
+			} else {
+				events.setCursor(ARROW);
+				banishWindow(true);
+				_windowBounds.top = CONTROLS_Y1;
+				_key = _oldKey = -1;
+				_temp = _oldTemp = 0;
+				_menuMode = STD_MODE;
+				_lookHelp = 0;
+				events.clearEvents();
+			}
+		} else {
+			// Looking at an inventory object
+			_selector = _oldSelector = savedSelector;
+
+			// Reload the inventory graphics and draw the inventory
+			inv.loadInv();
+			inv.putInv(SLAM_SECONDARY_BUFFER);
+			inv.freeInv();
+			banishWindow(1);
+
+			_windowBounds.top = CONTROLS_Y1;
+			_key = _oldKey = COMMANDS[INV_MODE - 1];
+			_temp = _oldTemp = 0;
+			events.clearEvents();
+
+			_invLookFlag = 0;
+			_menuMode = INV_MODE;
+			_windowOpen = true;
+		}
+
+		return;
+	}
+
+	Surface &bb = *screen._backBuffer;
+	if (firstTime) {
+		// Only draw the border on the first call
+		_infoFlag = true;
+		clearInfo();
+
+		bb.fillRect(Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH,
+			CONTROLS_Y1 + 10), BORDER_COLOR);
+		bb.fillRect(Common::Rect(0, CONTROLS_Y + 10, 1, SHERLOCK_SCREEN_HEIGHT - 1),
+			BORDER_COLOR);
+		bb.fillRect(Common::Rect(SHERLOCK_SCREEN_WIDTH - 2, CONTROLS_Y + 10,
+			SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+		bb.fillRect(Common::Rect(0, SHERLOCK_SCREEN_HEIGHT - 1, SHERLOCK_SCREEN_WIDTH,
+			SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+	}
+
+	// Clear background
+	bb.fillRect(Common::Rect(2, CONTROLS_Y + 10, SHERLOCK_SCREEN_WIDTH - 2,
+		SHERLOCK_SCREEN_HEIGHT - 2), INV_BACKGROUND);
+
+	_windowBounds.top = CONTROLS_Y;
+	events.clearEvents();
+
+	// Loop through displaying up to five lines
+	bool endOfStr = false;
+	const char *msgP = str.c_str();
+	for (int lineNum = 0; lineNum < ONSCREEN_FILES_COUNT && !endOfStr; ++lineNum) {
+		int width = 0;
+		const char *lineStartP = msgP;
+
+		// Determine how much can be displayed on the line
+		do {
+			width += screen.charWidth(*msgP++);
+		} while (width < 300 && *msgP);
+
+		if (*msgP)
+			--msgP;
+		else
+			endOfStr = true;
+
+		// If the line needs to be wrapped, scan backwards to find
+		// the end of the previous word as a splitting point
+		if (width >= 300) {
+			while (*msgP != ' ')
+				--msgP;
+			endOfStr = false;
+		}
+
+		// Print out the line
+		Common::String line(lineStartP, msgP);
+		screen.gPrint(Common::Point(16, CONTROLS_Y + 12 + lineNum * 9),
+			INV_FOREGROUND, "%s", line.c_str());
+
+		if (!endOfStr)
+			// Start next line at start of the nxet word after space
+			++msgP;
+	}
+
+	// Handle display depending on whether all the message was shown
+	if (!endOfStr) {
+		Common::String fixedText_PressKeyForMore = fixedText.getText(kFixedText_PressKey_ForMore);
+		Common::String fixedText_PressKeyForMoreHotkey = fixedText.getText(kFixedText_PressKey_ForMoreHotkey);
+		int fixedText_PressKeyForMoreLen = screen.stringWidth(fixedText_PressKeyForMore);
+
+		screen.makeButton(Common::Rect(46, CONTROLS_Y, 272, CONTROLS_Y + 10),
+			(SHERLOCK_SCREEN_WIDTH - fixedText_PressKeyForMoreLen) / 2,
+			fixedText_PressKeyForMore);
+		screen.gPrint(Common::Point((SHERLOCK_SCREEN_WIDTH - fixedText_PressKeyForMoreLen) / 2, CONTROLS_Y),
+			COMMAND_FOREGROUND, "%s", fixedText_PressKeyForMoreHotkey.c_str());
+		_descStr = msgP;
+	} else {
+		Common::String fixedText_PressKeyToContinue = fixedText.getText(kFixedText_PressKey_ToContinue);
+		Common::String fixedText_PressKeyToContinueHotkey = fixedText.getText(kFixedText_PressKey_ToContinueHotkey);
+		int fixedText_PressKeyToContinueLen = screen.stringWidth(fixedText_PressKeyToContinue);
+
+		screen.makeButton(Common::Rect(46, CONTROLS_Y, 272, CONTROLS_Y + 10),
+			(SHERLOCK_SCREEN_WIDTH - fixedText_PressKeyToContinueLen) / 2,
+			fixedText_PressKeyToContinue);
+		screen.gPrint(Common::Point((SHERLOCK_SCREEN_WIDTH - fixedText_PressKeyToContinueLen) / 2, CONTROLS_Y),
+			COMMAND_FOREGROUND, "%s", fixedText_PressKeyToContinueHotkey.c_str());
+		_descStr = "";
+	}
+
+	if (firstTime) {
+		if (!_slideWindows) {
+			screen.slamRect(Common::Rect(0, CONTROLS_Y,
+				SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+		} else {
+			// Display the window
+			summonWindow();
+		}
+
+		_selector = _oldSelector = -1;
+		_windowOpen = true;
+	} else {
+		screen.slamRect(Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH,
+			SHERLOCK_SCREEN_HEIGHT));
+	}
+}
+
+void ScalpelUserInterface::printObjectDesc() {
+	printObjectDesc(_cAnimStr, true);
+}
+
+void ScalpelUserInterface::summonWindow(const Surface &bgSurface, bool slideUp) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+
+	if (_windowOpen)
+		// A window is already open, so can't open another one
+		return;
+
+	if (slideUp) {
+		// Gradually slide up the display of the window
+		for (int idx = 1; idx <= bgSurface.h(); idx += 2) {
+			screen._backBuffer->blitFrom(bgSurface, Common::Point(0, SHERLOCK_SCREEN_HEIGHT - idx),
+				Common::Rect(0, 0, bgSurface.w(), idx));
+			screen.slamRect(Common::Rect(0, SHERLOCK_SCREEN_HEIGHT - idx,
+				SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+
+			events.delay(10);
+		}
+	} else {
+		// Gradually slide down the display of the window
+		for (int idx = 1; idx <= bgSurface.h(); idx += 2) {
+			screen._backBuffer->blitFrom(bgSurface,
+				Common::Point(0, SHERLOCK_SCREEN_HEIGHT - bgSurface.h()),
+				Common::Rect(0, bgSurface.h() - idx, bgSurface.w(), bgSurface.h()));
+			screen.slamRect(Common::Rect(0, SHERLOCK_SCREEN_HEIGHT - bgSurface.h(),
+				SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT - bgSurface.h() + idx));
+
+			events.delay(10);
+		}
+	}
+
+	// Final display of the entire window
+	screen._backBuffer->blitFrom(bgSurface, Common::Point(0, SHERLOCK_SCREEN_HEIGHT - bgSurface.h()),
+		Common::Rect(0, 0, bgSurface.w(), bgSurface.h()));
+	screen.slamArea(0, SHERLOCK_SCREEN_HEIGHT - bgSurface.h(), bgSurface.w(), bgSurface.h());
+
+	_windowOpen = true;
+}
+
+void ScalpelUserInterface::summonWindow(bool slideUp, int height) {
+	Screen &screen = *_vm->_screen;
+
+	// Extract the window that's been drawn on the back buffer
+	Surface tempSurface(SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT - height);
+	Common::Rect r(0, height, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+	tempSurface.blitFrom(screen._backBuffer1, Common::Point(0, 0), r);
+
+	// Remove drawn window with original user interface
+	screen._backBuffer1.blitFrom(screen._backBuffer2,
+		Common::Point(0, height), r);
+
+	// Display the window gradually on-screen
+	summonWindow(tempSurface, slideUp);
+}
+
+void ScalpelUserInterface::banishWindow(bool slideUp) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+
+	if (_windowOpen) {
+		if (slideUp || !_slideWindows) {
+			// Slide window down
+			// Only slide the window if the window style allows it
+			if (_slideWindows) {
+				for (int idx = 2; idx < (SHERLOCK_SCREEN_HEIGHT - CONTROLS_Y); idx += 2) {
+					// Shift the window down by 2 lines
+					byte *pSrc = (byte *)screen._backBuffer1.getBasePtr(0, CONTROLS_Y + idx - 2);
+					byte *pSrcEnd = (byte *)screen._backBuffer1.getBasePtr(0, SHERLOCK_SCREEN_HEIGHT - 2);
+					byte *pDest = (byte *)screen._backBuffer1.getBasePtr(0, SHERLOCK_SCREEN_HEIGHT);
+					Common::copy_backward(pSrc, pSrcEnd, pDest);
+
+					// Restore lines from the ui in the secondary back buffer
+					screen._backBuffer1.blitFrom(screen._backBuffer2,
+						Common::Point(0, CONTROLS_Y),
+						Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH, CONTROLS_Y + idx));
+
+					screen.slamArea(0, CONTROLS_Y + idx - 2, SHERLOCK_SCREEN_WIDTH,
+						SHERLOCK_SCREEN_HEIGHT - CONTROLS_Y - idx + 2);
+					events.delay(10);
+				}
+
+				// Restore final two old lines
+				screen._backBuffer1.blitFrom(screen._backBuffer2,
+					Common::Point(0, SHERLOCK_SCREEN_HEIGHT - 2),
+					Common::Rect(0, SHERLOCK_SCREEN_HEIGHT - 2,
+						SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+				screen.slamArea(0, SHERLOCK_SCREEN_HEIGHT - 2, SHERLOCK_SCREEN_WIDTH, 2);
+			} else {
+				// Restore old area to completely erase window
+				screen._backBuffer1.blitFrom(screen._backBuffer2,
+					Common::Point(0, CONTROLS_Y),
+					Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+				screen.slamRect(Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH,
+					SHERLOCK_SCREEN_HEIGHT));
+			}
+		} else {
+			// Slide the original user interface up to cover the dialog
+			for (int idx = 1; idx < (SHERLOCK_SCREEN_HEIGHT - CONTROLS_Y1); idx += 2) {
+				byte *pSrc = (byte *)screen._backBuffer2.getBasePtr(0, CONTROLS_Y1);
+				byte *pSrcEnd = (byte *)screen._backBuffer2.getBasePtr(0, CONTROLS_Y1 + idx);
+				byte *pDest = (byte *)screen._backBuffer1.getBasePtr(0, SHERLOCK_SCREEN_HEIGHT - idx);
+				Common::copy(pSrc, pSrcEnd, pDest);
+
+				screen.slamArea(0, SHERLOCK_SCREEN_HEIGHT - idx, SHERLOCK_SCREEN_WIDTH,
+					SHERLOCK_SCREEN_HEIGHT);
+				events.delay(10);
+			}
+
+			// Show entire final area
+			screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(0, CONTROLS_Y1),
+				Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+			screen.slamRect(Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+		}
+
+		_infoFlag = false;
+		_windowOpen = false;
+	}
+
+	_menuMode = STD_MODE;
+}
+
+void ScalpelUserInterface::checkUseAction(const UseType *use, const Common::String &invName,
+		FixedTextActionId fixedTextActionId, int objNum, bool giveMode) {
+	Events &events = *_vm->_events;
+	FixedText &fixedText = *_vm->_fixedText;
+	Inventory &inv = *_vm->_inventory;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	bool printed = fixedTextActionId == kFixedTextAction_Invalid;
+
+	if (objNum >= 1000) {
+		// Holmes was specified, so do nothing
+		_infoFlag = true;
+		clearInfo();
+		_infoFlag = true;
+
+		// Display error message
+		_menuCounter = 30;
+		screen.print(Common::Point(0, INFO_LINE + 1), INFO_FOREGROUND, "You can't do that to yourself.");
+		return;
+	}
+
+	// Scan for target item
+	int targetNum = -1;
+	if (giveMode) {
+		for (int idx = 0; idx < USE_COUNT && targetNum == -1; ++idx) {
+			if ((use[idx]._target.equalsIgnoreCase("*GIVE*") || use[idx]._target.equalsIgnoreCase("*GIVEP*"))
+					&& use[idx]._names[0].equalsIgnoreCase(invName)) {
+				// Found a match
+				targetNum = idx;
+				if (use[idx]._target.equalsIgnoreCase("*GIVE*"))
+					inv.deleteItemFromInventory(invName);
+			}
+		}
+	} else {
+		for (int idx = 0; idx < USE_COUNT && targetNum == -1; ++idx) {
+			if (use[idx]._target.equalsIgnoreCase(invName))
+				targetNum = idx;
+		}
+	}
+
+	if (targetNum != -1) {
+		// Found a target, so do the action
+		const UseType &action = use[targetNum];
+
+		events.setCursor(WAIT);
+
+		if (action._useFlag)
+			_vm->setFlags(action._useFlag);
+
+		if (action._cAnimNum != 99) {
+			if (action._cAnimNum == 0)
+				scene.startCAnim(9, action._cAnimSpeed);
+			else
+				scene.startCAnim(action._cAnimNum - 1, action._cAnimSpeed);
+		}
+
+		if (!talk._talkToAbort) {
+			Object &obj = scene._bgShapes[objNum];
+			for (int idx = 0; idx < NAMES_COUNT && !talk._talkToAbort; ++idx) {
+				if (obj.checkNameForCodes(action._names[idx], fixedTextActionId)) {
+					if (!talk._talkToAbort)
+						printed = true;
+				}
+			}
+
+			// Print "Done..." as an ending, unless flagged for leaving scene or otherwise flagged
+			if (scene._goToScene != 1 && !printed && !talk._talkToAbort) {
+				_infoFlag = true;
+				clearInfo();
+				screen.print(Common::Point(0, INFO_LINE + 1), INFO_FOREGROUND, "Done...");
+				_menuCounter = 25;
+			}
+		}
+	} else {
+		// Couldn't find target, so print error
+		_infoFlag = true;
+		clearInfo();
+
+		if (giveMode) {
+			screen.print(Common::Point(0, INFO_LINE + 1), INFO_FOREGROUND, "No, thank you.");
+		} else if (fixedTextActionId == kFixedTextAction_Invalid) {
+			screen.print(Common::Point(0, INFO_LINE + 1), INFO_FOREGROUND, "You can't do that.");
+		} else {
+			Common::String errorMessage = fixedText.getActionMessage(fixedTextActionId, 0);
+			screen.print(Common::Point(0, INFO_LINE + 1), INFO_FOREGROUND, "%s", errorMessage.c_str());
+		}
+
+		_infoFlag = true;
+		_menuCounter = 30;
+	}
+
+	events.setCursor(ARROW);
+}
+
+void ScalpelUserInterface::offsetButton3DO(Common::Point &pt, int num) {
+	if (IS_3DO) {
+		if (num >= 0 && num <= 2)
+			pt.x += 15;
+		else if (num >= 6 && num <= 8)
+			pt.x -= 4;
+		else if (num >= 9 && num <= 11)
+			pt.x -= 8;
+	}
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/scalpel_user_interface.h b/engines/sherlock/scalpel/scalpel_user_interface.h
new file mode 100644
index 0000000000..8c2f3f9e3b
--- /dev/null
+++ b/engines/sherlock/scalpel/scalpel_user_interface.h
@@ -0,0 +1,222 @@
+/* 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 SHERLOCK_SCALPEL_UI_H
+#define SHERLOCK_SCALPEL_UI_H
+
+#include "common/scummsys.h"
+#include "sherlock/user_interface.h"
+
+namespace Sherlock {
+
+class Inventory;
+class Talk;
+
+namespace Scalpel {
+
+extern const char COMMANDS[13];
+extern const char COMMANDS_3DO[13];
+extern const int MENU_POINTS[12][4];
+
+extern const int INVENTORY_POINTS[8][3];
+extern const char INVENTORY_COMMANDS[9];
+
+class Settings;
+
+class ScalpelUserInterface: public UserInterface {
+	friend class Settings;
+	friend class Talk;
+private:
+	char _keyPress;
+	int _lookHelp;
+	int _help, _oldHelp;
+	int _key, _oldKey;
+	int _temp, _oldTemp;
+	int _oldLook;
+	bool _keyboardInput;
+	bool _pause;
+	int _cNum;
+	Common::String _cAnimStr;
+	Common::String _descStr;
+	int _find;
+private:
+	/**
+	 * Draws the image for a user interface button in the down/pressed state.
+	 */
+	void depressButton(int num);
+
+	/**
+	 * If he mouse button is pressed, then calls depressButton to draw the button
+	 * as pressed; if not, it will show it as released with a call to "restoreButton".
+	 */
+	void pushButton(int num);
+
+	/**
+	 * By the time this method has been called, the graphics for the button change
+	 * have already been drawn. This simply takes care of switching the mode around
+	 * accordingly
+	 */
+	void toggleButton(int num);
+
+	/**
+	 * Print the name of an object in the scene
+	 */
+	void lookScreen(const Common::Point &pt);
+
+	/**
+	 * Gets the item in the inventory the mouse is on and display's its description
+	 */
+	void lookInv();
+
+	/**
+	 * Handles input when the file list window is being displayed
+	 */
+	void doEnvControl();
+	
+	/**
+	 * Handle input whilst the inventory is active
+	 */
+	void doInvControl();
+	
+	/**
+	 * Handles waiting whilst an object's description window is open.
+	 */
+	void doLookControl();
+	
+	/**
+	 * Handles input until one of the user interface buttons/commands is selected
+	 */
+	void doMainControl();
+	
+	/**
+	 * Handles the input for the MOVE, OPEN, and CLOSE commands
+	 */
+	void doMiscControl(int allowed);
+	
+	/**
+	 * Handles input for picking up items
+	 */
+	void doPickControl();
+	
+	/**
+	 * Handles input when in talk mode. It highlights the buttons and available statements,
+	 * and handles allowing the user to click on them
+	 */
+	void doTalkControl();
+	
+	/**
+	 * Handles events when the Journal is active.
+	 * @remarks		Whilst this would in theory be better in the Journal class, since it displays in
+	 *		the user interface, it uses so many internal UI fields, that it sort of made some sense
+	 *		to put it in the UserInterface class.
+	 */
+	void journalControl();
+
+	/**
+	 * Checks to see whether a USE action is valid on the given object
+	 */
+	void checkUseAction(const UseType *use, const Common::String &invName, FixedTextActionId fixedTextActionId,
+		int objNum, bool giveMode);
+	
+	/**
+	 * Print the previously selected object's decription
+	 */
+	void printObjectDesc(const Common::String &str, bool firstTime);
+public:
+	ImageFile *_controlPanel;
+        ImageFile *_controls;
+	int _oldUse;
+public:
+	ScalpelUserInterface(SherlockEngine *vm);
+	virtual ~ScalpelUserInterface();
+
+	/**
+	 * Handles counting down whilst checking for input, then clears the info line.
+	 */
+	void whileMenuCounter();
+
+	/**
+	 * Draws the image for the given user interface button in the up
+	 * (not selected) position
+	 */
+	void restoreButton(int num);
+
+	/**
+	 * Creates a text window and uses it to display the in-depth description
+	 * of the highlighted object
+	 */
+	void examine();
+
+	void offsetButton3DO(Common::Point &pt, int num);
+public:
+	/**
+	 * Resets the user interface
+	 */
+	virtual void reset();
+
+	/**
+	 * Main input handler for the user interface
+	 */
+	virtual void handleInput();
+
+	/**
+	 * Draw the user interface onto the screen's back buffers
+	 */	
+	virtual void drawInterface(int bufferNum = 3);
+
+	/**
+	 * Displays a passed window by gradually scrolling it vertically on-screen
+	 */
+	virtual void summonWindow(const Surface &bgSurface, bool slideUp = true);
+
+	/**
+	 * Slide the window stored in the back buffer onto the screen
+	 */
+	virtual void summonWindow(bool slideUp = true, int height = CONTROLS_Y);
+
+	/**
+	 * Close a currently open window
+	 * @param flag	0 = slide old window down, 1 = slide prior UI back up
+	 */
+	virtual void banishWindow(bool slideUp = true);
+
+	/**
+	 * Clears the info line of the screen
+	 */
+	virtual void clearInfo();
+
+	/**
+	 * Clear any active text window
+	 */
+	virtual void clearWindow();
+
+	/**
+	 * Print the previously selected object's decription
+	 */	
+	virtual void printObjectDesc();
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/settings.cpp b/engines/sherlock/scalpel/settings.cpp
new file mode 100644
index 0000000000..f6769a4b99
--- /dev/null
+++ b/engines/sherlock/scalpel/settings.cpp
@@ -0,0 +1,343 @@
+/* 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 "sherlock/sherlock.h"
+#include "sherlock/scalpel/settings.h"
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "sherlock/scalpel/scalpel_user_interface.h"
+#include "sherlock/scalpel/scalpel.h"
+
+namespace Sherlock {
+
+namespace Scalpel {
+
+static const int SETUP_POINTS[12][4]  = {
+	{ 4, 154, 101, 53 },		// Exit
+	{ 4, 165, 101, 53 },		// Music Toggle
+	{ 219, 165, 316, 268 },		// Voice Toggle
+	{ 103, 165, 217, 160 },		// Sound Effects Toggle
+	{ 219, 154, 316, 268 },		// Help Button Left/Right
+	{ 103, 154, 217, 160 },		// New Font Style
+	{ 4, 187, 101, 53 },		// Joystick Toggle
+	{ 103, 187, 217, 160 },		// Calibrate Joystick
+	{ 219, 176, 316, 268 },		// Fade Style
+	{ 103, 176, 217, 160 },		// Window Open Style
+	{ 4, 176, 101, 53 }, 		// Portraits Toggle
+	{ 219, 187, 316, 268 }		// _key Pad Accel. Toggle
+};
+
+static const char *const SETUP_STRS0[2] = { "off", "on" };
+static const char *const SETUP_STRS1[2] = { "Directly", "by Pixel" };
+static const char *const SETUP_STRS2[2] = { "Left", "Right" };
+static const char *const SETUP_STRS3[2] = { "Appear", "Slide" };
+static const char *const SETUP_STRS5[2] = { "Left", "Right" };
+static const char *const SETUP_NAMES[12] = {
+	"Exit", "M", "V", "S", "B", "New Font Style", "J", "Calibrate Joystick", "F", "W", "P", "K"
+};
+
+/*----------------------------------------------------------------*/
+
+void Settings::drawInteface(bool flag) {
+	People &people = *_vm->_people;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	Sound &sound = *_vm->_sound;
+	Music &music = *_vm->_music;
+	UserInterface &ui = *_vm->_ui;
+	Common::String tempStr;
+
+	if (!flag) {
+		screen._backBuffer1.fillRect(Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, CONTROLS_Y1 + 1), BORDER_COLOR);
+		screen._backBuffer1.fillRect(Common::Rect(0, CONTROLS_Y1 + 1, 2, SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+		screen._backBuffer1.fillRect(Common::Rect(SHERLOCK_SCREEN_WIDTH - 2, CONTROLS_Y1 + 1, SHERLOCK_SCREEN_WIDTH,
+			SHERLOCK_SCREEN_HEIGHT), BORDER_COLOR);
+		screen._backBuffer1.hLine(0, SHERLOCK_SCREEN_HEIGHT - 1, SHERLOCK_SCREEN_WIDTH - 1, BORDER_COLOR);
+		screen._backBuffer1.fillRect(Common::Rect(2, CONTROLS_Y1 + 1, SHERLOCK_SCREEN_WIDTH - 2,
+			SHERLOCK_SCREEN_HEIGHT - 2), INV_BACKGROUND);
+	}
+
+	screen.makeButton(Common::Rect(SETUP_POINTS[0][0], SETUP_POINTS[0][1], SETUP_POINTS[0][2], SETUP_POINTS[0][1] + 10),
+		SETUP_POINTS[0][3] - screen.stringWidth("Exit") / 2, "Exit");
+
+	tempStr = Common::String::format("Music %s", SETUP_STRS0[music._musicOn]);
+	screen.makeButton(Common::Rect(SETUP_POINTS[1][0], SETUP_POINTS[1][1], SETUP_POINTS[1][2], SETUP_POINTS[1][1] + 10),
+		SETUP_POINTS[1][3] - screen.stringWidth(tempStr) / 2, tempStr);
+
+	tempStr = Common::String::format("Voices %s", SETUP_STRS0[sound._voices]);
+	screen.makeButton(Common::Rect(SETUP_POINTS[2][0], SETUP_POINTS[2][1], SETUP_POINTS[2][2], SETUP_POINTS[2][1] + 10),
+		SETUP_POINTS[2][3] - screen.stringWidth(tempStr) / 2, tempStr);
+
+	tempStr = Common::String::format("Sound Effects %s", SETUP_STRS0[sound._digitized]);
+	screen.makeButton(Common::Rect(SETUP_POINTS[3][0], SETUP_POINTS[3][1], SETUP_POINTS[3][2], SETUP_POINTS[3][1] + 10),
+		SETUP_POINTS[3][3] - screen.stringWidth(tempStr) / 2, tempStr);
+
+	tempStr = Common::String::format("Auto Help %s", SETUP_STRS5[ui._helpStyle]);
+	screen.makeButton(Common::Rect(SETUP_POINTS[4][0], SETUP_POINTS[4][1], SETUP_POINTS[4][2], SETUP_POINTS[4][1] + 10),
+		SETUP_POINTS[4][3] - screen.stringWidth(tempStr) / 2, tempStr);
+	screen.makeButton(Common::Rect(SETUP_POINTS[5][0], SETUP_POINTS[5][1], SETUP_POINTS[5][2], SETUP_POINTS[5][1] + 10),
+		SETUP_POINTS[5][3] - screen.stringWidth("New Font Style") / 2, "New Font Style");
+
+	// WORKAROUND: We don't support the joystick in ScummVM, so draw the next two buttons as disabled
+	tempStr = "Joystick Off";
+	screen.makeButton(Common::Rect(SETUP_POINTS[6][0], SETUP_POINTS[6][1], SETUP_POINTS[6][2], SETUP_POINTS[6][1] + 10),
+		SETUP_POINTS[6][3] - screen.stringWidth(tempStr) / 2, tempStr);
+	screen.buttonPrint(Common::Point(SETUP_POINTS[6][3], SETUP_POINTS[6][1]), COMMAND_NULL, false, tempStr);
+
+	tempStr = "Calibrate Joystick";
+	screen.makeButton(Common::Rect(SETUP_POINTS[7][0], SETUP_POINTS[7][1], SETUP_POINTS[7][2], SETUP_POINTS[7][1] + 10),
+		SETUP_POINTS[7][3] - screen.stringWidth(tempStr) / 2, tempStr);
+	screen.buttonPrint(Common::Point(SETUP_POINTS[7][3], SETUP_POINTS[7][1]), COMMAND_NULL, false, tempStr);
+
+	tempStr = Common::String::format("Fade %s", screen._fadeStyle ? "by Pixel" : "Directly");
+	screen.makeButton(Common::Rect(SETUP_POINTS[8][0], SETUP_POINTS[8][1], SETUP_POINTS[8][2], SETUP_POINTS[8][1] + 10),
+		SETUP_POINTS[8][3] - screen.stringWidth(tempStr) / 2, tempStr);
+
+	tempStr = Common::String::format("Windows %s", ui._slideWindows ? "Slide" : "Appear");
+	screen.makeButton(Common::Rect(SETUP_POINTS[9][0], SETUP_POINTS[9][1], SETUP_POINTS[9][2], SETUP_POINTS[9][1] + 10),
+		SETUP_POINTS[9][3] - screen.stringWidth(tempStr) / 2, tempStr);
+
+	tempStr = Common::String::format("Portraits %s", SETUP_STRS0[people._portraitsOn]);
+	screen.makeButton(Common::Rect(SETUP_POINTS[10][0], SETUP_POINTS[10][1], SETUP_POINTS[10][2], SETUP_POINTS[10][1] + 10),
+		SETUP_POINTS[10][3] - screen.stringWidth(tempStr) / 2, tempStr);
+
+	tempStr = "Key Pad Slow";
+	screen.makeButton(Common::Rect(SETUP_POINTS[11][0], SETUP_POINTS[11][1], SETUP_POINTS[11][2], SETUP_POINTS[11][1] + 10),
+		SETUP_POINTS[11][3] - screen.stringWidth(tempStr) / 2, tempStr);
+	screen.buttonPrint(Common::Point(SETUP_POINTS[11][3], SETUP_POINTS[11][1]), COMMAND_NULL, false, tempStr);
+
+	// Show the window immediately, or slide it on-screen
+	if (!flag) {
+		if (!ui._slideWindows) {
+			screen.slamRect(Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+		} else {
+			ui.summonWindow(true, CONTROLS_Y1);
+		}
+
+		ui._windowOpen = true;
+	} else {
+		screen.slamRect(Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+	}
+}
+
+int Settings::drawButtons(const Common::Point &pt, int _key) {
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	ScalpelScreen &screen = *(ScalpelScreen *)_vm->_screen;
+	Music &music = *_vm->_music;
+	Sound &sound = *_vm->_sound;
+	UserInterface &ui = *_vm->_ui;
+	int found = -1;
+	byte color;
+	Common::String tempStr;
+
+	for (int idx = 0; idx < 12; ++idx) {
+		if ((pt.x > SETUP_POINTS[idx][0] && pt.x < SETUP_POINTS[idx][2] && pt.y > SETUP_POINTS[idx][1]
+				&& pt.y < (SETUP_POINTS[idx][1] + 10) && (events._pressed || events._released))
+				|| (_key == SETUP_NAMES[idx][0])) {
+			found = idx;
+			color = COMMAND_HIGHLIGHTED;
+		} else {
+			color = COMMAND_FOREGROUND;
+		}
+
+		// Print the button text
+		switch (idx) {
+		case 1:
+			tempStr = Common::String::format("Music %s", SETUP_STRS0[music._musicOn]);
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), color, true, tempStr);
+			break;
+		case 2:
+			tempStr = Common::String::format("Voices %s", SETUP_STRS0[sound._voices]);
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), color, true, tempStr);
+			break;
+		case 3:
+			tempStr = Common::String::format("Sound Effects %s", SETUP_STRS0[sound._digitized]);
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), color, true, tempStr);
+			break;
+		case 4:
+			tempStr = Common::String::format("Auto Help %s", SETUP_STRS2[ui._helpStyle]);
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), color, true, tempStr);
+			break;
+		case 6:
+			tempStr = "Joystick Off";
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), COMMAND_NULL, true, tempStr);
+			break;
+		case 7:
+			tempStr = "Calibrate Joystick";
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), COMMAND_NULL, true, tempStr);
+			break;
+		case 8:
+			tempStr = Common::String::format("Fade %s", SETUP_STRS1[screen._fadeStyle]);
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), color, true, tempStr);
+			break;
+		case 9:
+			tempStr = Common::String::format("Windows %s", SETUP_STRS3[ui._slideWindows]);
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), color, true, tempStr);
+			break;
+		case 10:
+			tempStr = Common::String::format("Portraits %s", SETUP_STRS0[people._portraitsOn]);
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), color, true, tempStr);
+			break;
+		case 11:
+			tempStr = "Key Pad Slow";
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), COMMAND_NULL, true, tempStr);
+			break;
+		default:
+			screen.buttonPrint(Common::Point(SETUP_POINTS[idx][3], SETUP_POINTS[idx][1]), color, true, SETUP_NAMES[idx]);
+			break;
+		}
+	}
+
+	return found;
+}
+
+void Settings::show(SherlockEngine *vm) {
+	Events &events = *vm->_events;
+	People &people = *vm->_people;
+	Scene &scene = *vm->_scene;
+	Screen &screen = *vm->_screen;
+	Sound &sound = *vm->_sound;
+	Music &music = *vm->_music;
+	Talk &talk = *vm->_talk;
+	ScalpelUserInterface &ui = *(ScalpelUserInterface *)vm->_ui;
+	bool updateConfig = false;
+
+	assert(vm->getGameID() == GType_SerratedScalpel);
+	Settings settings(vm);
+	settings.drawInteface(false);
+
+	do {
+		if (ui._menuCounter)
+			ui.whileMenuCounter();
+
+		int found = -1;
+		ui._key = -1;
+
+		scene.doBgAnim();
+		if (talk._talkToAbort)
+			return;
+
+		events.setButtonState();
+		Common::Point pt = events.mousePos();
+
+		if (events._pressed || events._released || events.kbHit()) {
+			ui.clearInfo();
+			ui._key = -1;
+
+			if (events.kbHit()) {
+				Common::KeyState keyState = events.getKey();
+				ui._key = toupper(keyState.keycode);
+
+				if (ui._key == Common::KEYCODE_RETURN || ui._key == Common::KEYCODE_SPACE) {
+					events._pressed = false;
+					events._oldButtons = 0;
+					ui._keyPress = '\0';
+					events._released = true;
+				}
+			}
+
+			// Handle highlighting button under mouse
+			found = settings.drawButtons(pt, ui._key);
+		}
+
+		if ((found == 0 && events._released) || (ui._key == 'E' || ui._key == Common::KEYCODE_ESCAPE))
+			// Exit
+			break;
+
+		if ((found == 1 && events._released) || ui._key == 'M') {
+			// Toggle music
+			music._musicOn = !music._musicOn;
+			if (!music._musicOn)
+				music.stopMusic();
+			else
+				music.startSong();
+
+			updateConfig = true;
+			settings.drawInteface(true);
+		}
+
+		if ((found == 2 && events._released) || ui._key == 'V') {
+			sound._voices = !sound._voices;
+			updateConfig = true;
+			settings.drawInteface(true);
+		}
+
+		if ((found == 3 && events._released) || ui._key == 'S') {
+			// Toggle sound effects
+			sound._digitized = !sound._digitized;
+			updateConfig = true;
+			settings.drawInteface(true);
+		}
+
+		if ((found == 4 && events._released) || ui._key == 'A') {
+			// Help button style
+			ui._helpStyle = !ui._helpStyle;
+			updateConfig = true;
+			settings.drawInteface(true);
+		}
+
+		if ((found == 5 && events._released) || ui._key == 'N') {
+			// New font style
+			int fontNum = screen.fontNumber() + 1;
+			if (fontNum == 3)
+				fontNum = 0;
+
+			screen.setFont(fontNum);
+			updateConfig = true;
+			settings.drawInteface(true);
+		}
+
+		if ((found == 8 && events._released) || ui._key == 'F') {
+			// Toggle fade style
+			screen._fadeStyle = !screen._fadeStyle;
+			updateConfig = true;
+			settings.drawInteface(true);
+		}
+
+		if ((found == 9 && events._released) || ui._key == 'W') {
+			// Window style
+			ui._slideWindows = !ui._slideWindows;
+			updateConfig = true;
+			settings.drawInteface(true);
+		}
+
+		if ((found == 10 && events._released) || ui._key == 'P') {
+			// Toggle portraits being shown
+			people._portraitsOn = !people._portraitsOn;
+			updateConfig = true;
+			settings.drawInteface(true);
+		}
+	} while (!vm->shouldQuit());
+
+	ui.banishWindow();
+
+	if (updateConfig)
+		vm->saveConfig();
+
+	ui._keyPress = '\0';
+	ui._keyboardInput = false;
+	ui._windowBounds.top = CONTROLS_Y1;
+	ui._key = -1;
+}
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scalpel/settings.h b/engines/sherlock/scalpel/settings.h
new file mode 100644
index 0000000000..ff2e647a62
--- /dev/null
+++ b/engines/sherlock/scalpel/settings.h
@@ -0,0 +1,63 @@
+/* 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 SHERLOCK_SETTINGS_H
+#define SHERLOCK_SETTINGS_H
+
+#include "common/scummsys.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Scalpel {
+
+class Settings {
+private:
+	SherlockEngine *_vm;
+
+	Settings(SherlockEngine *vm) : _vm(vm) {}
+
+	/**
+	 * Draws the interface for the settings window
+	 */
+	void drawInteface(bool flag);
+
+	/**
+	 * Draws the buttons for the settings dialog
+	 */
+	int drawButtons(const Common::Point &pt, int key);
+public:
+	/**
+	 * Handles input when the settings window is being shown
+	 * @remarks		Whilst this would in theory be better in the Journal class, since it displays in
+	 *		the user interface, it uses so many internal UI fields, that it sort of made some sense
+	 *		to put it in the UserInterface class.
+	 */
+	static void show(SherlockEngine *vm);
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/tsage/logo.cpp b/engines/sherlock/scalpel/tsage/logo.cpp
new file mode 100644
index 0000000000..014470dcc8
--- /dev/null
+++ b/engines/sherlock/scalpel/tsage/logo.cpp
@@ -0,0 +1,686 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/scummsys.h"
+#include "sherlock/scalpel/tsage/logo.h"
+#include "sherlock/scalpel/scalpel.h"
+
+namespace Sherlock {
+namespace Scalpel {
+namespace TsAGE {
+
+TLib *Visage::_tLib;
+
+Visage::Visage() {
+	_resNum = -1;
+	_rlbNum = -1;
+	_stream = nullptr;
+}
+
+void Visage::setVisage(int resNum, int rlbNum) {
+	if ((_resNum != resNum) || (_rlbNum != rlbNum)) {
+		_resNum = resNum;
+		_rlbNum = rlbNum;
+		delete _stream;
+
+		// Games after Ringworld have an extra indirection via the visage index file
+		Common::SeekableReadStream *stream = _tLib->getResource(RES_VISAGE, resNum, 9999);
+		if (rlbNum == 0)
+			rlbNum = 1;
+
+		// Check how many slots there are
+		uint16 count = stream->readUint16LE();
+		if (rlbNum > count)
+			rlbNum = count;
+
+		// Get the flags/rlbNum to use
+		stream->seek((rlbNum - 1) * 4 + 2);
+		uint32 v = stream->readUint32LE();
+		int flags = v >> 30;
+
+		if (flags & 3) {
+			rlbNum = (int)(v & 0xff);
+		}
+		assert((flags & 3) == 0);
+		delete stream;
+
+		_stream = _tLib->getResource(RES_VISAGE, resNum, rlbNum);
+	}
+}
+
+void Visage::clear() {
+	delete _stream;
+	_stream = nullptr;
+}
+
+Visage::~Visage() {
+	delete _stream;
+}
+
+void Visage::getFrame(ObjectSurface &s, int frameNum) {
+	_stream->seek(0);
+	int numFrames = _stream->readUint16LE();
+	if (frameNum > numFrames)
+		frameNum = numFrames;
+	if (frameNum > 0)
+		--frameNum;
+
+	_stream->seek(frameNum * 4 + 2);
+	int offset = _stream->readUint32LE();
+	_stream->seek(offset);
+
+	surfaceFromRes(s);
+}
+
+int Visage::getFrameCount() const {
+	_stream->seek(0);
+	return _stream->readUint16LE();
+}
+
+bool Visage::isLoaded() const {
+	return _stream != nullptr;
+}
+
+void Visage::surfaceFromRes(ObjectSurface &s) {
+	int frameWidth = _stream->readUint16LE();
+	int frameHeight = _stream->readUint16LE();
+	Common::Rect r(0, 0, frameWidth, frameHeight);
+	s.create(r.width(), r.height());
+
+	s._centroid.x = _stream->readSint16LE();
+	s._centroid.y = _stream->readSint16LE();
+
+	_stream->skip(1);
+	byte flags = _stream->readByte();
+	bool rleEncoded = (flags & 2) != 0;
+
+	byte *destP = (byte *)s.getPixels();
+
+	if (!rleEncoded) {
+		_stream->read(destP, r.width() * r.height());
+	} else {
+		Common::fill(destP, destP + (r.width() * r.height()), 0xff);
+
+		for (int yp = 0; yp < r.height(); ++yp) {
+			int width = r.width();
+			destP = (byte *)s.getBasePtr(0, yp);
+
+			while (width > 0) {
+				uint8 controlVal = _stream->readByte();
+				if ((controlVal & 0x80) == 0) {
+					// Copy specified number of bytes
+					_stream->read(destP, controlVal);
+					width -= controlVal;
+					destP += controlVal;
+				} else if ((controlVal & 0x40) == 0) {
+					// Skip a specified number of output pixels
+					destP += controlVal & 0x3f;
+					width -= controlVal & 0x3f;
+				} else {
+					// Copy a specified pixel a given number of times
+					controlVal &= 0x3f;
+					int pixel = _stream->readByte();
+
+					Common::fill(destP, destP + controlVal, pixel);
+					destP += controlVal;
+					width -= controlVal;
+				}
+			}
+			assert(width == 0);
+		}
+	}
+}
+
+/*--------------------------------------------------------------------------*/
+
+ScalpelEngine *Object::_vm;
+
+Object::Object() {
+	_vm = nullptr;
+	_isAnimating = _finished = false;
+	_frame = 0;
+	_numFrames = 0;
+	_frameChange = 0;
+	_angle = _changeCtr = 0;
+	_walkStartFrame = 0;
+	_majorDiff = _minorDiff = 0;
+}
+
+void Object::setVisage(int visage, int strip) {
+	_visage.setVisage(visage, strip);
+}
+
+void Object::setAnimMode(bool isAnimating) {
+	_isAnimating = isAnimating;
+	_finished = false;
+
+	_updateStartFrame = _vm->_events->getFrameCounter();
+	if (_numFrames)
+		_updateStartFrame += 60 / _numFrames;
+	_frameChange = 1;
+}
+
+void Object::setDestination(const Common::Point &pt) {
+	_destination = pt; 
+
+	int moveRate = 10;
+	_walkStartFrame = _vm->_events->getFrameCounter();
+	_walkStartFrame += 60 / moveRate;
+
+	calculateMoveAngle();
+
+	// Get the difference
+	int diffX = _destination.x - _position.x;
+	int diffY = _destination.y - _position.y;
+	int xSign = (diffX < 0) ? -1 : (diffX > 0 ? 1 : 0);
+	int ySign = (diffY < 0) ? -1 : (diffY > 0 ? 1 : 0);
+	diffX = ABS(diffX);
+	diffY = ABS(diffY);
+
+	if (diffX < diffY) {
+		_minorDiff = diffX / 2;
+		_majorDiff = diffY;
+	} else {
+		_minorDiff = diffY / 2;
+		_majorDiff = diffX;
+	}
+
+	// Set the destination position
+	_moveDelta = Common::Point(diffX, diffY);
+	_moveSign = Common::Point(xSign, ySign);
+	_changeCtr = 0;
+
+	assert(diffX || diffY);
+}
+
+void Object::erase() {
+	Screen &screen = *_vm->_screen;
+	
+	if (_visage.isLoaded() && !_oldBounds.isEmpty())
+		screen.blitFrom(screen._backBuffer1, Common::Point(_oldBounds.left, _oldBounds.top), _oldBounds);
+}
+
+void Object::update() {
+	Screen &screen = *_vm->_screen;
+
+	if (_visage.isLoaded()) {
+		if (isMoving()) {
+			uint32 currTime = _vm->_events->getFrameCounter();
+			if (_walkStartFrame <= currTime) {
+				int moveRate = 10;
+				int frameInc = 60 / moveRate;
+				_walkStartFrame = currTime + frameInc;
+				move();
+			}
+		}
+		
+		if (_isAnimating) {
+			if (_frame < _visage.getFrameCount())
+				_frame = changeFrame();
+			else
+				_finished = true;
+		}
+
+		// Get the new frame
+		ObjectSurface s;
+		_visage.getFrame(s, _frame);
+
+		// Display the frame
+		_oldBounds = Common::Rect(_position.x, _position.y, _position.x + s.w(), _position.y + s.h());
+		_oldBounds.translate(-s._centroid.x, -s._centroid.y);
+		screen.transBlitFrom(s, Common::Point(_oldBounds.left, _oldBounds.top));
+	}
+}
+
+int Object::changeFrame() {
+	int frameNum = _frame;
+	uint32 currentFrame = _vm->_events->getFrameCounter();
+
+	if (_updateStartFrame <= currentFrame) {
+		if (_numFrames > 0) {
+			int v = 60 / _numFrames;
+			_updateStartFrame = currentFrame + v;
+
+			frameNum = getNewFrame();
+		}
+	}
+
+	return frameNum;
+}
+
+int Object::getNewFrame() {
+	int frameNum = _frame + _frameChange;
+
+	if (_frameChange > 0) {
+		if (frameNum > _visage.getFrameCount()) {
+			frameNum = 1;
+		}
+	} else if (frameNum < 1) {
+		frameNum = _visage.getFrameCount();
+	}
+
+	return frameNum;
+}
+
+void Object::calculateMoveAngle() {
+	int xDiff = _destination.x - _position.x, yDiff = _position.y - _destination.y;
+
+	if (!xDiff && !yDiff)
+		_angle = 0;
+	else if (!xDiff)
+		_angle = (_destination.y >= _position.y) ? 180 : 0;
+	else if (!yDiff)
+		_angle = (_destination.x >= _position.x) ? 90 : 270;
+	else {
+		int result = (((xDiff * 100) / ((abs(xDiff) + abs(yDiff))) * 90) / 100);
+
+		if (yDiff < 0)
+			result = 180 - result;
+		else if (xDiff < 0)
+			result += 360;
+
+		_angle = result;
+	}
+}
+
+bool Object::isAnimEnded() const {
+	return _finished;
+}
+
+bool Object::isMoving() const {
+	return (_destination.x != 0) && (_destination != _position);
+}
+
+void Object::move() {
+	Common::Point currPos = _position;
+	Common::Point moveDiff(5, 3);
+	int percent = 100;
+
+	if (dontMove())
+		return;
+
+	if (_moveDelta.x >= _moveDelta.y) {
+		int xAmount = _moveSign.x * moveDiff.x * percent / 100;
+		if (!xAmount)
+			xAmount = _moveSign.x;
+		currPos.x += xAmount;
+
+		int yAmount = ABS(_destination.y - currPos.y);
+		int yChange = _majorDiff / ABS(xAmount);
+		int ySign;
+
+		if (!yChange)
+			ySign = _moveSign.y;
+		else {
+			int v = yAmount / yChange;
+			_changeCtr += yAmount % yChange;
+			if (_changeCtr >= yChange) {
+				++v;
+				_changeCtr -= yChange;
+			}
+
+			ySign = _moveSign.y * v;
+		}
+
+		currPos.y += ySign;
+		_majorDiff -= ABS(xAmount);
+	} else {
+		int yAmount = _moveSign.y * moveDiff.y * percent / 100;
+		if (!yAmount)
+			yAmount = _moveSign.y;
+		currPos.y += yAmount;
+
+		int xAmount = ABS(_destination.x - currPos.x);
+		int xChange = _majorDiff / ABS(yAmount);
+		int xSign;
+
+		if (!xChange)
+			xSign = _moveSign.x;
+		else {
+			int v = xAmount / xChange;
+			_changeCtr += xAmount % xChange;
+			if (_changeCtr >= xChange) {
+				++v;
+				_changeCtr -= xChange;
+			}
+
+			xSign = _moveSign.x * v;
+		}
+
+		currPos.x += xSign;
+		_majorDiff -= ABS(yAmount);
+	}
+
+	_position = currPos;
+	if (dontMove())
+		_position = _destination;
+}
+
+bool Object::dontMove() const {
+	return (_majorDiff <= 0);
+}
+
+void Object::endMove() {
+	_position = _destination;
+}
+
+/*----------------------------------------------------------------*/
+
+bool Logo::show(ScalpelEngine *vm) {
+	Events &events = *vm->_events;
+	Logo *logo = new Logo(vm);
+	bool interrupted = false;
+
+	while (!logo->finished()) {
+		logo->nextFrame();
+
+		// Erase areas from previous frame, and update and re-draw objects
+		for (int idx = 0; idx < 4; ++idx)
+			logo->_objects[idx].erase();
+		for (int idx = 0; idx < 4; ++idx)
+			logo->_objects[idx].update();
+
+		events.delay(10);
+		events.setButtonState();
+		++logo->_frameCounter;
+
+		interrupted = vm->shouldQuit() || events.kbHit() || events._pressed;
+		if (interrupted) {
+			// Keyboard or mouse button pressed, so break out of logo display
+			events.clearEvents();
+			break;
+		}
+	}
+
+	delete logo;
+	return !interrupted;
+}
+
+Logo::Logo(ScalpelEngine *vm) : _vm(vm), _lib("sf3.rlb") {
+	Object::_vm = vm;
+	Visage::_tLib = &_lib;
+
+	_finished = false;
+
+	// Initialize counter
+	_counter = 0;
+	_frameCounter = 0;
+
+	// Initialize wait frame counters
+	_waitFrames = 0;
+	_waitStartFrame = 0;
+
+	// Initialize animation counters
+	_animateObject = 0;
+	_animateStartFrame = 0;
+	_animateFrameDelay = 0;
+	_animateFrames = NULL;
+	_animateFrame = 0;
+	
+	// Save a copy of the original palette
+	_vm->_screen->getPalette(_originalPalette);
+
+	// Set up the palettes
+	Common::fill(&_palette1[0], &_palette1[PALETTE_SIZE], 0);
+	Common::fill(&_palette1[0], &_palette2[PALETTE_SIZE], 0);
+	Common::fill(&_palette1[0], &_palette3[PALETTE_SIZE], 0);
+
+	_lib.getPalette(_palette1, 1111);
+	_lib.getPalette(_palette1, 10);
+	_lib.getPalette(_palette2, 1111);
+	_lib.getPalette(_palette2, 1);
+	_lib.getPalette(_palette3, 1111);
+	_lib.getPalette(_palette3, 14);
+}
+
+Logo::~Logo() {
+	// Restore the original palette
+	_vm->_screen->setPalette(_originalPalette);
+}
+
+bool Logo::finished() const {
+	return _finished;
+}
+
+const AnimationFrame handFrames[] = {
+	{  1,  33,  91 }, {  2,  44, 124 }, {  3,  64, 153 }, {  4,  87, 174 },
+	{  5, 114, 191 }, {  6, 125, 184 }, {  7, 154, 187 }, {  8, 181, 182 },
+	{  9, 191, 167 }, { 10, 190, 150 }, { 11, 182, 139 }, { 11, 170, 130 },
+	{ 11, 158, 121 }, {  0,   0,   0 }
+};
+
+const AnimationFrame companyFrames[] = {
+	{  1, 155,  94 }, {  2, 155,  94 }, {  3, 155,  94 }, {  4, 155,  94 },
+	{  5, 155,  94 }, {  6, 155,  94 }, {  7, 155,  94 }, {  8, 155,  94 },
+	{  0,   0,   0 }
+};
+
+void Logo::nextFrame() {
+	Screen &screen = *_vm->_screen;
+
+	if (_waitFrames) {
+		uint32 currFrame = _frameCounter;
+		if (currFrame - _waitStartFrame < _waitFrames) {
+			return;
+		}
+		_waitStartFrame = 0;
+		_waitFrames = 0;
+	}
+
+	if (_animateFrames) {
+		uint32 currFrame = _frameCounter;
+		if (currFrame > _animateStartFrame + _animateFrameDelay) {
+			AnimationFrame animationFrame = _animateFrames[_animateFrame];
+			if (animationFrame.frame) {
+				_objects[_animateObject]._frame = animationFrame.frame;
+				_objects[_animateObject]._position = Common::Point(animationFrame.x, animationFrame.y);
+				_animateStartFrame += _animateFrameDelay;
+				_animateFrame++;
+			} else {
+				_animateObject = 0;
+				_animateFrameDelay = 0;
+				_animateFrames = NULL;
+				_animateStartFrame = 0;
+				_animateFrame = 0;
+			}
+		}
+		if (_animateFrames)
+			return;
+	}
+
+	switch (_counter++) {
+	case 0:
+		// Load the background and fade it in
+		loadBackground();
+		fade(_palette1);
+		break;
+
+	case 1:
+		// First half of square, circle, and triangle arranging themselves
+		_objects[0].setVisage(16, 1);
+		_objects[0]._frame = 1;
+		_objects[0]._position = Common::Point(169, 107);
+		_objects[0]._numFrames = 7;
+		_objects[0].setAnimMode(true);
+		break;
+
+	case 2:
+		// Keep waiting until first animation ends
+		if (!_objects[0].isAnimEnded()) {
+			--_counter;
+		} else {
+			// Start second half of the shapes animation
+			_objects[0].setVisage(16, 2);
+			_objects[0]._frame = 1;
+			_objects[0]._numFrames = 11;
+			_objects[0].setAnimMode(true);
+		}
+		break;
+
+	case 3:
+		// Keep waiting until second animation of shapes ordering themselves ends
+		if (!_objects[0].isAnimEnded()) {
+			--_counter;
+		} else {
+			// Fade out the background but keep the shapes visible
+			fade(_palette2);
+			screen._backBuffer1.clear();
+		}
+		waitFrames(10);
+		break;
+
+	case 4:
+		// Load the new palette
+		byte palette[PALETTE_SIZE];
+		Common::copy(&_palette2[0], &_palette2[PALETTE_SIZE], &palette[0]);
+		_lib.getPalette(palette, 12);
+		screen.clear();
+		screen.setPalette(palette);
+
+		// Morph into the EA logo
+		_objects[0].setVisage(12, 1);
+		_objects[0]._frame = 1;
+		_objects[0]._numFrames = 7;
+		_objects[0].setAnimMode(true);
+		_objects[0]._position = Common::Point(170, 142);
+		_objects[0].setDestination(Common::Point(158, 71));
+		break;
+
+	case 5:
+		// Wait until the logo has expanded upwards to form EA logo
+		if (_objects[0].isMoving())
+			--_counter;
+		break;
+
+	case 6:
+		fade(_palette3, 40);
+		break;
+
+	case 7:
+		// Show the 'Electronic Arts' company name
+		_objects[1].setVisage(14, 1);
+		_objects[1]._frame = 1;
+		_objects[1]._position = Common::Point(152, 98);
+		waitFrames(120);
+		break;
+
+	case 8:
+		// Start sequence of positioning and size hand cursor in an arc
+		_objects[2].setVisage(18, 1);
+		startAnimation(2, 5, &handFrames[0]);
+		break;
+
+	case 9:
+		// Show a highlighting of the company name
+		_objects[1].remove();
+		_objects[2].erase();
+		_objects[2].remove();
+		_objects[3].setVisage(19, 1);
+		startAnimation(3, 8, &companyFrames[0]);
+		break;
+
+	case 10:
+		waitFrames(180);
+		break;
+
+	case 11:
+		_finished = true;
+		break;
+
+	default:
+		break;
+	}
+}
+
+void Logo::waitFrames(uint frames) {
+	_waitFrames = frames;
+	_waitStartFrame = _frameCounter;
+}
+
+void Logo::startAnimation(uint object, uint frameDelay, const AnimationFrame *frames) {
+	_animateObject = object;
+	_animateFrameDelay = frameDelay;
+	_animateFrames = frames;
+	_animateStartFrame = _frameCounter;
+	_animateFrame = 1;
+
+	_objects[object]._frame = frames[0].frame;
+	_objects[object]._position = Common::Point(frames[0].x, frames[0].y);
+}
+
+void Logo::loadBackground() {
+	Screen &screen = *_vm->_screen;
+	
+	for (int idx = 0; idx < 4; ++idx) {
+		// Get the portion of the screen
+		Common::SeekableReadStream *stream = _lib.getResource(RES_BITMAP, 10, idx);
+
+		// Load it onto the surface
+		Common::Point pt((idx / 2) * (SHERLOCK_SCREEN_WIDTH / 2), (idx % 2) * (SHERLOCK_SCREEN_HEIGHT / 2));
+		for (int y = 0; y < (SHERLOCK_SCREEN_HEIGHT / 2); ++y, ++pt.y) {
+			byte *pDest = (byte *)screen._backBuffer1.getBasePtr(pt.x, pt.y);
+			stream->read(pDest, SHERLOCK_SCREEN_WIDTH / 2);
+		}
+
+		//	_backgroundBounds = Rect(0, 0, READ_LE_UINT16(data), READ_LE_UINT16(data + 2));
+		delete stream;
+	}
+
+	// Default to a blank palette
+	byte palette[PALETTE_SIZE];
+	Common::fill(&palette[0], &palette[PALETTE_SIZE], 0);
+	screen.setPalette(palette);
+
+	// Copy the surface to the screen
+	screen.blitFrom(screen._backBuffer1);
+}
+
+void Logo::fade(const byte palette[PALETTE_SIZE], int step) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	byte startPalette[PALETTE_SIZE];
+	byte tempPalette[PALETTE_SIZE];
+
+	screen.getPalette(startPalette);
+
+	for (int percent = 0; percent < 100; percent += step) {
+		for (int palIndex = 0; palIndex < 256; ++palIndex) {
+			const byte *pal1P = (const byte *)&startPalette[palIndex * 3];
+			const byte *pal2P = (const byte *)&palette[palIndex * 3];
+			byte *destP = &tempPalette[palIndex * 3];
+
+			for (int rgbIndex = 0; rgbIndex < 3; ++rgbIndex, ++pal1P, ++pal2P, ++destP) {
+				*destP = (int)*pal1P + ((int)*pal2P - (int)*pal1P) * percent / 100;
+			}
+		}
+
+		screen.setPalette(tempPalette);
+		events.wait(1);
+	}
+
+	// Set final palette
+	screen.setPalette(palette);
+}
+
+} // end of namespace TsAGE
+} // end of namespace Scalpel
+} // end of namespace Sherlock
diff --git a/engines/sherlock/scalpel/tsage/logo.h b/engines/sherlock/scalpel/tsage/logo.h
new file mode 100644
index 0000000000..8e47ea42a1
--- /dev/null
+++ b/engines/sherlock/scalpel/tsage/logo.h
@@ -0,0 +1,250 @@
+/* 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 SHERLOCK_SCALPEL_TSAGE_LOGO_H
+#define SHERLOCK_SCALPEL_TSAGE_LOGO_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/file.h"
+#include "common/list.h"
+#include "common/str.h"
+#include "common/str-array.h"
+#include "common/util.h"
+#include "graphics/surface.h"
+#include "sherlock/scalpel/tsage/resources.h"
+#include "sherlock/screen.h"
+
+namespace Sherlock {
+namespace Scalpel {
+
+class ScalpelEngine;
+
+namespace TsAGE {
+
+class ObjectSurface : public Surface {
+public:
+	Common::Point _centroid;
+public:
+	ObjectSurface() : Surface() {}
+	virtual ~ObjectSurface() {}
+};
+
+class Visage {
+private:
+	Common::SeekableReadStream *_stream;
+
+	/**
+	 * Translates a raw image resource into a graphics surface
+	 */
+	void surfaceFromRes(ObjectSurface &s);
+public:
+	static TLib *_tLib;
+	int _resNum;
+	int _rlbNum;
+public:
+	Visage();
+	~Visage();
+
+	/**
+	 * Set the visage number
+	 */
+	void setVisage(int resNum, int rlbNum = 9999);
+
+	/**
+	 * Clear the visage
+	 */
+	void clear();
+
+	/**
+	 * Get a frame from the visage
+	 */
+	void getFrame(ObjectSurface &s, int frameNum);
+	
+	/**
+	 * Return the number of frames
+	 */
+	int getFrameCount() const;
+
+	/**
+	 * Returns whether the visage is loaded
+	 */
+	bool isLoaded() const;
+};
+
+class Object {
+private:
+	Visage _visage;
+	uint32 _updateStartFrame;
+	bool _isAnimating;
+	bool _finished;
+	uint32 _walkStartFrame;
+	int _angle;
+	int _changeCtr;
+	int _majorDiff, _minorDiff;
+	Common::Point _moveDelta;
+	Common::Point _moveSign;
+
+	/**
+	 * Return the next frame when the object is animating
+	 */
+	int changeFrame();
+
+	/**
+	 * Gets the next frame in the sequence
+	 */
+	int getNewFrame();
+
+	/**
+	 * Calculate the angle between the current position and a designated destination
+	 */
+	void calculateMoveAngle();
+
+	/**
+	 * Handle any object movement
+	 */
+	void move();
+
+	/**
+	 * Returns whether not to make any movement
+	 */
+	bool dontMove() const;
+
+	/**
+	 * Ends any current movement
+	 */
+	void endMove();
+public:
+	static ScalpelEngine *_vm;
+	Common::Point _position;
+	Common::Point _destination;
+	Common::Rect _oldBounds;
+	int _frame;
+	int _numFrames;
+	int _frameChange;
+public:
+	Object();
+
+	/**
+	 * Load the data for the object
+	 */
+	void setVisage(int visage, int strip);
+
+	/**
+	 * Sets whether the object is animating
+	 */
+	void setAnimMode(bool isAnimating);
+
+	/**
+	 * Starts an object moving to a given destination
+	 */
+	void setDestination(const Common::Point &pt);
+
+	/**
+	 * Returns true if an animation is ended
+	 */
+	bool isAnimEnded() const;
+
+	/**
+	 * Return true if object is moving
+	 */
+	bool isMoving() const;
+
+	/**
+	 * Erase the area the object was previously drawn at, by restoring the background
+	 */
+	void erase();
+
+	/**
+	 * Update the frame
+	 */
+	void update();
+
+	/**
+	 * Remove an object from being displayed
+	 */
+	void remove() { _visage.clear(); }
+};
+
+struct AnimationFrame {
+	int	frame;
+	int	x;
+	int	y;
+};
+
+class Logo {
+private:
+	ScalpelEngine *_vm;
+	TLib _lib;
+	int _counter, _frameCounter;
+	bool _finished;
+	byte _originalPalette[PALETTE_SIZE];
+	byte _palette1[PALETTE_SIZE];
+	byte _palette2[PALETTE_SIZE];
+	byte _palette3[PALETTE_SIZE];
+	Object _objects[4];
+	uint _waitFrames;
+	uint32 _waitStartFrame;
+	int _animateObject;
+	uint32 _animateStartFrame;
+	uint _animateFrameDelay;
+	const AnimationFrame *_animateFrames;
+	uint _animateFrame;
+
+	Logo(ScalpelEngine *vm);
+	~Logo();
+
+	void nextFrame();
+
+	bool finished() const;
+
+	/**
+	 * Wait for a number of frames. Note that the frame count in _events is
+	 * not the same as the number of calls to nextFrame().
+	 */
+	void waitFrames(uint frames);
+
+	/**
+	 * Start an animation sequence. Used for sequences that are described
+	 * one frame at a time because they do unusual things, or run at
+	 * unusual rates.
+	 */
+	void startAnimation(uint object, uint frameDelay, const AnimationFrame *frames);
+
+	/**
+	 * Load the background for the scene
+	 */
+	void loadBackground();
+
+	/**
+	 * Fade from the current palette to a new one
+	 */
+	void fade(const byte palette[PALETTE_SIZE], int step = 6);
+public:
+	static bool show(ScalpelEngine *vm);
+};
+
+} // end of namespace TsAGE
+} // end of namespace Scalpel
+} // end of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scalpel/tsage/resources.cpp b/engines/sherlock/scalpel/tsage/resources.cpp
new file mode 100644
index 0000000000..56b7021563
--- /dev/null
+++ b/engines/sherlock/scalpel/tsage/resources.cpp
@@ -0,0 +1,373 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/memstream.h"
+#include "common/stack.h"
+#include "sherlock/scalpel/tsage/resources.h"
+
+namespace Sherlock {
+namespace Scalpel {
+namespace TsAGE {
+
+static uint16 bitMasks[4] = {0x1ff, 0x3ff, 0x7ff, 0xfff};
+
+uint16 BitReader::readToken() {
+	assert((numBits >= 9) && (numBits <= 12));
+	uint16 result = _remainder;
+	int bitsLeft = numBits - _bitsLeft;
+	int bitOffset = _bitsLeft;
+	_bitsLeft = 0;
+
+	while (bitsLeft >= 0) {
+		_remainder = readByte();
+		result |= _remainder << bitOffset;
+		bitsLeft -= 8;
+		bitOffset += 8;
+	}
+
+	_bitsLeft = -bitsLeft;
+	_remainder >>= 8 - _bitsLeft;
+	return result & bitMasks[numBits - 9];
+}
+
+/*-------------------------------------------------------------------------*/
+
+TLib::TLib(const Common::String &filename) : _filename(filename) {
+
+	// If the resource strings list isn't yet loaded, load them
+	if (_resStrings.size() == 0) {
+		Common::File f;
+		if (f.open("tsage.cfg")) {
+			while (!f.eos()) {
+				_resStrings.push_back(f.readLine());
+			}
+			f.close();
+		}
+	}
+
+	if (!_file.open(filename))
+		error("Missing file %s", filename.c_str());
+
+	loadIndex();
+}
+
+TLib::~TLib() {
+	_resStrings.clear();
+}
+
+/**
+ * Load a section index from the given position in the file
+ */
+void TLib::loadSection(uint32 fileOffset) {
+	_resources.clear();
+	_file.seek(fileOffset);
+	_sections.fileOffset = fileOffset;
+
+	loadSection(_file, _resources);
+}
+
+struct DecodeReference {
+	uint16 vWord;
+	uint8 vByte;
+};
+
+/**
+ * Gets a resource from the currently loaded section
+ */
+Common::SeekableReadStream *TLib::getResource(uint16 id, bool suppressErrors) {
+	// Scan for an entry for the given Id
+	ResourceEntry *re = nullptr;
+	ResourceList::iterator iter;
+	for (iter = _resources.begin(); iter != _resources.end(); ++iter) {
+		if ((*iter).id == id) {
+			re = &(*iter);
+			break;
+		}
+	}
+	if (!re) {
+		if (suppressErrors)
+			return nullptr;
+		error("Could not find resource Id #%d", id);
+	}
+
+	if (!re->isCompressed) {
+		// Read in the resource data and return it
+		byte *dataP = (byte *)malloc(re->size);
+		_file.seek(_sections.fileOffset + re->fileOffset);
+		_file.read(dataP, re->size);
+
+		return new Common::MemoryReadStream(dataP, re->size, DisposeAfterUse::YES);
+	}
+
+	/*
+	 * Decompress the data block
+	 */
+
+	_file.seek(_sections.fileOffset + re->fileOffset);
+	Common::ReadStream *compStream = _file.readStream(re->size);
+	BitReader bitReader(*compStream);
+
+	byte *dataOut = (byte *)malloc(re->uncompressedSize);
+	byte *destP = dataOut;
+	uint bytesWritten = 0;
+
+	uint16 ctrCurrent = 0x102, ctrMax = 0x200;
+	uint16 word_48050 = 0, currentToken = 0, word_48054 =0;
+	byte byte_49068 = 0, byte_49069 = 0;
+
+	const uint tableSize = 0x1000;
+	DecodeReference *table = (DecodeReference *)malloc(tableSize * sizeof(DecodeReference));
+	if (!table)
+		error("[TLib::getResource] Cannot allocate table buffer");
+
+	for (uint i = 0; i < tableSize; ++i) {
+		table[i].vByte = table[i].vWord = 0;
+	}
+	Common::Stack<uint16> tokenList;
+
+	for (;;) {
+		// Get the next decode token
+		uint16 token = bitReader.readToken();
+
+		// Handle the token
+		if (token == 0x101) {
+			// End of compressed stream
+			break;
+		} else if (token == 0x100) {
+			// Reset bit-rate
+			bitReader.numBits = 9;
+			ctrMax = 0x200;
+			ctrCurrent = 0x102;
+
+			// Set variables with next token
+			currentToken = word_48050 = bitReader.readToken();
+			byte_49069 = byte_49068 = (byte)currentToken;
+
+			++bytesWritten;
+			assert(bytesWritten <= re->uncompressedSize);
+			*destP++ = byte_49069;
+		} else {
+			word_48054 = word_48050 = token;
+
+			if (token >= ctrCurrent) {
+				word_48050 = currentToken;
+				tokenList.push(byte_49068);
+			}
+
+			while (word_48050 >= 0x100) {
+				assert(word_48050 < 0x1000);
+				tokenList.push(table[word_48050].vByte);
+				word_48050 = table[word_48050].vWord;
+			}
+
+			byte_49069 = byte_49068 = (byte)word_48050;
+			tokenList.push(word_48050);
+
+			// Write out any cached tokens
+			while (!tokenList.empty()) {
+				++bytesWritten;
+				assert(bytesWritten <= re->uncompressedSize);
+				*destP++ = tokenList.pop();
+			}
+
+			assert(ctrCurrent < 0x1000);
+			table[ctrCurrent].vByte = byte_49069;
+			table[ctrCurrent].vWord = currentToken;
+			++ctrCurrent;
+
+			currentToken = word_48054;
+			if ((ctrCurrent >= ctrMax) && (bitReader.numBits != 12)) {
+				// Move to the next higher bit-rate
+				++bitReader.numBits;
+				ctrMax <<= 1;
+			}
+		}
+	}
+
+	free(table);
+
+	assert(bytesWritten == re->uncompressedSize);
+	delete compStream;
+	return new Common::MemoryReadStream(dataOut, re->uncompressedSize, DisposeAfterUse::YES);
+}
+
+/**
+ * Finds the correct section and loads the specified resource within it
+ */
+Common::SeekableReadStream *TLib::getResource(ResourceType resType, uint16 resNum, uint16 rlbNum, bool suppressErrors) {
+	SectionList::iterator i = _sections.begin();
+	while ((i != _sections.end()) && ((*i).resType != resType || (*i).resNum != resNum))
+		++i;
+	if (i == _sections.end()) {
+		if (suppressErrors)
+			return nullptr;
+		error("Unknown resource type %d num %d", resType, resNum);
+	}
+
+	loadSection((*i).fileOffset);
+
+	return getResource(rlbNum, suppressErrors);
+}
+
+/**
+ * Gets the offset of the start of a resource in the resource file
+ */
+uint32 TLib::getResourceStart(ResourceType resType, uint16 resNum, uint16 rlbNum, ResourceEntry &entry) {
+	// Find the correct section
+	SectionList::iterator i = _sections.begin();
+	while ((i != _sections.end()) && ((*i).resType != resType || (*i).resNum != resNum))
+		++i;
+	if (i == _sections.end()) {
+		error("Unknown resource type %d num %d", resType, resNum);
+	}
+
+	// Load in the section index
+	loadSection((*i).fileOffset);
+
+	// Scan for an entry for the given Id
+	ResourceEntry *re = nullptr;
+	ResourceList::iterator iter;
+	for (iter = _resources.begin(); iter != _resources.end(); ++iter) {
+		if ((*iter).id == rlbNum) {
+			re = &(*iter);
+			break;
+		}
+	}
+
+	// Throw an error if no resource was found, or the resource is compressed
+	if (!re || re->isCompressed)
+		error("Invalid resource Id #%d", rlbNum);
+
+	// Return the resource entry as well as the file offset
+	entry = *re;
+	return _sections.fileOffset + entry.fileOffset;
+}
+
+void TLib::loadIndex() {
+	uint16 resNum, configId, fileOffset;
+
+	// Load the root resources section
+	loadSection(0);
+
+	// Get the single resource from it
+	Common::SeekableReadStream *stream = getResource(0);
+
+	_sections.clear();
+
+	// Loop through reading the entries
+	while ((resNum = stream->readUint16LE()) != 0xffff) {
+		configId = stream->readUint16LE();
+		fileOffset = stream->readUint16LE();
+
+		SectionEntry se;
+		se.resNum = resNum;
+		se.resType = (ResourceType)(configId & 0x1f);
+		se.fileOffset = (((configId >> 5) & 0x7ff) << 16) | fileOffset;
+
+		_sections.push_back(se);
+	}
+
+	delete stream;
+}
+
+/**
+ * Retrieves the specified palette resource and returns it's data
+ *
+ * @paletteNum Specefies the palette number
+ */
+void TLib::getPalette(byte palette[PALETTE_SIZE], int paletteNum) {
+	// Get the specified palette
+	Common::SeekableReadStream *stream = getResource(RES_PALETTE, paletteNum, 0, true);
+	if (!stream)
+		return;
+
+	int startNum = stream->readUint16LE();
+	int numEntries = stream->readUint16LE();
+	assert((startNum < 256) && ((startNum + numEntries) <= 256));
+	stream->skip(2);
+
+	// Copy over the data
+	stream->read(&palette[startNum * 3], numEntries * 3);
+
+	delete stream;
+}
+
+/**
+ * Open up the given resource file using a passed file object. If the desired entry is found
+ * in the index, return the index entry for it, and move the file to the start of the resource
+ */
+bool TLib::scanIndex(Common::File &f, ResourceType resType, int rlbNum, int resNum,
+									  ResourceEntry &resEntry) {
+	// Load the root section index
+	ResourceList resList;
+	loadSection(f, resList);
+
+	// Loop through the index for the desired entry
+	ResourceList::iterator iter;
+	for (iter = resList.begin(); iter != resList.end(); ++iter) {
+		ResourceEntry &re = *iter;
+		if (re.id == resNum) {
+			// Found it, so exit
+			resEntry = re;
+			f.seek(re.fileOffset);
+			return true;
+		}
+	}
+
+	// No matching entry found
+	return false;
+}
+
+/**
+ * Inner logic for decoding a section index into a passed resource list object
+ */
+void TLib::loadSection(Common::File &f, ResourceList &resources) {
+	if (f.readUint32BE() != 0x544D492D)
+		error("Data block is not valid Rlb data");
+
+	/*uint8 unknown1 = */f.readByte();
+	uint16 numEntries = f.readByte();
+
+	for (uint i = 0; i < numEntries; ++i) {
+		uint16 id = f.readUint16LE();
+		uint16 size = f.readUint16LE();
+		uint16 uncSize = f.readUint16LE();
+		uint8 sizeHi = f.readByte();
+		uint8 type = f.readByte() >> 5;
+		assert(type <= 1);
+		uint32 offset = f.readUint32LE();
+
+		ResourceEntry re;
+		re.id = id;
+		re.fileOffset = offset;
+		re.isCompressed = type != 0;
+		re.size = ((sizeHi & 0xF) << 16) | size;
+		re.uncompressedSize = ((sizeHi & 0xF0) << 12) | uncSize;
+
+		resources.push_back(re);
+	}
+}
+
+} // end of namespace TsAGE
+} // end of namespace Scalpel
+} // end of namespace Sherlock
diff --git a/engines/sherlock/scalpel/tsage/resources.h b/engines/sherlock/scalpel/tsage/resources.h
new file mode 100644
index 0000000000..3e09b6b0b1
--- /dev/null
+++ b/engines/sherlock/scalpel/tsage/resources.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 SHERLOCK_SCALPEL_TSAGE_RESOURCES_H
+#define SHERLOCK_SCALPEL_TSAGE_RESOURCES_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/file.h"
+#include "common/list.h"
+#include "common/str.h"
+#include "common/str-array.h"
+#include "common/util.h"
+#include "graphics/surface.h"
+#include "sherlock/screen.h"
+
+namespace Sherlock {
+namespace Scalpel {
+namespace TsAGE {
+
+// Magic number used by original game to identify valid memory blocks
+const uint32 MEMORY_ENTRY_ID = 0xE11DA722;
+
+const int MEMORY_POOL_SIZE = 1000;
+
+enum ResourceType { RES_LIBRARY, RES_STRIP, RES_IMAGE, RES_PALETTE, RES_VISAGE, RES_SOUND, RES_MESSAGE,
+		RES_FONT, RES_POINTER, RES_BANK, RES_SND_DRIVER, RES_PRIORITY, RES_CONTROL, RES_WALKRGNS,
+		RES_BITMAP, RES_SAVE, RES_SEQUENCE,
+		// Return to Ringworld specific resource types
+		RT17, RT18, RT19, RT20, RT21, RT22, RT23, RT24, RT25, RT26, RT27, RT28, RT29, RT30, RT31
+};
+
+class SectionEntry {
+public:
+	ResourceType resType;
+	uint16 resNum;
+	uint32 fileOffset;
+
+	SectionEntry() {
+		resType = RES_LIBRARY;
+		resNum = 0;
+		fileOffset = 0;
+	}
+};
+
+class ResourceEntry {
+public:
+	uint16 id;
+	bool isCompressed;
+	uint32 fileOffset;
+	uint32 size;
+	uint32 uncompressedSize;
+
+	ResourceEntry() {
+		id = 0;
+		isCompressed = false;
+		fileOffset = 0;
+		size = 0;
+		uncompressedSize = 0;
+	}
+};
+
+typedef Common::List<ResourceEntry> ResourceList;
+
+class SectionList : public Common::List<SectionEntry> {
+public:
+	uint32 fileOffset;
+
+	SectionList() {
+		fileOffset = 0;
+	}
+};
+
+class BitReader {
+private:
+	Common::ReadStream &_stream;
+	uint8 _remainder, _bitsLeft;
+	byte readByte() { return _stream.eos() ? 0 : _stream.readByte(); }
+public:
+	BitReader(Common::ReadStream &s) : _stream(s) {
+		numBits = 9;
+		_remainder = 0;
+		_bitsLeft = 0;
+	}
+	uint16 readToken();
+
+	int numBits;
+};
+
+class TLib {
+private:
+	Common::StringArray _resStrings;
+private:
+	Common::File _file;
+	Common::String _filename;
+	ResourceList _resources;
+	SectionList _sections;
+
+	void loadSection(uint32 fileOffset);
+	void loadIndex();
+
+	static bool scanIndex(Common::File &f, ResourceType resType, int rlbNum, int resNum, ResourceEntry &resEntry);
+	static void loadSection(Common::File &f, ResourceList &resources);
+public:
+	TLib(const Common::String &filename);
+	~TLib();
+
+	const Common::String &getFilename() { return _filename; }
+	const SectionList &getSections() { return _sections; }
+	Common::SeekableReadStream *getResource(uint16 id, bool suppressErrors = false);
+	Common::SeekableReadStream *getResource(ResourceType resType, uint16 resNum, uint16 rlbNum, bool suppressErrors = false);
+	uint32 getResourceStart(ResourceType resType, uint16 resNum, uint16 rlbNum, ResourceEntry &entry);
+	void getPalette(byte palette[PALETTE_SIZE], int paletteNum);
+};
+
+} // end of namespace TsAGE
+} // end of namespace Scalpel
+} // end of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/scene.cpp b/engines/sherlock/scene.cpp
new file mode 100644
index 0000000000..6f9ef179a3
--- /dev/null
+++ b/engines/sherlock/scene.cpp
@@ -0,0 +1,1422 @@
+/* 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 "sherlock/scene.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/screen.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/scalpel/scalpel_people.h"
+#include "sherlock/scalpel/scalpel_scene.h"
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+
+namespace Sherlock {
+
+BgFileHeader::BgFileHeader() {
+	_numStructs = -1;
+	_numImages = -1;
+	_numcAnimations = -1;
+	_descSize = -1;
+	_seqSize = -1;
+
+	// Serrated Scalpel
+	_fill = -1;
+
+	// Rose Tattoo
+	_scrollSize = -1;
+	_bytesWritten = -1;
+	_fadeStyle = -1;
+	Common::fill(&_palette[0], &_palette[PALETTE_SIZE], 0);
+}
+
+void BgFileHeader::load(Common::SeekableReadStream &s, bool isRoseTattoo) {
+	_numStructs = s.readUint16LE();
+	_numImages = s.readUint16LE();
+	_numcAnimations = s.readUint16LE();
+	_descSize = s.readUint16LE();
+	_seqSize = s.readUint16LE();
+
+	if (isRoseTattoo) {
+		_scrollSize = s.readUint16LE();
+		_bytesWritten = s.readUint32LE();
+		_fadeStyle = s.readByte();
+	} else {
+		_fill = s.readUint16LE();
+
+	}
+}
+
+/*----------------------------------------------------------------*/
+
+void BgFileHeaderInfo::load(Common::SeekableReadStream &s) {
+	_filesize = s.readUint32LE();
+	_maxFrames = s.readByte();
+
+	char buffer[9];
+	s.read(buffer, 9);
+	_filename = Common::String(buffer);
+}
+
+void BgFileHeaderInfo::load3DO(Common::SeekableReadStream &s) {
+	_filesize = s.readUint32BE();
+	_maxFrames = s.readByte();
+
+	char buffer[9];
+	s.read(buffer, 9);
+	_filename = Common::String(buffer);
+	s.skip(2); // only on 3DO!
+}
+
+/*----------------------------------------------------------------*/
+
+void Exit::load(Common::SeekableReadStream &s, bool isRoseTattoo) {
+	if (isRoseTattoo) {
+		char buffer[41];
+		s.read(buffer, 41);
+		_dest = Common::String(buffer);
+	}
+
+	left = s.readSint16LE();
+	top = s.readSint16LE();
+	setWidth(s.readUint16LE());
+	setHeight(s.readUint16LE());
+
+	_image = isRoseTattoo ? s.readByte() : 0;
+	_scene = s.readSint16LE();
+
+	if (!isRoseTattoo)
+		_allow = s.readSint16LE();
+
+	_newPosition.x = s.readSint16LE();
+	_newPosition.y = s.readSint16LE();
+	_newPosition._facing = s.readUint16LE();
+
+	if (isRoseTattoo)
+		_allow = s.readSint16LE();
+}
+
+void Exit::load3DO(Common::SeekableReadStream &s) {
+	left = s.readSint16BE();
+	top = s.readSint16BE();
+	setWidth(s.readUint16BE());
+	setHeight(s.readUint16BE());
+
+	_image = 0;
+	_scene = s.readSint16BE();
+
+	_allow = s.readSint16BE();
+
+	_newPosition.x = s.readSint16BE();
+	_newPosition.y = s.readSint16BE();
+	_newPosition._facing = s.readUint16BE();
+	s.skip(2); // Filler
+}
+
+/*----------------------------------------------------------------*/
+
+void SceneEntry::load(Common::SeekableReadStream &s) {
+	_startPosition.x = s.readSint16LE();
+	_startPosition.y = s.readSint16LE();
+	_startDir = s.readByte();
+	_allow = s.readByte();
+}
+
+void SceneEntry::load3DO(Common::SeekableReadStream &s) {
+	_startPosition.x = s.readSint16BE();
+	_startPosition.y = s.readSint16BE();
+	_startDir = s.readByte();
+	_allow = s.readByte();
+}
+
+void SceneSound::load(Common::SeekableReadStream &s) {
+	char buffer[9];
+	s.read(buffer, 8);
+	buffer[8] = '\0';
+
+	_name = Common::String(buffer);
+	_priority = s.readByte();
+}
+
+void SceneSound::load3DO(Common::SeekableReadStream &s) {
+	load(s);
+}
+
+/*----------------------------------------------------------------*/
+
+int ObjectArray::indexOf(const Object &obj) const {
+	for (uint idx = 0; idx < size(); ++idx) {
+		if (&(*this)[idx] == &obj)
+			return idx;
+	}
+
+	return -1;
+}
+
+/*----------------------------------------------------------------*/
+
+void ScaleZone::load(Common::SeekableReadStream &s) {
+	left = s.readSint16LE();
+	top = s.readSint16LE();
+	setWidth(s.readUint16LE());
+	setHeight(s.readUint16LE());
+
+	_topNumber = s.readByte();
+	_bottomNumber = s.readByte();
+}
+
+/*----------------------------------------------------------------*/
+
+void WalkArray::load(Common::SeekableReadStream &s, bool isRoseTattoo) {
+	_pointsCount = (int8)s.readByte();
+
+	for (int idx = 0; idx < _pointsCount; ++idx) {
+		int x = s.readSint16LE();
+		int y = isRoseTattoo ? s.readSint16LE() : s.readByte();
+		push_back(Common::Point(x, y));
+	}
+}
+
+/*----------------------------------------------------------------*/
+
+Scene *Scene::init(SherlockEngine *vm) {
+	if (vm->getGameID() == GType_SerratedScalpel)
+		return new Scalpel::ScalpelScene(vm);
+	else
+		return new Tattoo::TattooScene(vm);
+}
+
+Scene::Scene(SherlockEngine *vm): _vm(vm) {
+	_sceneStats = new bool *[SCENES_COUNT];
+	_sceneStats[0] = new bool[SCENES_COUNT * (MAX_BGSHAPES + 1)];
+	Common::fill(&_sceneStats[0][0], &_sceneStats[0][SCENES_COUNT * (MAX_BGSHAPES + 1)], false);
+	for (int idx = 1; idx < SCENES_COUNT; ++idx) {
+		_sceneStats[idx] = _sceneStats[idx - 1] + (MAX_BGSHAPES + 1);
+	}
+
+	_currentScene = -1;
+	_goToScene = -1;
+	_walkedInScene = false;
+	_version = 0;
+	_compressed = false;
+	_invGraphicItems = 0;
+	_cAnimFramePause = 0;
+	_restoreFlag = false;
+	_animating = 0;
+	_doBgAnimDone = true;
+	_tempFadeStyle = 0;
+	_doBgAnimDone = false;
+}
+
+Scene::~Scene() {
+	freeScene();
+	delete[] _sceneStats[0];
+	delete[] _sceneStats;
+}
+
+void Scene::selectScene() {
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	UserInterface &ui = *_vm->_ui;
+
+	// Reset fields
+	ui._windowOpen = ui._infoFlag = false;
+	ui._menuMode = STD_MODE;
+
+	// Load the scene
+	Common::String sceneFile = Common::String::format("res%02d", _goToScene);
+	// _rrmName gets set during loadScene()
+	// _rrmName is for ScalpelScene::startCAnim
+	_currentScene = _goToScene;
+	_goToScene = -1;
+
+	loadScene(sceneFile);
+
+	// If the fade style was changed from running a movie, then reset it
+	if (_tempFadeStyle) {
+		screen._fadeStyle = _tempFadeStyle;
+		_tempFadeStyle = 0;
+	}
+
+	people[HOLMES]._walkDest = Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER,
+		people[HOLMES]._position.y / FIXED_INT_MULTIPLIER);
+
+	_restoreFlag = true;
+	events.clearEvents();
+
+	// If there were any scripts waiting to be run, but were interrupt by a running
+	// canimation (probably the last scene's exit canim), clear the _scriptMoreFlag
+	if (talk._scriptMoreFlag == 3)
+		talk._scriptMoreFlag = 0;
+}
+
+void Scene::freeScene() {
+	SaveManager &saves = *_vm->_saves;
+
+	if (_currentScene == -1)
+		return;
+
+	_vm->_ui->clearWindow();
+	_vm->_talk->freeTalkVars();
+	_vm->_talk->clearSequences();
+	_vm->_inventory->freeInv();
+	_vm->_music->freeSong();
+	_vm->_sound->freeLoadedSounds();
+
+	if (!saves._justLoaded)
+		saveSceneStatus();
+
+	_sequenceBuffer.clear();
+	_descText.clear();
+	_walkPoints.clear();
+	_cAnim.clear();
+	_bgShapes.clear();
+	_zones.clear();
+	_canimShapes.clear();
+
+	for (uint idx = 0; idx < _images.size(); ++idx)
+		delete _images[idx]._images;
+	_images.clear();
+
+	_currentScene = -1;
+}
+
+bool Scene::loadScene(const Common::String &filename) {
+	Events &events = *_vm->_events;
+	Music &music = *_vm->_music;
+	People &people = *_vm->_people;
+	Resources &res = *_vm->_res;
+	SaveManager &saves = *_vm->_saves;
+	Screen &screen = *_vm->_screen;
+	UserInterface &ui = *_vm->_ui;
+	bool flag;
+
+	_walkedInScene = false;
+
+	// Reset the list of walkable areas
+	_zones.clear();
+	_zones.push_back(Common::Rect(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+
+	_descText.clear();
+	_comments = "";
+	_bgShapes.clear();
+	_cAnim.clear();
+	_sequenceBuffer.clear();
+
+	//
+	// Load the room resource file for the scene
+	//
+
+	if (!IS_3DO) {
+		// PC version
+		Common::String roomFilename = filename + ".rrm";
+		_roomFilename = roomFilename;
+
+		flag = _vm->_res->exists(roomFilename);
+		if (flag) {
+			Common::SeekableReadStream *rrmStream = _vm->_res->load(roomFilename);
+
+			rrmStream->seek(39);
+			if (IS_SERRATED_SCALPEL) {
+				_version = rrmStream->readByte();
+				_compressed = _version == 10;
+			} else {
+				_compressed = rrmStream->readByte() > 0;
+			}
+
+			// Go to header and read it in
+			rrmStream->seek(rrmStream->readUint32LE());
+
+			BgFileHeader bgHeader;
+			bgHeader.load(*rrmStream, IS_ROSE_TATTOO);
+			_invGraphicItems = bgHeader._numImages + 1;
+
+			if (IS_ROSE_TATTOO) {
+				// Resize the screen if necessary
+				int fullWidth = SHERLOCK_SCREEN_WIDTH + bgHeader._scrollSize;
+				if (screen._backBuffer1.w() != fullWidth) {
+					screen._backBuffer1.create(fullWidth, SHERLOCK_SCREEN_HEIGHT);
+					screen._backBuffer2.create(fullWidth, SHERLOCK_SCREEN_HEIGHT);
+				}
+
+				// Handle initializing the palette
+				screen.initPaletteFade(bgHeader._bytesWritten);
+				rrmStream->read(screen._cMap, PALETTE_SIZE);
+				paletteLoaded();
+				screen.translatePalette(screen._cMap);
+
+				// Read in background
+				if (_compressed) {
+					res.decompress(*rrmStream, (byte *)screen._backBuffer1.getPixels(), fullWidth * SHERLOCK_SCREEN_HEIGHT);
+				} else {
+					rrmStream->read(screen._backBuffer1.getPixels(), fullWidth * SHERLOCK_SCREEN_HEIGHT);
+				}
+			} 
+
+			// Read in the shapes header info
+			Common::Array<BgFileHeaderInfo> bgInfo;
+			bgInfo.resize(bgHeader._numStructs);
+
+			for (uint idx = 0; idx < bgInfo.size(); ++idx)
+				bgInfo[idx].load(*rrmStream);
+
+			// Read information
+			if (IS_ROSE_TATTOO) {
+				// Load shapes
+				Common::SeekableReadStream *infoStream = !_compressed ? rrmStream : res.decompress(*rrmStream, bgHeader._numStructs * 625);
+
+				_bgShapes.resize(bgHeader._numStructs);
+				for (int idx = 0; idx < bgHeader._numStructs; ++idx)
+					_bgShapes[idx].load(*infoStream, true);
+
+				if (_compressed)
+					delete infoStream;
+
+				// Load description text
+				_descText.resize(bgHeader._descSize);
+				if (_compressed)
+					res.decompress(*rrmStream, (byte *)&_descText[0], bgHeader._descSize);
+				else
+					rrmStream->read(&_descText[0], bgHeader._descSize);
+
+				// Load sequences
+				_sequenceBuffer.resize(bgHeader._seqSize);
+				if (_compressed)
+					res.decompress(*rrmStream, &_sequenceBuffer[0], bgHeader._seqSize);
+				else
+					rrmStream->read(&_sequenceBuffer[0], bgHeader._seqSize);
+			} else if (!_compressed) {
+				// Serrated Scalpel uncompressed info
+				_bgShapes.resize(bgHeader._numStructs);
+				for (int idx = 0; idx < bgHeader._numStructs; ++idx)
+					_bgShapes[idx].load(*rrmStream, false);
+
+				if (bgHeader._descSize) {
+					_descText.resize(bgHeader._descSize);
+					rrmStream->read(&_descText[0], bgHeader._descSize);
+				}
+
+				if (bgHeader._seqSize) {
+					_sequenceBuffer.resize(bgHeader._seqSize);
+					rrmStream->read(&_sequenceBuffer[0], bgHeader._seqSize);
+				}
+			} else {
+				// Serrated Scalpel compressed info
+				Common::SeekableReadStream *infoStream;
+
+				// Read shapes
+				infoStream = Resources::decompressLZ(*rrmStream, bgHeader._numStructs * 569);
+
+				_bgShapes.resize(bgHeader._numStructs);
+				for (int idx = 0; idx < bgHeader._numStructs; ++idx)
+					_bgShapes[idx].load(*infoStream, false);
+
+				delete infoStream;
+
+				// Read description texts
+				if (bgHeader._descSize) {
+					infoStream = Resources::decompressLZ(*rrmStream, bgHeader._descSize);
+
+					_descText.resize(bgHeader._descSize);
+					infoStream->read(&_descText[0], bgHeader._descSize);
+
+					delete infoStream;
+				}
+
+				// Read sequences
+				if (bgHeader._seqSize) {
+					infoStream = Resources::decompressLZ(*rrmStream, bgHeader._seqSize);
+
+					_sequenceBuffer.resize(bgHeader._seqSize);
+					infoStream->read(&_sequenceBuffer[0], bgHeader._seqSize);
+
+					delete infoStream;
+				}
+			}
+
+			// Set up the list of images used by the scene
+			_images.resize(bgHeader._numImages + 1);
+			for (int idx = 0; idx < bgHeader._numImages; ++idx) {
+				_images[idx + 1]._filesize = bgInfo[idx]._filesize;
+				_images[idx + 1]._maxFrames = bgInfo[idx]._maxFrames;
+
+				// Read in the image data
+				Common::SeekableReadStream *imageStream = _compressed ?
+					res.decompress(*rrmStream, bgInfo[idx]._filesize) :
+					rrmStream->readStream(bgInfo[idx]._filesize);
+
+				_images[idx + 1]._images = new ImageFile(*imageStream);
+
+				delete imageStream;
+			}
+
+			// Set up the bgShapes
+			for (int idx = 0; idx < bgHeader._numStructs; ++idx) {
+				_bgShapes[idx]._images = _images[_bgShapes[idx]._misc]._images;
+				_bgShapes[idx]._imageFrame = !_bgShapes[idx]._images ? (ImageFrame *)nullptr :
+					&(*_bgShapes[idx]._images)[0];
+
+				_bgShapes[idx]._examine = Common::String(&_descText[_bgShapes[idx]._descOffset]);
+				_bgShapes[idx]._sequences = &_sequenceBuffer[_bgShapes[idx]._sequenceOffset];
+				_bgShapes[idx]._misc = 0;
+				_bgShapes[idx]._seqCounter = 0;
+				_bgShapes[idx]._seqCounter2 = 0;
+				_bgShapes[idx]._seqStack = 0;
+				_bgShapes[idx]._frameNumber = -1;
+				_bgShapes[idx]._oldPosition = Common::Point(0, 0);
+				_bgShapes[idx]._oldSize = Common::Point(1, 1);
+			}
+
+			// Load in cAnim list
+			_cAnim.clear();
+			if (bgHeader._numcAnimations) {
+				int animSize = IS_SERRATED_SCALPEL ? 65 : 47;
+				Common::SeekableReadStream *cAnimStream = _compressed ?
+					res.decompress(*rrmStream, animSize * bgHeader._numcAnimations) :
+					rrmStream->readStream(animSize * bgHeader._numcAnimations);
+
+				// Load cAnim offset table as well
+				uint32 *cAnimOffsetTablePtr = new uint32[bgHeader._numcAnimations];
+				uint32 *cAnimOffsetPtr = cAnimOffsetTablePtr;
+				memset(cAnimOffsetTablePtr, 0, bgHeader._numcAnimations * sizeof(uint32));
+ 				if (IS_SERRATED_SCALPEL) {
+					// Save current stream offset
+					int32 curOffset = rrmStream->pos();
+					rrmStream->seek(44); // Seek to cAnim-Offset-Table
+					for (uint16 curCAnim = 0; curCAnim < bgHeader._numcAnimations; curCAnim++) {
+						*cAnimOffsetPtr = rrmStream->readUint32LE();
+						cAnimOffsetPtr++;
+					}
+					// Seek back to original stream offset
+					rrmStream->seek(curOffset);
+				}
+				// TODO: load offset table for Rose Tattoo as well
+
+				// Go to the start of the cAnimOffsetTable
+				cAnimOffsetPtr = cAnimOffsetTablePtr;
+
+				_cAnim.resize(bgHeader._numcAnimations);
+				for (uint idx = 0; idx < _cAnim.size(); ++idx) {
+					_cAnim[idx].load(*cAnimStream, IS_ROSE_TATTOO, *cAnimOffsetPtr);
+					cAnimOffsetPtr++;
+				}
+
+				delete cAnimStream;
+				delete[] cAnimOffsetTablePtr;
+			}
+
+			
+
+			// Read in the room bounding areas
+			int size = rrmStream->readUint16LE();
+			Common::SeekableReadStream *boundsStream = !_compressed ? rrmStream :
+				res.decompress(*rrmStream, size);
+
+			_zones.resize(size / 10);
+			for (uint idx = 0; idx < _zones.size(); ++idx) {
+				_zones[idx].left = boundsStream->readSint16LE();
+				_zones[idx].top = boundsStream->readSint16LE();
+				_zones[idx].setWidth(boundsStream->readSint16LE() + 1);
+				_zones[idx].setHeight(boundsStream->readSint16LE() + 1);
+				boundsStream->skip(2);	// Skip unused scene number field
+			}
+
+			if (_compressed)
+				delete boundsStream;
+
+			// Ensure we've reached the path version byte
+			if (rrmStream->readByte() != (IS_SERRATED_SCALPEL ? 254 : 251))
+				error("Invalid scene path data");
+
+			// Load the walk directory and walk data
+			assert(_zones.size() < MAX_ZONES);
+
+
+			for (uint idx1 = 0; idx1 < _zones.size(); ++idx1) {
+				Common::fill(&_walkDirectory[idx1][0], &_walkDirectory[idx1][MAX_ZONES], 0);
+				for (uint idx2 = 0; idx2 < _zones.size(); ++idx2)
+					_walkDirectory[idx1][idx2] = rrmStream->readSint16LE();
+			}
+
+			// Read in the walk data
+			size = rrmStream->readUint16LE();
+			Common::SeekableReadStream *walkStream = !_compressed ? rrmStream->readStream(size) :
+				res.decompress(*rrmStream, size);
+
+			// Translate the file offsets of the walk directory to indexes in the loaded walk data
+			for (uint idx1 = 0; idx1 < _zones.size(); ++idx1) {
+				for (uint idx2 = 0; idx2 < _zones.size(); ++idx2) {
+					int dataOffset = _walkDirectory[idx1][idx2];
+					if (dataOffset == -1)
+						continue;
+
+					// Check to see if we've already loaded the walk set for the given data offset
+					uint dataIndex = 0;
+					while (dataIndex < _walkPoints.size() && _walkPoints[dataIndex]._fileOffset != dataOffset)
+						++dataIndex;
+
+					if (dataIndex == _walkPoints.size()) {
+						// Walk data for that offset hasn't been loaded yet, so load it now
+						_walkPoints.push_back(WalkArray());
+
+						walkStream->seek(dataOffset);
+						_walkPoints[_walkPoints.size() - 1]._fileOffset = dataOffset;
+						_walkPoints[_walkPoints.size() - 1].load(*walkStream, IS_ROSE_TATTOO);
+						dataIndex = _walkPoints.size() - 1;
+					}
+
+					_walkDirectory[idx1][idx2] = dataIndex;
+				}
+			}
+
+			delete walkStream;
+
+			if (IS_ROSE_TATTOO) {
+				// Read in the entrance
+				_entrance.load(*rrmStream);
+
+				// Load scale zones
+				_scaleZones.resize(rrmStream->readByte());
+				for (uint idx = 0; idx < _scaleZones.size(); ++idx)
+					_scaleZones[idx].load(*rrmStream);
+			}
+
+			// Read in the exits
+			int numExits = rrmStream->readByte();
+			_exits.resize(numExits);
+
+			for (int idx = 0; idx < numExits; ++idx)
+				_exits[idx].load(*rrmStream, IS_ROSE_TATTOO);
+
+			if (IS_SERRATED_SCALPEL)
+				// Read in the entrance
+				_entrance.load(*rrmStream);
+
+			// Initialize sound list
+			int numSounds = rrmStream->readByte();
+			_sounds.resize(numSounds);
+
+			for (int idx = 0; idx < numSounds; ++idx)
+				_sounds[idx].load(*rrmStream);
+
+			loadSceneSounds();
+
+			if (IS_ROSE_TATTOO) {
+				// Load the object sound list
+				char buffer[27];
+			
+				_objSoundList.resize(rrmStream->readUint16LE());
+				for (uint idx = 0; idx < _objSoundList.size(); ++idx) {
+					rrmStream->read(buffer, 27);
+					_objSoundList[idx] = Common::String(buffer);
+				}
+			} else {
+				// Read in palette
+				rrmStream->read(screen._cMap, PALETTE_SIZE);
+				screen.translatePalette(screen._cMap);
+				Common::copy(screen._cMap, screen._cMap + PALETTE_SIZE, screen._sMap);
+
+				// Read in the background
+				Common::SeekableReadStream *bgStream = !_compressed ? rrmStream :
+					res.decompress(*rrmStream, SHERLOCK_SCREEN_WIDTH * SHERLOCK_SCENE_HEIGHT);
+
+				bgStream->read(screen._backBuffer1.getPixels(), SHERLOCK_SCREEN_WIDTH * SHERLOCK_SCENE_HEIGHT);
+
+				if (_compressed)
+					delete bgStream;
+			}
+
+			// Backup the image and set the palette
+			screen._backBuffer2.blitFrom(screen._backBuffer1);
+			screen.setPalette(screen._cMap);
+
+			delete rrmStream;
+		}
+
+	} else {
+		// === 3DO version ===
+		_roomFilename = "rooms/" + filename + ".rrm";
+		flag = _vm->_res->exists(_roomFilename);
+		if (!flag)
+			error("loadScene: 3DO room data file not found");
+
+		Common::SeekableReadStream *roomStream = _vm->_res->load(_roomFilename);
+		uint32 roomStreamSize = roomStream->size();
+
+		// there should be at least all bytes of the header data
+		if (roomStreamSize < 128)
+			error("loadScene: 3DO room data file is too small");
+
+		// Read 3DO header
+		roomStream->skip(4); // UINT32: offset graphic data?
+		uint16 header3DO_numStructs = roomStream->readUint16BE();
+		uint16 header3DO_numImages = roomStream->readUint16BE();
+		uint16 header3DO_numAnimations = roomStream->readUint16BE();
+		roomStream->skip(6);
+
+		uint32 header3DO_bgInfo_offset        = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_bgInfo_size          = roomStream->readUint32BE();
+		uint32 header3DO_bgShapes_offset      = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_bgShapes_size        = roomStream->readUint32BE();
+		uint32 header3DO_descriptions_offset  = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_descriptions_size    = roomStream->readUint32BE();
+		uint32 header3DO_sequence_offset      = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_sequence_size        = roomStream->readUint32BE();
+		uint32 header3DO_cAnim_offset         = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_cAnim_size           = roomStream->readUint32BE();
+		uint32 header3DO_roomBounding_offset  = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_roomBounding_size    = roomStream->readUint32BE();
+		uint32 header3DO_walkDirectory_offset = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_walkDirectory_size   = roomStream->readUint32BE();
+		uint32 header3DO_walkData_offset      = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_walkData_size        = roomStream->readUint32BE();
+		uint32 header3DO_exits_offset         = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_exits_size           = roomStream->readUint32BE();
+		uint32 header3DO_entranceData_offset  = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_entranceData_size    = roomStream->readUint32BE();
+		uint32 header3DO_soundList_offset     = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_soundList_size       = roomStream->readUint32BE();
+		//uint32 header3DO_unknown_offset       = roomStream->readUint32BE() + 0x80;
+		//uint32 header3DO_unknown_size         = roomStream->readUint32BE();
+		roomStream->skip(8); // Skip over unknown offset+size
+		uint32 header3DO_bgGraphicData_offset = roomStream->readUint32BE() + 0x80;
+		uint32 header3DO_bgGraphicData_size   = roomStream->readUint32BE();
+
+		// Calculate amount of entries
+		int32 header3DO_soundList_count       = header3DO_soundList_size / 9;
+
+		_invGraphicItems = header3DO_numImages + 1;
+
+		// Verify all offsets
+		if (header3DO_bgInfo_offset >= roomStreamSize)
+			error("loadScene: 3DO bgInfo offset points outside of room file");
+		if (header3DO_bgInfo_size > (roomStreamSize - header3DO_bgInfo_offset))
+			error("loadScene: 3DO bgInfo size goes beyond room file");
+		if (header3DO_bgShapes_offset >= roomStreamSize)
+			error("loadScene: 3DO bgShapes offset points outside of room file");
+		if (header3DO_bgShapes_size > (roomStreamSize - header3DO_bgShapes_offset))
+			error("loadScene: 3DO bgShapes size goes beyond room file");
+		if (header3DO_descriptions_offset >= roomStreamSize)
+			error("loadScene: 3DO descriptions offset points outside of room file");
+		if (header3DO_descriptions_size > (roomStreamSize - header3DO_descriptions_offset))
+			error("loadScene: 3DO descriptions size goes beyond room file");
+		if (header3DO_sequence_offset >= roomStreamSize)
+			error("loadScene: 3DO sequence offset points outside of room file");
+		if (header3DO_sequence_size > (roomStreamSize - header3DO_sequence_offset))
+			error("loadScene: 3DO sequence size goes beyond room file");
+		if (header3DO_cAnim_offset >= roomStreamSize)
+			error("loadScene: 3DO cAnim offset points outside of room file");
+		if (header3DO_cAnim_size > (roomStreamSize - header3DO_cAnim_offset))
+			error("loadScene: 3DO cAnim size goes beyond room file");
+		if (header3DO_roomBounding_offset >= roomStreamSize)
+			error("loadScene: 3DO roomBounding offset points outside of room file");
+		if (header3DO_roomBounding_size > (roomStreamSize - header3DO_roomBounding_offset))
+			error("loadScene: 3DO roomBounding size goes beyond room file");
+		if (header3DO_walkDirectory_offset >= roomStreamSize)
+			error("loadScene: 3DO walkDirectory offset points outside of room file");
+		if (header3DO_walkDirectory_size > (roomStreamSize - header3DO_walkDirectory_offset))
+			error("loadScene: 3DO walkDirectory size goes beyond room file");
+		if (header3DO_walkData_offset >= roomStreamSize)
+			error("loadScene: 3DO walkData offset points outside of room file");
+		if (header3DO_walkData_size > (roomStreamSize - header3DO_walkData_offset))
+			error("loadScene: 3DO walkData size goes beyond room file");
+		if (header3DO_exits_offset >= roomStreamSize)
+			error("loadScene: 3DO exits offset points outside of room file");
+		if (header3DO_exits_size > (roomStreamSize - header3DO_exits_offset))
+			error("loadScene: 3DO exits size goes beyond room file");
+		if (header3DO_entranceData_offset >= roomStreamSize)
+			error("loadScene: 3DO entranceData offset points outside of room file");
+		if (header3DO_entranceData_size > (roomStreamSize - header3DO_entranceData_offset))
+			error("loadScene: 3DO entranceData size goes beyond room file");
+		if (header3DO_soundList_offset >= roomStreamSize)
+			error("loadScene: 3DO soundList offset points outside of room file");
+		if (header3DO_soundList_size > (roomStreamSize - header3DO_soundList_offset))
+			error("loadScene: 3DO soundList size goes beyond room file");
+		if (header3DO_bgGraphicData_offset >= roomStreamSize)
+			error("loadScene: 3DO bgGraphicData offset points outside of room file");
+		if (header3DO_bgGraphicData_size > (roomStreamSize - header3DO_bgGraphicData_offset))
+			error("loadScene: 3DO bgGraphicData size goes beyond room file");
+
+		// === BGINFO === read in the shapes header info
+		Common::Array<BgFileHeaderInfo> bgInfo;
+
+		uint32 expected3DO_bgInfo_size = header3DO_numStructs * 16;
+		if (expected3DO_bgInfo_size != header3DO_bgInfo_size) // Security check
+			error("loadScene: 3DO bgInfo size mismatch");
+
+		roomStream->seek(header3DO_bgInfo_offset);
+		bgInfo.resize(header3DO_numStructs);
+		for (uint idx = 0; idx < bgInfo.size(); ++idx)
+			bgInfo[idx].load3DO(*roomStream);
+
+		// === BGSHAPES === read in the shapes info
+		uint32 expected3DO_bgShapes_size = header3DO_numStructs * 588;
+		if (expected3DO_bgShapes_size != header3DO_bgShapes_size) // Security check
+			error("loadScene: 3DO bgShapes size mismatch");
+
+		roomStream->seek(header3DO_bgShapes_offset);
+		_bgShapes.resize(header3DO_numStructs);
+		for (int idx = 0; idx < header3DO_numStructs; ++idx)
+			_bgShapes[idx].load3DO(*roomStream);
+
+		// === DESCRIPTION === read description text
+		if (header3DO_descriptions_size) {
+			roomStream->seek(header3DO_descriptions_offset);
+			_descText.resize(header3DO_descriptions_size);
+			roomStream->read(&_descText[0], header3DO_descriptions_size);
+		}
+
+		// === SEQUENCE === read sequence buffer
+		if (header3DO_sequence_size) {
+			roomStream->seek(header3DO_sequence_offset);
+			_sequenceBuffer.resize(header3DO_sequence_size);
+			roomStream->read(&_sequenceBuffer[0], header3DO_sequence_size);
+		}
+
+		// === IMAGES === set up the list of images used by the scene
+		roomStream->seek(header3DO_bgGraphicData_offset);
+		_images.resize(header3DO_numImages + 1);
+		for (int idx = 0; idx < header3DO_numImages; ++idx) {
+			_images[idx + 1]._filesize = bgInfo[idx]._filesize;
+			_images[idx + 1]._maxFrames = bgInfo[idx]._maxFrames;
+
+			// Read image data into memory
+			Common::SeekableReadStream *imageStream = roomStream->readStream(bgInfo[idx]._filesize);
+
+			// Load image data into an ImageFile array as room file data
+			// which is basically a fixed header, followed by a raw cel header, followed by regular cel data
+			_images[idx + 1]._images = new ImageFile3DO(*imageStream, true);
+
+			delete imageStream;
+		}
+
+		// === BGSHAPES === Set up the bgShapes
+		for (int idx = 0; idx < header3DO_numStructs; ++idx) {
+			_bgShapes[idx]._images = _images[_bgShapes[idx]._misc]._images;
+			_bgShapes[idx]._imageFrame = !_bgShapes[idx]._images ? (ImageFrame *)nullptr :
+				&(*_bgShapes[idx]._images)[0];
+
+			_bgShapes[idx]._examine = Common::String(&_descText[_bgShapes[idx]._descOffset]);
+			_bgShapes[idx]._sequences = &_sequenceBuffer[_bgShapes[idx]._sequenceOffset];
+			_bgShapes[idx]._misc = 0;
+			_bgShapes[idx]._seqCounter = 0;
+			_bgShapes[idx]._seqCounter2 = 0;
+			_bgShapes[idx]._seqStack = 0;
+			_bgShapes[idx]._frameNumber = -1;
+			_bgShapes[idx]._oldPosition = Common::Point(0, 0);
+			_bgShapes[idx]._oldSize = Common::Point(1, 1);
+		}
+
+		// === CANIM === read cAnim list
+		_cAnim.clear();
+		if (header3DO_numAnimations) {
+			roomStream->seek(header3DO_cAnim_offset);
+			Common::SeekableReadStream *cAnimStream = roomStream->readStream(header3DO_cAnim_size);
+
+			uint32 *cAnimOffsetTablePtr = new uint32[header3DO_numAnimations];
+			uint32 *cAnimOffsetPtr = cAnimOffsetTablePtr;
+			uint32 cAnimOffset = 0;
+			memset(cAnimOffsetTablePtr, 0, header3DO_numAnimations * sizeof(uint32));
+
+			// Seek to end of graphics data and load cAnim offset table from there
+			roomStream->seek(header3DO_bgGraphicData_offset + header3DO_bgGraphicData_size);
+			for (uint16 curCAnim = 0; curCAnim < header3DO_numAnimations; curCAnim++) {
+				cAnimOffset = roomStream->readUint32BE();
+				if (cAnimOffset >= roomStreamSize)
+					error("loadScene: 3DO cAnim entry offset points outside of room file");
+
+				*cAnimOffsetPtr = cAnimOffset;
+				cAnimOffsetPtr++;
+			}
+
+			// Go to the start of the cAnimOffsetTable
+			cAnimOffsetPtr = cAnimOffsetTablePtr;
+
+			_cAnim.resize(header3DO_numAnimations);
+			for (uint idx = 0; idx < _cAnim.size(); ++idx) {
+				_cAnim[idx].load3DO(*cAnimStream, *cAnimOffsetPtr);
+				cAnimOffsetPtr++;
+			}
+
+			delete cAnimStream;
+			delete[] cAnimOffsetTablePtr;
+		}
+
+		// === BOUNDING AREAS === Read in the room bounding areas
+		int roomBoundingCount = header3DO_roomBounding_size / 12;
+		uint32 expected3DO_roomBounding_size = roomBoundingCount * 12;
+		if (expected3DO_roomBounding_size != header3DO_roomBounding_size)
+			error("loadScene: 3DO roomBounding size mismatch");
+
+		roomStream->seek(header3DO_roomBounding_offset);
+		_zones.resize(roomBoundingCount);
+		for (uint idx = 0; idx < _zones.size(); ++idx) {
+			_zones[idx].left = roomStream->readSint16BE();
+			_zones[idx].top = roomStream->readSint16BE();
+			_zones[idx].setWidth(roomStream->readSint16BE() + 1);
+			_zones[idx].setHeight(roomStream->readSint16BE() + 1);
+			roomStream->skip(4); // skip UINT32
+		}
+
+		// === WALK DIRECTORY === Load the walk directory
+		uint32 expected3DO_walkDirectory_size = _zones.size() * _zones.size() * 2;
+		if (expected3DO_walkDirectory_size != header3DO_walkDirectory_size)
+			error("loadScene: 3DO walkDirectory size mismatch");
+
+		roomStream->seek(header3DO_walkDirectory_offset);
+		assert(_zones.size() < MAX_ZONES);
+		for (uint idx1 = 0; idx1 < _zones.size(); ++idx1) {
+			for (uint idx2 = 0; idx2 < _zones.size(); ++idx2)
+				_walkDirectory[idx1][idx2] = roomStream->readSint16BE();
+		}
+
+		// === WALK DATA === Read in the walk data
+		roomStream->seek(header3DO_walkData_offset);
+
+		// Read in the walk data
+		Common::SeekableReadStream *walkStream = !_compressed ? roomStream->readStream(header3DO_walkData_size) :
+			res.decompress(*roomStream, header3DO_walkData_size);
+
+		// Translate the file offsets of the walk directory to indexes in the loaded walk data
+		for (uint idx1 = 0; idx1 < _zones.size(); ++idx1) {
+			for (uint idx2 = 0; idx2 < _zones.size(); ++idx2) {
+				int dataOffset = _walkDirectory[idx1][idx2];
+				if (dataOffset == -1)
+					continue;
+
+				// Check to see if we've already loaded the walk set for the given data offset
+				uint dataIndex = 0;
+				while (dataIndex < _walkPoints.size() && _walkPoints[dataIndex]._fileOffset != dataOffset)
+					++dataIndex;
+
+				if (dataIndex == _walkPoints.size()) {
+					// Walk data for that offset hasn't been loaded yet, so load it now
+					_walkPoints.push_back(WalkArray());
+
+					walkStream->seek(dataOffset);
+					_walkPoints[_walkPoints.size() - 1]._fileOffset = dataOffset;
+					_walkPoints[_walkPoints.size() - 1].load(*walkStream, IS_ROSE_TATTOO);
+					dataIndex = _walkPoints.size() - 1;
+				}
+
+				_walkDirectory[idx1][idx2] = dataIndex;
+			}
+		}
+
+		delete walkStream;
+
+		// === EXITS === Read in the exits
+		roomStream->seek(header3DO_exits_offset);
+
+		int exitsCount = header3DO_exits_size / 20;
+
+		_exits.resize(exitsCount);
+		for (int idx = 0; idx < exitsCount; ++idx)
+			_exits[idx].load3DO(*roomStream);
+
+		// === ENTRANCE === Read in the entrance
+		if (header3DO_entranceData_size != 8)
+			error("loadScene: 3DO entranceData size mismatch");
+
+		roomStream->seek(header3DO_entranceData_offset);
+		_entrance.load3DO(*roomStream);
+
+		// === SOUND LIST === Initialize sound list
+		roomStream->seek(header3DO_soundList_offset);
+		_sounds.resize(header3DO_soundList_count);
+		for (int idx = 0; idx < header3DO_soundList_count; ++idx)
+			_sounds[idx].load3DO(*roomStream);
+
+		delete roomStream;
+
+		// === BACKGROUND PICTURE ===
+		// load from file rooms\[filename].bg
+		// it's uncompressed 15-bit RGB555 data
+
+		Common::String roomBackgroundFilename = "rooms/" + filename + ".bg";
+		flag = _vm->_res->exists(roomBackgroundFilename);
+		if (!flag)
+			error("loadScene: 3DO room background file not found (%s)", roomBackgroundFilename.c_str());
+
+		Common::File roomBackgroundStream;
+		if (!roomBackgroundStream.open(roomBackgroundFilename))
+			error("Could not open file - %s", roomBackgroundFilename.c_str());
+
+		int totalPixelCount = SHERLOCK_SCREEN_WIDTH * SHERLOCK_SCENE_HEIGHT;
+		uint16 *roomBackgroundDataPtr = NULL;
+		uint16 *pixelSourcePtr = NULL;
+		uint16 *pixelDestPtr = (uint16 *)screen._backBuffer1.getPixels();
+		uint16  curPixel = 0;
+		uint32  roomBackgroundStreamSize = roomBackgroundStream.size();
+		uint32  expectedBackgroundSize   = totalPixelCount * 2;
+
+		// Verify file size of background file
+		if (expectedBackgroundSize != roomBackgroundStreamSize)
+			error("loadScene: 3DO room background file not expected size");
+
+		roomBackgroundDataPtr = new uint16[totalPixelCount];
+		roomBackgroundStream.read(roomBackgroundDataPtr, roomBackgroundStreamSize);
+		roomBackgroundStream.close();
+
+		// Convert data from RGB555 to RGB565
+		pixelSourcePtr = roomBackgroundDataPtr;
+		for (int pixels = 0; pixels < totalPixelCount; pixels++) {
+			curPixel = READ_BE_UINT16(pixelSourcePtr++);
+
+			byte curPixelRed   = (curPixel >> 10) & 0x1F;
+			byte curPixelGreen = (curPixel >> 5) & 0x1F;
+			byte curPixelBlue  = curPixel & 0x1F;
+			*pixelDestPtr = ((curPixelRed << 11) | (curPixelGreen << 6) | (curPixelBlue));
+			pixelDestPtr++;
+		}
+
+		delete[] roomBackgroundDataPtr;
+
+#if 0
+		// code to show the background
+		screen.blitFrom(screen._backBuffer1);
+		_vm->_events->wait(10000);
+#endif
+
+		// Backup the image
+		screen._backBuffer2.blitFrom(screen._backBuffer1);
+	}
+
+	// Handle drawing any on-screen interface
+	ui.drawInterface();
+
+	checkSceneStatus();
+
+	if (!saves._justLoaded) {
+		for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+			if (_bgShapes[idx]._type == HIDDEN && _bgShapes[idx]._aType == TALK_EVERY)
+				_bgShapes[idx].toggleHidden();
+		}
+
+		// Check for TURNON objects
+		for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+			if (_bgShapes[idx]._type == HIDDEN && (_bgShapes[idx]._flags & TURNON_OBJ))
+				_bgShapes[idx].toggleHidden();
+		}
+
+		// Check for TURNOFF objects
+		for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+			if (_bgShapes[idx]._type != HIDDEN && (_bgShapes[idx]._flags & TURNOFF_OBJ) &&
+					_bgShapes[idx]._type != INVALID)
+				_bgShapes[idx].toggleHidden();
+			if (_bgShapes[idx]._type == HIDE_SHAPE)
+				// Hiding isn't needed, since objects aren't drawn yet
+				_bgShapes[idx]._type = HIDDEN;
+		}
+	}
+
+	checkSceneFlags(false);
+	checkInventory();
+
+	// Handle starting any music for the scene
+	if (IS_SERRATED_SCALPEL && music._musicOn && music.loadSong(_currentScene))
+		music.startSong();
+
+	// Load walking images if not already loaded
+	people.loadWalk();
+
+	// Transition to the scene and setup entrance co-ordinates and animations
+	transitionToScene();
+
+	// Player has not yet walked in this scene
+	_walkedInScene = false;
+	saves._justLoaded = false;
+
+	events.clearEvents();
+	return flag;
+}
+
+void Scene::loadSceneSounds() {
+	Sound &sound = *_vm->_sound;
+
+	for (uint idx = 0; idx < _sounds.size(); ++idx)
+		sound.loadSound(_sounds[idx]._name, _sounds[idx]._priority);
+}
+
+void Scene::checkSceneStatus() {
+	if (_sceneStats[_currentScene][MAX_BGSHAPES]) {
+		for (int idx = 0; idx < MAX_BGSHAPES; ++idx) {
+			bool flag = _sceneStats[_currentScene][idx];
+
+			if (idx < (int)_bgShapes.size()) {
+				Object &obj = _bgShapes[idx];
+
+				if (flag) {
+					// No shape to erase, so flag as hidden
+					obj._type = HIDDEN;
+				} else if (obj._images == nullptr || obj._images->size() == 0) {
+					// No shape
+					obj._type = NO_SHAPE;
+				} else {
+					obj._type = ACTIVE_BG_SHAPE;
+				}
+			} else {
+				// Finished checks
+				return;
+			}
+		}
+	}
+}
+
+void Scene::saveSceneStatus() {
+	// Flag any objects for the scene that have been altered
+	int count = MIN((int)_bgShapes.size(), MAX_BGSHAPES);
+	for (int idx = 0; idx < count; ++idx) {
+		Object &obj = _bgShapes[idx];
+		_sceneStats[_currentScene][idx] = obj._type == HIDDEN || obj._type == REMOVE
+			|| obj._type == HIDE_SHAPE || obj._type == INVALID;
+	}
+
+	// Flag scene as having been visited
+	_sceneStats[_currentScene][MAX_BGSHAPES] = true;
+}
+
+void Scene::checkSceneFlags(bool flag) {
+	SpriteType mode = flag ? HIDE_SHAPE : HIDDEN;
+
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &o = _bgShapes[idx];
+
+		if (o._requiredFlag[0] || o._requiredFlag[1]) {
+			bool objectFlag = true;
+			if (o._requiredFlag[0] != 0)
+				objectFlag = _vm->readFlags(o._requiredFlag[0]);
+			if (o._requiredFlag[1] != 0)
+				objectFlag &= _vm->readFlags(o._requiredFlag[1]);
+
+			if (!objectFlag) {
+				// Kill object
+				if (o._type != HIDDEN && o._type != INVALID) {
+					if (o._images == nullptr || o._images->size() == 0)
+						// No shape to erase, so flag as hidden
+						o._type = HIDDEN;
+					else
+						// Flag it as needing to be hidden after first erasing it
+						o._type = mode;
+				}
+			} else if (IS_ROSE_TATTOO || o._requiredFlag[0] > 0) {
+				// Restore object
+				if (o._images == nullptr || o._images->size() == 0)
+					o._type = NO_SHAPE;
+				else
+					o._type = ACTIVE_BG_SHAPE;
+			}
+		}
+	}
+
+	// Check inventory for items to remove based on flag changes
+	for (int idx = 0; idx < _vm->_inventory->_holdings; ++idx) {
+		InventoryItem &ii = (*_vm->_inventory)[idx];
+		if (ii._requiredFlag && !_vm->readFlags(ii._requiredFlag)) {
+			// Kill object: move it after the active holdings
+			InventoryItem tempItem = (*_vm->_inventory)[idx];
+			_vm->_inventory->insert_at(_vm->_inventory->_holdings, tempItem);
+			_vm->_inventory->remove_at(idx);
+			_vm->_inventory->_holdings--;
+		}
+	}
+
+	// Check inactive inventory items for ones to reactivate based on flag changes
+	for (uint idx = _vm->_inventory->_holdings; idx < _vm->_inventory->size(); ++idx) {
+		InventoryItem &ii = (*_vm->_inventory)[idx];
+		if (ii._requiredFlag && _vm->readFlags(ii._requiredFlag)) {
+			// Restore object: move it after the active holdings
+			InventoryItem tempItem = (*_vm->_inventory)[idx];
+			_vm->_inventory->remove_at(idx);
+			_vm->_inventory->insert_at(_vm->_inventory->_holdings, tempItem);
+			_vm->_inventory->_holdings++;
+		}
+	}
+}
+
+void Scene::checkInventory() {
+	for (uint shapeIdx = 0; shapeIdx < _bgShapes.size(); ++shapeIdx) {
+		for (int invIdx = 0; invIdx < _vm->_inventory->_holdings; ++invIdx) {
+			if (_bgShapes[shapeIdx]._name.equalsIgnoreCase((*_vm->_inventory)[invIdx]._name)) {
+				_bgShapes[shapeIdx]._type = INVALID;
+				break;
+			}
+		}
+	}
+}
+
+void Scene::transitionToScene() {
+	People &people = *_vm->_people;
+	SaveManager &saves = *_vm->_saves;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	Point32 &hSavedPos = people._savedPos;
+	int &hSavedFacing = people._savedPos._facing;
+
+	if (hSavedPos.x < 1) {
+		// No exit information from last scene-check entrance info
+		if (_entrance._startPosition.x < 1) {
+			// No entrance info either, so use defaults
+			if (IS_SERRATED_SCALPEL) {
+				hSavedPos = Point32(160 * FIXED_INT_MULTIPLIER, 100 * FIXED_INT_MULTIPLIER);
+				hSavedFacing = 4;
+			} else {
+				hSavedPos = people[HOLMES]._position;
+				hSavedFacing = people[HOLMES]._sequenceNumber;
+			}
+		} else {
+			// setup entrance info
+			hSavedPos.x = _entrance._startPosition.x * FIXED_INT_MULTIPLIER;
+			hSavedPos.y = _entrance._startPosition.y * FIXED_INT_MULTIPLIER;
+			if (IS_SERRATED_SCALPEL) {
+				hSavedPos.x /= 100;
+				hSavedPos.y /= 100;
+			}
+
+			hSavedFacing = _entrance._startDir;
+		}
+	} else {
+		// Exit information exists, translate it to real sequence info
+		// Note: If a savegame was just loaded, then the data is already correct.
+		// Otherwise, this is a linked scene or entrance info, and must be translated
+		if (hSavedFacing < 8 && !saves._justLoaded) {
+			if (IS_ROSE_TATTOO)
+				hSavedFacing = Tattoo::FS_TRANS[hSavedFacing];
+			else			
+				hSavedFacing = Scalpel::FS_TRANS[hSavedFacing];
+			
+			hSavedPos.x *= FIXED_INT_MULTIPLIER;
+			hSavedPos.y *= FIXED_INT_MULTIPLIER;
+		}
+	}
+
+	int cAnimNum = -1;
+
+	if (!saves._justLoaded) {
+		if (hSavedFacing < 101) {
+			// Standard info, so set it
+			people[HOLMES]._position = hSavedPos;
+			people[HOLMES]._sequenceNumber = hSavedFacing;
+		} else {
+			// It's canimation information
+			cAnimNum = hSavedFacing - 101;
+		}
+	}
+
+	// Reset positioning for next load
+	hSavedPos = Common::Point(-1, -1);
+	hSavedFacing = -1;
+
+	if (cAnimNum != -1) {
+		// Prevent Holmes from being drawn
+		people[HOLMES]._position = Common::Point(0, 0);
+	}
+
+	// If the scene is capable of scrolling, set the current scroll so that whoever has control 
+	// of the scroll code is in the middle of the screen
+	if (screen._backBuffer1.w() > SHERLOCK_SCREEN_WIDTH)
+		people[people._walkControl].centerScreenOnPerson();
+
+	for (uint objIdx = 0; objIdx < _bgShapes.size(); ++objIdx) {
+		Object &obj = _bgShapes[objIdx];
+
+		if (obj._aType > 1 && obj._type != INVALID && obj._type != HIDDEN) {
+			Common::Point topLeft = obj._position;
+			Common::Point bottomRight;
+
+			if (obj._type != NO_SHAPE) {
+				topLeft += obj._imageFrame->_offset;
+				bottomRight.x = topLeft.x + obj._imageFrame->_frame.w;
+				bottomRight.y = topLeft.y + obj._imageFrame->_frame.h;
+			} else {
+				bottomRight = topLeft + obj._noShapeSize;
+			}
+
+			if (Common::Rect(topLeft.x, topLeft.y, bottomRight.x, bottomRight.y).contains(
+					Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER, 
+					people[HOLMES]._position.y / FIXED_INT_MULTIPLIER))) {
+				// Current point is already inside box - impact occurred on
+				// a previous call. So simply do nothing except talk until the
+				// player is clear of the box
+				switch (obj._aType) {
+				case FLAG_SET:
+					for (int useNum = 0; useNum < USE_COUNT; ++useNum) {
+						if (obj._use[useNum]._useFlag) {
+							if (!_vm->readFlags(obj._use[useNum]._useFlag))
+								_vm->setFlags(obj._use[useNum]._useFlag);
+						}
+
+						if (!talk._talkToAbort) {
+							for (int nameIdx = 0; nameIdx < NAMES_COUNT; ++nameIdx) {
+								toggleObject(obj._use[useNum]._names[nameIdx]);
+							}
+						}
+					}
+
+					obj._type = HIDDEN;
+					break;
+
+				default:
+					break;
+				}
+			}
+		}
+	}
+
+	updateBackground();
+
+	// Actually do the transition
+	if (screen._fadeStyle) {
+		if (!IS_3DO) {
+			// do pixel-transition for PC
+			screen.randomTransition();
+		} else {
+			// fade in for 3DO
+			screen.clear();
+			static_cast<Scalpel::Scalpel3DOScreen *>(_vm->_screen)->fadeIntoScreen3DO(3);
+		}
+	} else {
+		screen.slamArea(screen._currentScroll.x, screen._currentScroll.y, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+	}
+	screen.update();
+
+	// Start any initial animation for the scene
+	if (cAnimNum != -1) {
+		CAnim &c = _cAnim[cAnimNum];
+		PositionFacing pt = c._goto[0];
+
+		c._goto[0].x = c._goto[0].y = -1;
+		people[HOLMES]._position = Common::Point(0, 0);
+
+		startCAnim(cAnimNum, 1);
+		c._goto[0] = pt;
+	}
+}
+
+int Scene::toggleObject(const Common::String &name) {
+	int count = 0;
+
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		if (name.equalsIgnoreCase(_bgShapes[idx]._name)) {
+			++count;
+			_bgShapes[idx].toggleHidden();
+		}
+	}
+
+	return count;
+}
+
+void Scene::updateBackground() {
+	People &people = *_vm->_people;
+
+	// Update Holmes if he's turned on
+	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+		if (people[idx]._type == CHARACTER)
+			people[idx].adjustSprite();
+	}
+
+	// Flag the bg shapes which need to be redrawn
+	checkBgShapes();
+
+	// Draw the shapes for the scene
+	drawAllShapes();
+}
+
+Exit *Scene::checkForExit(const Common::Rect &r) {
+	for (uint idx = 0; idx < _exits.size(); ++idx) {
+		if (_exits[idx].intersects(r))
+			return &_exits[idx];
+	}
+
+	return nullptr;
+}
+
+int Scene::checkForZones(const Common::Point &pt, int zoneType) {
+	int matches = 0;
+
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &o = _bgShapes[idx];
+		if ((o._aType == zoneType && o._type != INVALID) && o._type != HIDDEN) {
+			Common::Rect r = o._type == NO_SHAPE ? o.getNoShapeBounds() : o.getNewBounds();
+
+			if (r.contains(pt)) {
+				++matches;
+				o.setFlagsAndToggles();
+				_vm->_talk->talkTo(o._use[0]._target);
+			}
+		}
+	}
+
+	return matches;
+}
+
+int Scene::whichZone(const Common::Point &pt) {
+	for (uint idx = 0; idx < _zones.size(); ++idx) {
+		if (_zones[idx].contains(pt))
+			return idx;
+	}
+
+	return -1;
+}
+
+void Scene::synchronize(Serializer &s) {
+	if (s.isSaving())
+		saveSceneStatus();
+
+	if (s.isSaving()) {
+		s.syncAsSint16LE(_currentScene);
+	} else {
+		s.syncAsSint16LE(_goToScene);
+	}
+
+	for (int sceneNum = 1; sceneNum < SCENES_COUNT; ++sceneNum) {
+		for (int flag = 0; flag <= MAX_BGSHAPES; ++flag) {
+			s.syncAsByte(_sceneStats[sceneNum][flag]);
+		}
+	}
+}
+
+void Scene::checkBgShapes() {
+	People &people = *_vm->_people;
+	Person &holmes = people[HOLMES];
+	Common::Point pt(holmes._position.x / FIXED_INT_MULTIPLIER, holmes._position.y / FIXED_INT_MULTIPLIER);
+
+	// Iterate through the shapes
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &obj = _bgShapes[idx];
+		if (obj._type == ACTIVE_BG_SHAPE || (IS_SERRATED_SCALPEL && obj._type == STATIC_BG_SHAPE)) {
+			if ((obj._flags & 5) == 1) {
+				obj._misc = (pt.y < (obj._position.y + obj.frameHeight() - 1)) ?
+					NORMAL_FORWARD : NORMAL_BEHIND;
+			} else if (!(obj._flags & OBJ_BEHIND)) {
+				obj._misc = BEHIND;
+			} else if (obj._flags & OBJ_FORWARD) {
+				obj._misc = FORWARD;
+			}
+		}
+	}
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/scene.h b/engines/sherlock/scene.h
new file mode 100644
index 0000000000..f7aa39fd41
--- /dev/null
+++ b/engines/sherlock/scene.h
@@ -0,0 +1,321 @@
+/* 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 SHERLOCK_SCENE_H
+#define SHERLOCK_SCENE_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/rect.h"
+#include "common/serializer.h"
+#include "sherlock/objects.h"
+#include "sherlock/resources.h"
+#include "sherlock/screen.h"
+
+namespace Sherlock {
+
+#define MAX_ZONES	40
+#define INFO_LINE	140
+
+class SherlockEngine;
+
+struct BgFileHeader {
+	int _numStructs;
+	int _numImages;
+	int _numcAnimations;
+	int _descSize;
+	int _seqSize;
+
+	// Serrated Scalpel
+	int _fill;
+
+	// Rose Tattoo
+	int _scrollSize;
+	int _bytesWritten;				// Size of the main body of the RRM
+	int _fadeStyle;					// Fade style
+	byte _palette[PALETTE_SIZE];	// Palette
+
+
+	BgFileHeader();
+
+	/**
+	 * Load the data for the object
+	 */
+	void load(Common::SeekableReadStream &s, bool isRoseTattoo);
+};
+
+struct BgFileHeaderInfo {
+	int _filesize;				// How long images are
+	int _maxFrames;				// How many unique frames in object
+	Common::String _filename;	// Filename of object
+
+	/**
+	 * Load the data for the object
+	 */
+	void load(Common::SeekableReadStream &s);
+	void load3DO(Common::SeekableReadStream &s);
+};
+
+class Exit: public Common::Rect {
+public:
+	int _scene;
+	int _allow;
+	PositionFacing _newPosition;
+
+	Common::String _dest;
+	int _image;					// Arrow image to use
+
+	/**
+	 * Load the data for the object
+	 */
+	void load(Common::SeekableReadStream &s, bool isRoseTattoo);
+	void load3DO(Common::SeekableReadStream &s);
+};
+
+struct SceneEntry {
+	Common::Point _startPosition;
+	int _startDir;
+	int _allow;
+
+	/**
+	 * Load the data for the object
+	 */
+	void load(Common::SeekableReadStream &s);
+	void load3DO(Common::SeekableReadStream &s);
+};
+
+struct SceneSound {
+	Common::String _name;
+	int _priority;
+
+	/**
+	 * Load the data for the object
+	 */
+	void load(Common::SeekableReadStream &s);
+	void load3DO(Common::SeekableReadStream &s);
+};
+
+class ObjectArray : public Common::Array<Object> {
+public:
+	/**
+	 * Retuurn the index of the passed object in the array
+	 */
+	int indexOf(const Object &obj) const;
+};
+
+class ScaleZone: public Common::Rect {
+public:
+	int _topNumber;		// Numerator of scale size at the top of the zone
+	int _bottomNumber;	// Numerator of scale size at the bottom of the zone
+
+	void load(Common::SeekableReadStream &s);
+};
+
+class WalkArray : public Common::Array < Common::Point > {
+public:
+	int _pointsCount;
+	int _fileOffset;
+
+	WalkArray() : _pointsCount(0), _fileOffset(-1) {}
+
+	/**
+	 * Load data for the walk array entry
+	 */
+	void load(Common::SeekableReadStream &s, bool isRoseTattoo);
+};
+
+class Scene {
+private:
+	/**
+	 * Loads sounds for the scene
+	 */
+	void loadSceneSounds();
+
+	/**
+	 * Set objects to their current persistent state. This includes things such as
+	 * opening or moving them
+	 */
+	void checkSceneStatus();
+
+	/**
+	 * Checks scene objects against the player's inventory items. If there are any
+	 * matching names, it means the given item has already been picked up, and should
+	 * be hidden in the scene.
+	 */
+	void checkInventory();
+
+	/**
+	 * Set up any entrance co-ordinates or entrance canimations, and then transition
+	 * in the scene
+	 */
+	void transitionToScene();
+
+	/**
+	 * Restores objects to the correct status. This ensures that things like being opened or moved
+	 * will remain the same on future visits to the scene
+	 */
+	void saveSceneStatus();
+protected:
+	SherlockEngine *_vm;
+	Common::String _roomFilename;
+
+	/**
+	 * Loads the data associated for a given scene. The room resource file's format is:
+	 * BGHEADER: Holds an index for the rest of the file
+	 * STRUCTS:  The objects for the scene
+	 * IMAGES:   The graphic information for the structures
+	 *
+	 * The _misc field of the structures contains the number of the graphic image
+	 * that it should point to after loading; _misc is then set to 0.
+	 */
+	virtual bool loadScene(const Common::String &filename);
+
+	/**
+	 * Checks all the background shapes. If a background shape is animating,
+	 * it will flag it as needing to be drawn. If a non-animating shape is
+	 * colliding with another shape, it will also flag it as needing drawing
+	 */
+	virtual void checkBgShapes();
+
+	/**
+	 * Draw all the shapes, people and NPCs in the correct order
+	 */
+	virtual void drawAllShapes() = 0;
+
+	/**
+	 * Called by loadScene when the palette is loaded for Rose Tattoo
+	 */
+	virtual void paletteLoaded() {}
+
+	Scene(SherlockEngine *vm);
+public:
+	int _currentScene;
+	int _goToScene;
+	bool **_sceneStats;
+	bool _walkedInScene;
+	int _version;
+	bool _compressed;
+	int _invGraphicItems;
+	Common::String _comments;
+	Common::Array<char> _descText;
+	Common::Array<Common::Rect> _zones;
+	ObjectArray _bgShapes;
+	Common::Array<CAnim> _cAnim;
+	Common::Array<byte> _sequenceBuffer;
+	Common::Array<SceneImage> _images;
+	int _walkDirectory[MAX_ZONES][MAX_ZONES];
+	Common::Array<WalkArray> _walkPoints;
+	Common::Array<Exit> _exits;
+	SceneEntry _entrance;
+	Common::Array<SceneSound> _sounds;
+	Common::Array<Object *> _canimShapes;
+	Common::Array<ScaleZone> _scaleZones;
+	Common::StringArray _objSoundList;
+	bool _restoreFlag;
+	int _animating;
+	bool _doBgAnimDone;
+	int _tempFadeStyle;
+	int _cAnimFramePause;
+public:
+	static Scene *init(SherlockEngine *vm);
+	virtual ~Scene();
+
+	/**
+	 * Handles loading the scene specified by _goToScene
+	 */
+	void selectScene();
+
+	/**
+	 * Check the scene's objects against the game flags. If false is passed,
+	 * it means the scene has just been loaded. A value of true means that the scene
+	 * is in use (ie. not just loaded)
+	 */
+	void checkSceneFlags(bool mode);
+
+	/**
+	 * Check whether the passed area intersects with one of the scene's exits
+	 */
+	Exit *checkForExit(const Common::Rect &r);
+
+	/**
+	 * Scans through the object list to find one with a matching name, and will
+	 * call toggleHidden with all matches found. Returns the numer of matches found
+	 */
+	int toggleObject(const Common::String &name);
+
+	/**
+	 * Checks to see if the given position in the scene belongs to a given zone type.
+	 * If it is, the zone is activated and used just like a TAKL zone or aFLAG_SET zone.
+	 */
+	int checkForZones(const Common::Point &pt, int zoneType);
+
+	/**
+	 * Check which zone the the given position is located in.
+	 */
+	int whichZone(const Common::Point &pt);
+
+	/**
+	 * Fres all the graphics and other dynamically allocated data for the scene
+	 */
+	virtual void freeScene();
+
+	/**
+	 * Returns the index of the closest zone to a given point.
+	 */
+	virtual int closestZone(const Common::Point &pt) = 0;
+
+	/**
+	 * Attempts to find a background shape within the passed bounds. If found,
+	 * it will return the shape number, or -1 on failure.
+	 */
+	virtual int findBgShape(const Common::Point &pt) = 0;
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	virtual void synchronize(Serializer &s);
+public:
+	/**
+	 * Draw all objects and characters.
+	 */
+	virtual void doBgAnim() = 0;
+
+	/**
+	 * Update the screen back buffer with all of the scene objects which need
+	 * to be drawn
+	 */
+	virtual void updateBackground();
+
+	/**
+	 * Attempt to start a canimation sequence. It will load the requisite graphics, and
+	 * then copy the canim object into the _canimShapes array to start the animation.
+	 *
+	 * @param cAnimNum		The canim object within the current scene
+	 * @param playRate		Play rate. 0 is invalid; 1=normal speed, 2=1/2 speed, etc.
+	 *		A negative playRate can also be specified to play the animation in reverse
+	 */
+	virtual int startCAnim(int cAnimNum, int playRate = 1) = 0;
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/screen.cpp b/engines/sherlock/screen.cpp
new file mode 100644
index 0000000000..74da2a80ea
--- /dev/null
+++ b/engines/sherlock/screen.cpp
@@ -0,0 +1,432 @@
+/* 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 "sherlock/screen.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/scalpel/scalpel_screen.h"
+#include "common/system.h"
+#include "common/util.h"
+#include "graphics/palette.h"
+
+namespace Sherlock {
+
+Screen *Screen::init(SherlockEngine *vm) {
+	if (vm->getGameID() == GType_RoseTattoo)
+		return new Screen(vm);
+	else if (vm->getPlatform() == Common::kPlatform3DO)
+		return new Scalpel::Scalpel3DOScreen(vm);
+	else
+		return new Scalpel::ScalpelScreen(vm);
+}
+
+Screen::Screen(SherlockEngine *vm) : Surface(g_system->getWidth(), g_system->getHeight()), _vm(vm),
+		_backBuffer1(vm->getGameID() == GType_RoseTattoo ? 640 : 320, vm->getGameID() == GType_RoseTattoo ? 480 : 200),
+		_backBuffer2(vm->getGameID() == GType_RoseTattoo ? 640 : 320, vm->getGameID() == GType_RoseTattoo ? 480 : 200),
+		_backBuffer(&_backBuffer1) {
+	_transitionSeed = 1;
+	_fadeStyle = false;
+	Common::fill(&_cMap[0], &_cMap[PALETTE_SIZE], 0);
+	Common::fill(&_sMap[0], &_sMap[PALETTE_SIZE], 0);
+	Common::fill(&_tMap[0], &_tMap[PALETTE_SIZE], 0);
+	
+	// Set up the initial font
+	setFont(IS_SERRATED_SCALPEL ? 1 : 4);
+
+	// Rose Tattoo specific fields
+	_fadeBytesRead = _fadeBytesToRead = 0;
+	_oldFadePercent = 0;
+	_flushScreen = false;
+}
+
+Screen::~Screen() {
+	Fonts::free();
+}
+
+void Screen::update() {
+	// Merge the dirty rects
+	mergeDirtyRects();
+
+	// Loop through copying dirty areas to the physical screen
+	Common::List<Common::Rect>::iterator i;
+	for (i = _dirtyRects.begin(); i != _dirtyRects.end(); ++i) {
+		const Common::Rect &r = *i;
+		const byte *srcP = (const byte *)getBasePtr(r.left, r.top);
+		g_system->copyRectToScreen(srcP, _surface.pitch, r.left, r.top,
+			r.width(), r.height());
+	}
+
+	// Signal the physical screen to update
+	g_system->updateScreen();
+	_dirtyRects.clear();
+}
+
+void Screen::makeAllDirty() {
+	addDirtyRect(Common::Rect(0, 0, this->w(), this->h()));
+}
+
+void Screen::getPalette(byte palette[PALETTE_SIZE]) {
+	g_system->getPaletteManager()->grabPalette(palette, 0, PALETTE_COUNT);
+}
+
+void Screen::setPalette(const byte palette[PALETTE_SIZE]) {
+	g_system->getPaletteManager()->setPalette(palette, 0, PALETTE_COUNT);
+}
+
+int Screen::equalizePalette(const byte palette[PALETTE_SIZE]) {
+	int total = 0;
+	byte tempPalette[PALETTE_SIZE];
+	getPalette(tempPalette);
+
+	// For any palette component that doesn't already match the given destination
+	// palette, change by 1 towards the reference palette component
+	for (int idx = 0; idx < PALETTE_SIZE; ++idx) {
+		if (tempPalette[idx] > palette[idx]) {
+			tempPalette[idx] = MAX((int)palette[idx], (int)tempPalette[idx] - 4);
+			++total;
+		} else if (tempPalette[idx] < palette[idx]) {
+			tempPalette[idx] = MIN((int)palette[idx], (int)tempPalette[idx] + 4);
+			++total;
+		}
+	}
+
+	if (total > 0)
+		// Palette changed, so reload it
+		setPalette(tempPalette);
+
+	return total;
+}
+
+void Screen::fadeToBlack(int speed) {
+	byte tempPalette[PALETTE_SIZE];
+	Common::fill(&tempPalette[0], &tempPalette[PALETTE_SIZE], 0);
+
+	while (equalizePalette(tempPalette)) {
+		_vm->_events->delay(15 * speed);
+	}
+
+	setPalette(tempPalette);
+	fillRect(Common::Rect(0, 0, _surface.w, _surface.h), 0);
+}
+
+void Screen::fadeIn(const byte palette[PALETTE_SIZE], int speed) {
+	int count = 50;
+	while (equalizePalette(palette) && --count) {
+		_vm->_events->delay(15 * speed);
+	}
+
+	setPalette(palette);
+}
+
+void Screen::addDirtyRect(const Common::Rect &r) {
+	_dirtyRects.push_back(r);
+	assert(r.width() > 0 && r.height() > 0);
+}
+
+void Screen::mergeDirtyRects() {
+	Common::List<Common::Rect>::iterator rOuter, rInner;
+
+	// Process the dirty rect list to find any rects to merge
+	for (rOuter = _dirtyRects.begin(); rOuter != _dirtyRects.end(); ++rOuter) {
+		rInner = rOuter;
+		while (++rInner != _dirtyRects.end()) {
+
+			if ((*rOuter).intersects(*rInner)) {
+				// these two rectangles overlap or
+				// are next to each other - merge them
+
+				unionRectangle(*rOuter, *rOuter, *rInner);
+
+				// remove the inner rect from the list
+				_dirtyRects.erase(rInner);
+
+				// move back to beginning of list
+				rInner = rOuter;
+			}
+		}
+	}
+}
+
+bool Screen::unionRectangle(Common::Rect &destRect, const Common::Rect &src1, const Common::Rect &src2) {
+	destRect = src1;
+	destRect.extend(src2);
+
+	return !destRect.isEmpty();
+}
+
+void Screen::randomTransition() {
+	Events &events = *_vm->_events;
+	const int TRANSITION_MULTIPLIER = 0x15a4e35;
+	_dirtyRects.clear();
+	assert(IS_SERRATED_SCALPEL);
+
+	for (int idx = 0; idx <= 65535 && !_vm->shouldQuit(); ++idx) {
+		_transitionSeed = _transitionSeed * TRANSITION_MULTIPLIER + 1;
+		int offset = _transitionSeed & 0xFFFF;
+
+		if (offset < (this->w() * this->h()))
+			*((byte *)getPixels() + offset) = *((const byte *)_backBuffer->getPixels() + offset);
+
+		if (idx != 0 && (idx % 300) == 0) {
+			// Ensure there's a full screen dirty rect for the next frame update
+			if (_dirtyRects.empty())
+				addDirtyRect(Common::Rect(0, 0, _surface.w, _surface.h));
+
+			events.pollEvents();
+			events.delay(1);
+		}
+	}
+
+	// Make sure everything has been transferred
+	blitFrom(*_backBuffer);
+}
+
+void Screen::verticalTransition() {
+	Events &events = *_vm->_events;
+
+	byte table[640];
+	Common::fill(&table[0], &table[640], 0);
+
+	for (int yp = 0; yp < this->h(); ++yp) {
+		for (int xp = 0; xp < this->w(); ++xp) {
+			int temp = (table[xp] >= (this->h() - 3)) ? this->h() - table[xp] :
+				_vm->getRandomNumber(3) + 1;
+
+			if (temp) {
+				blitFrom(_backBuffer1, Common::Point(xp, table[xp]),
+					Common::Rect(xp, table[xp], xp + 1, table[xp] + temp));
+				table[xp] += temp;
+			}
+		}
+
+		events.delay(10);
+	}
+}
+
+void Screen::restoreBackground(const Common::Rect &r) {
+	if (r.width() > 0 && r.height() > 0)
+		_backBuffer->blitFrom(_backBuffer2, Common::Point(r.left, r.top), r);
+}
+
+void Screen::slamArea(int16 xp, int16 yp, int16 width, int16 height) {
+	slamRect(Common::Rect(xp, yp, xp + width, yp + height));
+}
+
+void Screen::slamRect(const Common::Rect &r) {
+	if (r.width() && r.height() > 0) {
+		Common::Rect srcRect = r, destRect = r;
+
+		destRect.translate(-_currentScroll.x, -_currentScroll.y);
+
+		if (destRect.left < 0) {
+			srcRect.left += -destRect.left;
+			destRect.left = 0;
+		}
+		if (destRect.top < 0) {
+			srcRect.top += -destRect.top;
+			destRect.top = 0;
+		}
+		if (destRect.right > SHERLOCK_SCREEN_WIDTH) {
+			srcRect.right -= (destRect.left - SHERLOCK_SCREEN_WIDTH);
+			destRect.right = SHERLOCK_SCREEN_WIDTH;
+		}
+		if (destRect.bottom > SHERLOCK_SCREEN_HEIGHT) {
+			srcRect.bottom -= (destRect.bottom - SHERLOCK_SCREEN_HEIGHT);
+			destRect.bottom = SHERLOCK_SCREEN_HEIGHT;
+		}
+
+		if (srcRect.isValidRect())
+			blitFrom(*_backBuffer, Common::Point(destRect.left, destRect.top), srcRect);
+	}
+}
+
+
+void Screen::flushImage(ImageFrame *frame, const Common::Point &pt, int16 *xp, int16 *yp, 
+		int16 *width, int16 *height) {
+	Common::Point imgPos = pt + frame->_offset;
+	Common::Rect newBounds(imgPos.x, imgPos.y, imgPos.x + frame->_frame.w, imgPos.y + frame->_frame.h);
+	Common::Rect oldBounds(*xp, *yp, *xp + *width, *yp + *height);
+
+	if (!_flushScreen) {
+		// See if the areas of the old and new overlap, and if so combine the areas
+		if (newBounds.intersects(oldBounds)) {
+			Common::Rect mergedBounds = newBounds;
+			mergedBounds.extend(oldBounds);
+			mergedBounds.right += 1;
+			mergedBounds.bottom += 1;
+
+			slamRect(mergedBounds);
+		} else {
+			// The two areas are independent, so copy them both
+			slamRect(newBounds);
+			slamRect(oldBounds);
+		}
+	}
+
+	*xp = newBounds.left;
+	*yp = newBounds.top;
+	*width = newBounds.width();
+	*height = newBounds.height();
+}
+
+void Screen::flushScaleImage(ImageFrame *frame, const Common::Point &pt, int16 *xp, int16 *yp,
+		int16 *width, int16 *height, int scaleVal) {
+	Common::Point imgPos(pt.x + frame->sDrawXOffset(scaleVal), pt.y + frame->sDrawYOffset(scaleVal));
+	Common::Rect newBounds(imgPos.x, imgPos.y, imgPos.x + frame->sDrawXSize(scaleVal), 
+		imgPos.y + frame->sDrawYSize(scaleVal));
+	Common::Rect oldBounds(*xp, *yp, *xp + *width, *yp + *height);
+
+	if (!_flushScreen) {
+		// See if the areas of the old and new overlap, and if so combine the areas
+		if (newBounds.intersects(oldBounds)) {
+			Common::Rect mergedBounds = newBounds;
+			mergedBounds.extend(oldBounds);
+			mergedBounds.right += 1;
+			mergedBounds.bottom += 1;
+
+			slamRect(mergedBounds);
+		} else {
+			// The two areas are independent, so copy them both
+			slamRect(newBounds);
+			slamRect(oldBounds);
+		}
+	}
+
+	*xp = newBounds.left;
+	*yp = newBounds.top;
+	*width = newBounds.width();
+	*height = newBounds.height();
+}
+
+void Screen::flushImage(ImageFrame *frame, const Common::Point &pt, Common::Rect &newBounds, int scaleVal) {
+	Common::Point newPos(newBounds.left, newBounds.top);
+	Common::Point newSize(newBounds.width(), newBounds.height());
+
+	if (scaleVal == SCALE_THRESHOLD)
+		flushImage(frame, pt, &newPos.x, &newPos.y, &newSize.x, &newSize.y);
+	else
+		flushScaleImage(frame, pt, &newPos.x, &newPos.y, &newSize.x, &newSize.y, scaleVal);
+
+	// Transfer the pos and size amounts into a single bounds rect
+	newBounds = Common::Rect(newPos.x, newPos.y, newPos.x + newSize.x, newPos.y + newSize.y);
+}
+
+void Screen::blockMove(const Common::Rect &r) {
+	Common::Rect bounds = r;
+	slamRect(bounds);
+}
+
+void Screen::blockMove() {
+	blockMove(Common::Rect(0, 0, w(), h()));
+}
+
+void Screen::print(const Common::Point &pt, uint color, const char *formatStr, ...) {
+	// Create the string to display
+	va_list args;
+	va_start(args, formatStr);
+	Common::String str = Common::String::vformat(formatStr, args);
+	va_end(args);
+
+	// Figure out area to draw text in
+	Common::Point pos = pt;
+	int width = stringWidth(str);
+	pos.y--;		// Font is always drawing one line higher
+	if (!pos.x)
+		// Center text horizontally
+		pos.x = (this->w() - width) / 2;
+
+	Common::Rect textBounds(pos.x, pos.y, pos.x + width, pos.y + _fontHeight);
+	if (textBounds.right > this->w())
+		textBounds.moveTo(this->w() - width, textBounds.top);
+	if (textBounds.bottom > this->h())
+		textBounds.moveTo(textBounds.left, this->h() - _fontHeight);
+
+	// Write out the string at the given position
+	writeString(str, Common::Point(textBounds.left, textBounds.top), color);
+
+	// Copy the affected area to the screen
+	slamRect(textBounds);
+}
+
+void Screen::gPrint(const Common::Point &pt, uint color, const char *formatStr, ...) {
+	// Create the string to display
+	va_list args;
+	va_start(args, formatStr);
+	Common::String str = Common::String::vformat(formatStr, args);
+	va_end(args);
+
+	// Print the text
+	writeString(str, pt, color);
+}
+
+void Screen::writeString(const Common::String &str, const Common::Point &pt, uint overrideColor) {
+	Fonts::writeString(_backBuffer, str, pt, overrideColor);
+}
+
+void Screen::vgaBar(const Common::Rect &r, int color) {
+	_backBuffer->fillRect(r, color);
+	slamRect(r);
+}
+
+void Screen::setDisplayBounds(const Common::Rect &r) {
+	_sceneSurface.setPixels(_backBuffer1.getBasePtr(r.left, r.top), r.width(), r.height(), _backBuffer1.getPixelFormat());
+
+	_backBuffer = &_sceneSurface;
+}
+
+void Screen::resetDisplayBounds() {
+	_backBuffer = &_backBuffer1;
+}
+
+Common::Rect Screen::getDisplayBounds() {
+	return (_backBuffer == &_sceneSurface) ? Common::Rect(0, 0, _sceneSurface.w(), _sceneSurface.h()) :
+		Common::Rect(0, 0, this->w(), this->h());
+}
+
+void Screen::synchronize(Serializer &s) {
+	int fontNumb = _fontNumber;
+	s.syncAsByte(fontNumb);
+	if (s.isLoading())
+		setFont(fontNumb);
+}
+
+void Screen::initPaletteFade(int bytesToRead) {
+	Common::copy(&_cMap[0], &_cMap[PALETTE_SIZE], &_sMap[0]);
+	Common::copy(&_cMap[0], &_cMap[PALETTE_SIZE], &_tMap[0]);
+
+	// Set how many bytes need to be read / have been read
+	_fadeBytesRead = 0;
+	_fadeBytesToRead = bytesToRead;
+	_oldFadePercent = 0;
+}
+
+int Screen::fadeRead(Common::SeekableReadStream &stream, byte *buf, int totalSize) {
+	warning("TODO: fadeRead");
+	stream.read(buf, totalSize);
+	return totalSize;
+}
+
+void Screen::translatePalette(byte palette[PALETTE_SIZE]) {
+	for (int idx = 0; idx < PALETTE_SIZE; ++idx)
+		palette[idx] = VGA_COLOR_TRANS(palette[idx]);
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/screen.h b/engines/sherlock/screen.h
new file mode 100644
index 0000000000..04a0c1e505
--- /dev/null
+++ b/engines/sherlock/screen.h
@@ -0,0 +1,233 @@
+/* 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 SHERLOCK_SCREEN_H
+#define SHERLOCK_SCREEN_H
+
+#include "common/list.h"
+#include "common/rect.h"
+#include "sherlock/surface.h"
+#include "sherlock/resources.h"
+#include "sherlock/saveload.h"
+
+namespace Sherlock {
+
+#define PALETTE_SIZE 768
+#define PALETTE_COUNT 256
+#define VGA_COLOR_TRANS(x) ((x) * 255 / 63)
+#define BG_GREYSCALE_RANGE_END 229
+#define BLACK 0
+
+class SherlockEngine;
+
+class Screen : public Surface {
+private:
+	Common::List<Common::Rect> _dirtyRects;
+	uint32 _transitionSeed;
+	Surface _sceneSurface;
+
+	// Rose Tattoo fields
+	int _fadeBytesRead, _fadeBytesToRead;
+	int _oldFadePercent;
+private:
+	/**
+	 * Merges together overlapping dirty areas of the screen
+	 */
+	void mergeDirtyRects();
+
+	/**
+	 * Returns the union of two dirty area rectangles
+	 */
+	bool unionRectangle(Common::Rect &destRect, const Common::Rect &src1, const Common::Rect &src2);
+protected:
+	SherlockEngine *_vm;
+
+	/**
+	 * Clear the current dirty rects list
+	 */
+	void clearDirtyRects() { _dirtyRects.clear(); }
+
+	/**
+	 * Adds a rectangle to the list of modified areas of the screen during the
+	 * current frame
+	 */
+	virtual void addDirtyRect(const Common::Rect &r);
+public:
+	Surface _backBuffer1, _backBuffer2;
+	Surface *_backBuffer;
+	bool _fadeStyle;
+	byte _cMap[PALETTE_SIZE];
+	byte _sMap[PALETTE_SIZE];
+	byte _tMap[PALETTE_SIZE];
+	bool _flushScreen;
+	Common::Point _currentScroll;
+public:
+	static Screen *init(SherlockEngine *vm);
+	Screen(SherlockEngine *vm);
+	virtual ~Screen();
+
+	/**
+	 * Handles updating any dirty areas of the screen Surface object to the physical screen
+	 */
+	void update();
+
+	/**
+	 * Makes the whole screen dirty
+	 */
+	void makeAllDirty();
+
+	/**
+	 * Return the currently active palette
+	 */
+	void getPalette(byte palette[PALETTE_SIZE]);
+
+	/**
+	 * Set the palette
+	 */
+	void setPalette(const byte palette[PALETTE_SIZE]);
+
+	/**
+	 * Fades from the currently active palette to the passed palette
+	 */
+	int equalizePalette(const byte palette[PALETTE_SIZE]);
+
+	/**
+	 * Fade out the palette to black
+	 */
+	void fadeToBlack(int speed = 2);
+
+	/**
+	 * Fade in a given palette
+	 */
+	void fadeIn(const byte palette[PALETTE_SIZE], int speed = 2);
+
+	/**
+	 * Do a random pixel transition in from _backBuffer surface to the screen
+	 */
+	void randomTransition();
+
+	/**
+	 * Transition to the surface from _backBuffer using a vertical transition
+	 */
+	void verticalTransition();
+
+	/**
+	 * Prints the text passed onto the back buffer at the given position and color.
+	 * The string is then blitted to the screen
+	 */
+	void print(const Common::Point &pt, uint color, const char *formatStr, ...) GCC_PRINTF(4, 5);
+
+	/**
+	 * Print a strings onto the back buffer without blitting it to the screen
+	 */
+	void gPrint(const Common::Point &pt, uint color, const char *formatStr, ...) GCC_PRINTF(4, 5);
+
+	/**
+	 * Copies a section of the second back buffer into the main back buffer
+	 */
+	void restoreBackground(const Common::Rect &r);
+
+	/**
+	 * Copies a given area to the screen
+	 */
+	void slamArea(int16 xp, int16 yp, int16 width, int16 height);
+
+	/**
+	 * Copies a given area to the screen
+	 */
+	void slamRect(const Common::Rect &r);
+
+	/**
+	 * Copy an image from the back buffer to the screen, taking care of both the
+	 * new area covered by the shape as well as the old area, which must be restored
+	 */
+	void flushImage(ImageFrame *frame, const Common::Point &pt, int16 *xp, int16 *yp, 
+		int16 *width, int16 *height);
+
+	/**
+	 * Similar to flushImage, this method takes in an extra parameter for the scale proporation,
+	 * which affects the calculated bounds accordingly
+	 */
+	void flushScaleImage(ImageFrame *frame, const Common::Point &pt, int16 *xp, int16 *yp, 
+		int16 *width, int16 *height, int scaleVal);
+
+	/**
+	 * Variation of flushImage/flushScaleImage that takes in and updates a rect
+	 */
+	void flushImage(ImageFrame *frame, const Common::Point &pt, Common::Rect &newBounds, int scaleVal);
+
+	/**
+	 * Copies data from the back buffer to the screen
+	 */
+	void blockMove(const Common::Rect &r);
+
+	/**
+	 * Copies the entire screen from the back buffer
+	 */
+	void blockMove();
+
+	/**
+	 * Fills an area on the back buffer, and then copies it to the screen
+	 */
+	void vgaBar(const Common::Rect &r, int color);
+
+	/**
+	 * Sets the active back buffer pointer to a restricted sub-area of the first back buffer
+	 */
+	void setDisplayBounds(const Common::Rect &r);
+
+	/**
+	 * Resets the active buffer pointer to point back to the full first back buffer
+	 */
+	void resetDisplayBounds();
+
+	/**
+	 * Return the size of the current display window
+	 */
+	Common::Rect getDisplayBounds();
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	void synchronize(Serializer &s);
+
+	/**
+	 * Draws the given string into the back buffer using the images stored in _font
+	 */
+	virtual void writeString(const Common::String &str, const Common::Point &pt, uint overrideColor);
+
+
+	// Rose Tattoo specific methods
+	void initPaletteFade(int bytesToRead);
+
+	int fadeRead(Common::SeekableReadStream &stream, byte *buf, int totalSize);
+
+	/**
+	 * Translate a palette from 6-bit RGB values to full 8-bit values suitable for passing
+	 * to the underlying palette manager
+	 */
+	static void translatePalette(byte palette[PALETTE_SIZE]);
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/sherlock.cpp b/engines/sherlock/sherlock.cpp
new file mode 100644
index 0000000000..d09fd0b270
--- /dev/null
+++ b/engines/sherlock/sherlock.cpp
@@ -0,0 +1,283 @@
+/* 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 "sherlock/sherlock.h"
+#include "sherlock/surface.h"
+#include "common/scummsys.h"
+#include "common/config-manager.h"
+#include "common/debug-channels.h"
+
+namespace Sherlock {
+
+SherlockEngine::SherlockEngine(OSystem *syst, const SherlockGameDescription *gameDesc) :
+		Engine(syst), _gameDescription(gameDesc), _randomSource("Sherlock") {
+	_animation = nullptr;
+	_debugger = nullptr;
+	_events = nullptr;
+	_fixedText = nullptr;
+	_inventory = nullptr;
+	_journal = nullptr;
+	_map = nullptr;
+	_music = nullptr;
+	_people = nullptr;
+	_res = nullptr;
+	_saves = nullptr;
+	_scene = nullptr;
+	_screen = nullptr;
+	_sound = nullptr;
+	_talk = nullptr;
+	_ui = nullptr;
+	_useEpilogue2 = false;
+	_loadGameSlot = -1;
+	_canLoadSave = false;
+	_showOriginalSavesDialog = false;
+	_interactiveFl = true;
+	_isScreenDoubled = false;
+}
+
+SherlockEngine::~SherlockEngine() {
+	delete _animation;
+	delete _debugger;
+	delete _events;
+	delete _fixedText;
+	delete _journal;
+	delete _map;
+	delete _people;
+	delete _saves;
+	delete _scene;
+	delete _screen;
+	delete _music;
+	delete _sound;
+	delete _talk;
+	delete _ui;
+	delete _inventory;
+	delete _res;
+}
+
+void SherlockEngine::initialize() {
+	DebugMan.addDebugChannel(kDebugLevelScript,      "scripts", "Script debug level");
+	DebugMan.addDebugChannel(kDebugLevelAdLibDriver, "AdLib",   "AdLib driver debugging");
+	DebugMan.addDebugChannel(kDebugLevelMT32Driver,  "MT32",    "MT32 driver debugging");
+	DebugMan.addDebugChannel(kDebugLevelMusic,       "Music",   "Music debugging");
+
+	Fonts::setVm(this);
+	ImageFile::setVm(this);
+	ImageFile3DO::setVm(this);
+	BaseObject::setVm(this);
+
+	if (isDemo()) {
+		Common::File f;
+		// The interactive demo doesn't have an intro thus doesn't include TITLE.SND
+		// At the opposite, the non-interactive demo is only the intro.
+		if (f.exists("TITLE.SND"))
+			_interactiveFl = false;
+	}
+
+	_res = new Resources(this);
+	_animation = new Animation(this);
+	_debugger = Debugger::init(this);
+	_events = new Events(this);
+	_fixedText = FixedText::init(this);
+	_inventory = Inventory::init(this);
+	_map = Map::init(this);
+	_music = new Music(this, _mixer);
+	_journal = Journal::init(this);
+	_people = People::init(this);
+	_saves = SaveManager::init(this, _targetName);
+	_scene = Scene::init(this);
+	_screen = Screen::init(this);
+	_sound = new Sound(this, _mixer);
+	_talk = Talk::init(this);
+	_ui = UserInterface::init(this);
+
+	// Load game settings
+	loadConfig();
+
+	if (getPlatform() == Common::kPlatform3DO) {
+		// Disable portraits on 3DO
+		// 3DO does not include portrait data
+		_people->_portraitsOn = false;
+	}
+}
+
+Common::Error SherlockEngine::run() {
+	// Initialize the engine
+	initialize();
+
+	// Flag for whether to show original saves dialog rather than the ScummVM GMM
+	_showOriginalSavesDialog = ConfMan.getBool("originalsaveload");
+
+	// If requested, load a savegame instead of showing the intro
+	if (ConfMan.hasKey("save_slot")) {
+		int saveSlot = ConfMan.getInt("save_slot");
+		if (saveSlot >= 0 && saveSlot <= MAX_SAVEGAME_SLOTS)
+			_loadGameSlot = saveSlot;
+	}
+
+	if (_loadGameSlot != -1) {
+		_saves->loadGame(_loadGameSlot);
+		_loadGameSlot = -1;
+	} else {
+		do
+			showOpening();
+		while (!shouldQuit() && !_interactiveFl);
+	}
+
+	while (!shouldQuit()) {
+		// Prepare for scene, and handle any game-specific scenes. This allows
+		// for game specific cutscenes or mini-games that aren't standard scenes
+		startScene();
+		if (shouldQuit())
+			break;
+
+		// Clear the screen
+		_screen->clear();
+
+		// Reset UI flags
+		_ui->reset();
+
+		// Reset the data for the player character (Sherlock)
+		_people->reset();
+
+		// Initialize and load the scene.
+		_scene->selectScene();
+
+		// Scene handling loop
+		sceneLoop();
+	}
+
+	return Common::kNoError;
+}
+
+void SherlockEngine::sceneLoop() {
+	while (!shouldQuit() && _scene->_goToScene == -1) {
+		// See if a script needs to be completed from either a goto room code,
+		// or a script that was interrupted by another script
+		if (_talk->_scriptMoreFlag == 1 || _talk->_scriptMoreFlag == 3)
+			_talk->talkTo(_talk->_scriptName);
+		else
+			_talk->_scriptMoreFlag = 0;
+
+		// Handle any input from the keyboard or mouse
+		handleInput();
+
+		if (_people->_savedPos.x == -1) {
+			_canLoadSave = true;
+			_scene->doBgAnim();
+			_canLoadSave = false;
+		}
+	}
+
+	_scene->freeScene();
+	_people->freeWalk();
+}
+
+void SherlockEngine::handleInput() {
+	_canLoadSave = _ui->_menuMode == STD_MODE || _ui->_menuMode == LAB_MODE;
+	_events->pollEventsAndWait();
+	_canLoadSave = false;
+
+	// See if a key or mouse button is pressed
+	_events->setButtonState();
+
+	_ui->handleInput();
+}
+
+bool SherlockEngine::readFlags(int flagNum) {
+	bool value = _flags[ABS(flagNum)];
+	if (flagNum < 0)
+		value = !value;
+
+	return value;
+}
+
+void SherlockEngine::setFlags(int flagNum) {
+	_flags[ABS(flagNum)] = flagNum >= 0;
+
+	_scene->checkSceneFlags(true);
+}
+
+void SherlockEngine::setFlagsDirect(int flagNum) {
+	_flags[ABS(flagNum)] = flagNum >= 0;
+}
+
+void SherlockEngine::loadConfig() {
+	// Load sound settings
+	syncSoundSettings();
+
+	ConfMan.registerDefault("font", getGameID() == GType_SerratedScalpel ? 1 : 4);
+
+	_screen->setFont(ConfMan.getInt("font"));
+	if (getGameID() == GType_SerratedScalpel)
+		_screen->_fadeStyle = ConfMan.getBool("fade_style");
+
+	_ui->_helpStyle = ConfMan.getBool("help_style");
+	_ui->_slideWindows = ConfMan.getBool("window_style");
+	_people->_portraitsOn = ConfMan.getBool("portraits_on");
+}
+
+void SherlockEngine::saveConfig() {
+	ConfMan.setBool("mute", !_sound->_digitized);
+	ConfMan.setBool("music_mute", !_music->_musicOn);
+	ConfMan.setBool("speech_mute", !_sound->_speechOn);
+
+	ConfMan.setInt("font", _screen->fontNumber());
+	ConfMan.setBool("fade_style", _screen->_fadeStyle);
+	ConfMan.setBool("help_style", _ui->_helpStyle);
+	ConfMan.setBool("window_style", _ui->_slideWindows);
+	ConfMan.setBool("portraits_on", _people->_portraitsOn);
+
+	ConfMan.flushToDisk();
+}
+
+void SherlockEngine::syncSoundSettings() {
+	Engine::syncSoundSettings();
+
+	// Load sound-related settings
+	_sound->syncSoundSettings();
+	_music->syncMusicSettings();
+}
+
+void SherlockEngine::synchronize(Serializer &s) {
+	for (uint idx = 0; idx < _flags.size(); ++idx)
+		s.syncAsByte(_flags[idx]);
+}
+
+bool SherlockEngine::canLoadGameStateCurrently() {
+	return _canLoadSave;
+}
+
+bool SherlockEngine::canSaveGameStateCurrently() {
+	return _canLoadSave;
+}
+
+Common::Error SherlockEngine::loadGameState(int slot) {
+	_saves->loadGame(slot);
+	return Common::kNoError;
+}
+
+Common::Error SherlockEngine::saveGameState(int slot, const Common::String &desc) {
+	_saves->saveGame(slot, desc);
+	return Common::kNoError;
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/sherlock.h b/engines/sherlock/sherlock.h
new file mode 100644
index 0000000000..b85321c385
--- /dev/null
+++ b/engines/sherlock/sherlock.h
@@ -0,0 +1,233 @@
+/* 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 SHERLOCK_HOLMES_H
+#define SHERLOCK_HOLMES_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/endian.h"
+#include "common/hash-str.h"
+#include "common/serializer.h"
+#include "common/random.h"
+#include "common/savefile.h"
+#include "common/util.h"
+#include "engines/engine.h"
+#include "sherlock/animation.h"
+#include "sherlock/debugger.h"
+#include "sherlock/events.h"
+#include "sherlock/fixed_text.h"
+#include "sherlock/inventory.h"
+#include "sherlock/journal.h"
+#include "sherlock/map.h"
+#include "sherlock/music.h"
+#include "sherlock/people.h"
+#include "sherlock/resources.h"
+#include "sherlock/saveload.h"
+#include "sherlock/scene.h"
+#include "sherlock/screen.h"
+#include "sherlock/sound.h"
+#include "sherlock/talk.h"
+#include "sherlock/user_interface.h"
+
+namespace Sherlock {
+
+enum {
+	kDebugLevelScript      = 1 << 0,
+	kDebugLevelAdLibDriver = 2 << 0,
+	kDebugLevelMT32Driver  = 3 << 0,
+	kDebugLevelMusic       = 4 << 0
+};
+
+enum GameType {
+	GType_SerratedScalpel = 0,
+	GType_RoseTattoo = 1
+};
+
+#define SHERLOCK_SCREEN_WIDTH _vm->_screen->w()
+#define SHERLOCK_SCREEN_HEIGHT _vm->_screen->h()
+#define SHERLOCK_SCENE_WIDTH _vm->_screen->_backBuffer1.w()
+#define SHERLOCK_SCENE_HEIGHT (IS_SERRATED_SCALPEL ? 138 : 480)
+#define SCENES_COUNT (IS_SERRATED_SCALPEL ? 63 : 101)
+#define MAX_BGSHAPES (IS_SERRATED_SCALPEL ? 64 : 150)
+
+#define COL_INFO_FOREGROUND (IS_SERRATED_SCALPEL ? (byte)Scalpel::INFO_FOREGROUND : (byte)Tattoo::INFO_FOREGROUND)
+#define COL_PEN_COLOR (IS_SERRATED_SCALPEL ? (byte)Scalpel::PEN_COLOR : (byte)Tattoo::PEN_COLOR)
+#define COL_PEN_HIGHLIGHT (IS_SERRATED_SCALPEL ? 15 : 129)
+
+struct SherlockGameDescription;
+
+class Resource;
+
+class SherlockEngine : public Engine {
+private:
+\
+	/**
+	 * Main loop for displaying a scene and handling all that occurs within it
+	 */
+	void sceneLoop();
+
+	/**
+	 * Handle all player input
+	 */
+	void handleInput();
+protected:
+	/**
+	 * Does basic initialization of the game engine
+	 */
+	virtual void initialize();
+
+	virtual void showOpening() = 0;
+
+	virtual void startScene() {}
+
+	/**
+	 * Returns a list of features the game itself supports
+	 */
+	virtual bool hasFeature(EngineFeature f) const;
+
+	/**
+	 * Load game configuration esttings
+	 */
+	virtual void loadConfig();
+public:
+	const SherlockGameDescription *_gameDescription;
+	Animation *_animation;
+	Debugger *_debugger;
+	Events *_events;
+	FixedText *_fixedText;
+	Inventory *_inventory;
+	Journal *_journal;
+	Map *_map;
+	Music *_music;
+	People *_people;
+	Resources *_res;
+	SaveManager *_saves;
+	Scene *_scene;
+	Screen *_screen;
+	Sound *_sound;
+	Talk *_talk;
+	UserInterface *_ui;
+	Common::RandomSource _randomSource;
+	Common::Array<bool> _flags;
+	bool _useEpilogue2;
+	int _loadGameSlot;
+	bool _canLoadSave;
+	bool _showOriginalSavesDialog;
+	bool _interactiveFl;
+	bool _isScreenDoubled;
+public:
+	SherlockEngine(OSystem *syst, const SherlockGameDescription *gameDesc);
+	virtual ~SherlockEngine();
+
+	/**
+	 * Main method for running the game
+	 */
+	virtual Common::Error run();
+
+	/**
+	 * Returns true if a savegame can be loaded
+	 */
+	virtual bool canLoadGameStateCurrently();
+
+	/**
+	 * Returns true if the game can be saved
+	 */
+	virtual bool canSaveGameStateCurrently();
+
+	/**
+	 * Called by the GMM to load a savegame
+	 */
+	virtual Common::Error loadGameState(int slot);
+
+	/**
+	 * Called by the GMM to save the game
+	 */
+	virtual Common::Error saveGameState(int slot, const Common::String &desc);
+
+	/**
+	 * Called by the engine when sound settings are updated
+	 */
+	virtual void syncSoundSettings();
+
+	/**
+	 * Saves game configuration information
+	 */
+	virtual void saveConfig();
+
+	/**
+	 * Returns whether the version is a demo
+	 */
+	virtual bool isDemo() const;
+
+	/**
+	 * Returns the Id of the game
+	 */
+	GameType getGameID() const;
+
+	/**
+	 * Returns the platform the game's datafiles are for
+	 */
+	Common::Platform getPlatform() const;
+
+	/**
+	 * Return the game's language
+	 */
+	Common::Language getLanguage() const;
+
+	/**
+	 * Return a random number
+	 */
+	int getRandomNumber(int limit) { return _randomSource.getRandomNumber(limit - 1); }
+
+	/**
+	 * Read the state of a global flag
+	 * @remarks		If a negative value is specified, it will return the inverse value
+	 *		of the positive flag number
+	 */
+	bool readFlags(int flagNum);
+
+	/**
+	 * Sets a global flag to either true or false depending on whether the specified
+	 * flag is positive or negative
+	 */
+	void setFlags(int flagNum);
+
+	/**
+	 * Set a global flag to 0 or 1 depending on whether the passed flag is negative or positive.
+	 * @remarks		We don't use the global setFlags method because we don't want to check scene flags
+	 */
+	void setFlagsDirect(int flagNum);
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	void synchronize(Serializer &s);
+};
+
+#define IS_ROSE_TATTOO (_vm->getGameID() == GType_RoseTattoo)
+#define IS_SERRATED_SCALPEL (_vm->getGameID() == GType_SerratedScalpel)
+#define IS_3DO (_vm->getPlatform() == Common::kPlatform3DO)
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/sound.cpp b/engines/sherlock/sound.cpp
new file mode 100644
index 0000000000..56ac2a5d9a
--- /dev/null
+++ b/engines/sherlock/sound.cpp
@@ -0,0 +1,337 @@
+/* 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 "sherlock/sherlock.h"
+#include "sherlock/sound.h"
+#include "common/config-manager.h"
+#include "audio/audiostream.h"
+#include "common/algorithm.h"
+#include "audio/mixer.h"
+#include "audio/decoders/raw.h"
+#include "audio/decoders/aiff.h"
+#include "audio/decoders/wave.h"
+
+namespace Sherlock {
+
+static const int8 creativeADPCM_ScaleMap[64] = {
+	0,  1,  2,  3,  4,  5,  6,  7,  0,  -1,  -2,  -3,  -4,  -5,  -6,  -7,
+	1,  3,  5,  7,  9, 11, 13, 15, -1,  -3,  -5,  -7,  -9, -11, -13, -15,
+	2,  6, 10, 14, 18, 22, 26, 30, -2,  -6, -10, -14, -18, -22, -26, -30,
+	4, 12, 20, 28, 36, 44, 52, 60, -4, -12, -20, -28, -36, -44, -52, -60
+};
+
+static const uint8 creativeADPCM_AdjustMap[64] = {
+	0, 0, 0, 0, 0, 16, 16, 16,
+	0, 0, 0, 0, 0, 16, 16, 16,
+	240, 0, 0, 0, 0, 16, 16, 16,
+	240, 0, 0, 0, 0, 16, 16, 16,
+	240, 0, 0, 0, 0, 16, 16, 16,
+	240, 0, 0, 0, 0, 16, 16, 16,
+	240, 0, 0, 0, 0,  0,  0,  0,
+	240, 0, 0, 0, 0,  0,  0,  0
+};
+
+/*----------------------------------------------------------------*/
+
+Sound::Sound(SherlockEngine *vm, Audio::Mixer *mixer) : _vm(vm), _mixer(mixer) {
+	_digitized = false;
+	_voices = 0;
+	_soundPlaying = false;
+	_speechPlaying = false;
+	_curPriority = 0;
+	_soundVolume = 255;
+
+	_soundOn = true;
+	_speechOn = true;
+
+	if (IS_3DO) {
+		// 3DO: we don't need to prepare anything for sound
+		return;
+	}
+
+	_vm->_res->addToCache("MUSIC.LIB");
+	if (!_vm->_interactiveFl)
+		_vm->_res->addToCache("TITLE.SND");
+	else {
+		_vm->_res->addToCache("MUSIC.LIB");
+		
+		if (IS_ROSE_TATTOO) {
+			_vm->_res->addToCache("SOUND.LIB");
+		} else {
+			_vm->_res->addToCache("SND.SND");
+
+			if (!_vm->isDemo()) {
+				_vm->_res->addToCache("TITLE.SND");
+				_vm->_res->addToCache("EPILOGUE.SND");
+			}
+		}
+	}
+}
+
+void Sound::syncSoundSettings() {
+	_digitized = !ConfMan.getBool("mute");
+	_speechOn = !ConfMan.getBool("mute") && !ConfMan.getBool("speech_mute");
+	_voices = _digitized ? 1 : 0;
+}
+
+void Sound::loadSound(const Common::String &name, int priority) {
+	// No implementation required in ScummVM
+	//warning("loadSound");
+}
+
+byte Sound::decodeSample(byte sample, byte &reference, int16 &scale) {
+	int16 samp = sample + scale;
+	int16 ref = 0;
+
+	// clip bad ADPCM-4 sample
+	samp = CLIP<int16>(samp, 0, 63);
+
+	ref = reference + creativeADPCM_ScaleMap[samp];
+	if (ref > 0xff) {
+		reference = 0xff;
+	} else {
+		if (ref < 0x00) {
+			reference = 0;
+		} else {
+			reference = (uint8)(ref & 0xff);
+		}
+	}
+
+	scale = (scale + creativeADPCM_AdjustMap[samp]) & 0xff;
+	return reference;
+}
+
+bool Sound::playSound(const Common::String &name, WaitType waitType, int priority, const char *libraryFilename) {
+	stopSound();
+
+	Common::String filename = formFilename(name);
+
+	Audio::SoundHandle &soundHandle = (IS_SERRATED_SCALPEL) ? _scalpelEffectsHandle : getFreeSoundHandle();
+	if (!playSoundResource(filename, libraryFilename, Audio::Mixer::kSFXSoundType, soundHandle))
+		error("Could not find sound resource - %s", filename.c_str());
+
+	_soundPlaying = true;
+	_curPriority = priority;
+
+	if (waitType == WAIT_RETURN_IMMEDIATELY) {
+		return true;
+	}
+
+	bool retval = true;
+	do {
+		_vm->_events->pollEvents();
+		g_system->delayMillis(10);
+		if ((waitType == WAIT_KBD_OR_FINISH) && _vm->_events->kbHit()) {
+			retval = false;
+			break;
+		}
+	} while (!_vm->shouldQuit() && _mixer->isSoundHandleActive(soundHandle));
+
+	_soundPlaying = false;
+	_mixer->stopHandle(soundHandle);
+
+	return retval;
+}
+
+Common::String Sound::formFilename(const Common::String &name) {
+	Common::String filename = name;
+
+	if (!filename.contains('.')) {
+		if (!IS_3DO) {
+			if (IS_SERRATED_SCALPEL) {
+				filename += ".SND";
+			} else {
+				filename += ".WAV";
+			}
+		} else {
+			// 3DO uses .aiff extension
+			filename += ".AIFF";
+			if (!filename.contains('/')) {
+				// if no directory was given, use the room sounds directory
+				filename = "rooms/sounds/" + filename;
+			}
+		}
+	}
+
+	return filename;
+}
+
+void Sound::playAiff(const Common::String &name, int volume, bool loop) {
+	Common::File *file = new Common::File();
+	if (!file->open(name)) {
+		delete file;
+		return;
+	}
+	Audio::AudioStream *stream;
+	Audio::RewindableAudioStream *audioStream = Audio::makeAIFFStream(file, DisposeAfterUse::YES);
+	if (loop) {
+		Audio::AudioStream *loopingStream = Audio::makeLoopingAudioStream(audioStream, 0);
+		stream = loopingStream;
+	} else {
+		stream = audioStream;
+	}
+	stopAiff();
+	_mixer->playStream(Audio::Mixer::kSFXSoundType, &_aiffHandle, stream, -1, volume);
+}
+
+void Sound::stopAiff() {
+	if (_mixer->isSoundHandleActive(_aiffHandle)) {
+		_mixer->stopHandle(_aiffHandle);
+	}
+}
+
+void Sound::playLoadedSound(int bufNum, WaitType waitType) {
+	if (IS_SERRATED_SCALPEL) {
+		if (_mixer->isSoundHandleActive(_scalpelEffectsHandle) && (_curPriority > _vm->_scene->_sounds[bufNum]._priority))
+			return;
+
+		stopSound();
+	}
+
+	playSound(_vm->_scene->_sounds[bufNum]._name, waitType, _vm->_scene->_sounds[bufNum]._priority);
+}
+
+void Sound::freeLoadedSounds() {
+	// As sounds are played with DisposeAfterUse::YES, stopping the sounds also
+	// frees them
+	stopSound();
+}
+
+void Sound::stopSound() {
+	if (IS_SERRATED_SCALPEL) {
+		_mixer->stopHandle(_scalpelEffectsHandle);
+	} else {
+		for (int i = 0; i < MAX_MIXER_CHANNELS; i++)
+			_mixer->stopHandle(_tattooEffectsHandle[i]);
+	}
+}
+
+void Sound::freeDigiSound() {
+	_soundPlaying = false;
+}
+
+Audio::SoundHandle &Sound::getFreeSoundHandle() {
+	for (int i = 0; i < MAX_MIXER_CHANNELS; i++) {
+		if (!_mixer->isSoundHandleActive(_tattooEffectsHandle[i]))
+			return _tattooEffectsHandle[i];
+	}
+
+	error("getFreeSoundHandle: No sound handle found");
+}
+
+void Sound::setVolume(int volume) {
+	warning("TODO: setVolume - %d", volume);
+}
+
+void Sound::playSpeech(const Common::String &name) {
+	Resources &res = *_vm->_res;
+	Scene &scene = *_vm->_scene;
+
+	// Stop any previously playing speech
+	stopSpeech();
+
+	if (IS_SERRATED_SCALPEL) {
+		Common::String filename = formFilename(name);
+		if (playSoundResource(filename, Common::String(), Audio::Mixer::kSFXSoundType, _speechHandle))
+			_speechPlaying = true;
+	} else {
+		// Figure out which speech library to use
+		Common::String libraryName = Common::String::format("speech%02d.lib", scene._currentScene);
+		if ((!scumm_strnicmp(name.c_str(), "SLVE12S", 7)) || (!scumm_strnicmp(name.c_str(), "WATS12X", 7))
+				|| (!scumm_strnicmp(name.c_str(), "HOLM12X", 7)))
+			libraryName = "SPEECH12.LIB";
+
+		// If the speech library file doesn't even exist, then we can't play anything
+		Common::File f;
+		if (!f.exists(libraryName))
+			return;
+
+		// Ensure the given library is in the cache
+		res.addToCache(libraryName);
+
+		if (playSoundResource(name, libraryName, Audio::Mixer::kSpeechSoundType, _speechHandle))
+			_speechPlaying = true;
+	}
+}
+
+void Sound::stopSpeech() {
+	_mixer->stopHandle(_speechHandle);
+	_speechPlaying = false;
+}
+
+bool Sound::isSpeechPlaying() {
+	_speechPlaying = _mixer->isSoundHandleActive(_speechHandle);
+	return _speechPlaying;
+}
+
+bool Sound::playSoundResource(const Common::String &name, const Common::String &libFilename,
+		Audio::Mixer::SoundType soundType, Audio::SoundHandle &handle) {
+	Resources &res = *_vm->_res;
+	Common::SeekableReadStream *stream = libFilename.empty() ? res.load(name) : res.load(name, libFilename, true);
+	if (!stream)
+		return false;
+
+	Audio::AudioStream *audioStream;
+	if (IS_ROSE_TATTOO && soundType == Audio::Mixer::kSpeechSoundType) {
+		audioStream = Audio::makeRawStream(stream, 11025, Audio::FLAG_UNSIGNED);
+	} else if (IS_3DO) {
+		// 3DO: AIFF file
+		audioStream = Audio::makeAIFFStream(stream, DisposeAfterUse::YES);
+	} else if (IS_SERRATED_SCALPEL) {
+		stream->skip(2);
+		int size = stream->readUint32BE();
+		int rate = stream->readUint16BE();
+		byte *data = (byte *)malloc(size);
+		byte *ptr = data;
+		stream->read(ptr, size);
+		delete stream;
+
+		assert(size > 2);
+
+		byte *decoded = (byte *)malloc((size - 1) * 2);
+
+		// Holmes uses Creative ADPCM 4-bit data
+		int counter = 0;
+		byte reference = ptr[0];
+		int16 scale = 0;
+
+		for (int i = 1; i < size; i++) {
+			decoded[counter++] = decodeSample((ptr[i] >> 4) & 0x0f, reference, scale);
+			decoded[counter++] = decodeSample((ptr[i] >> 0) & 0x0f, reference, scale);
+		}
+
+		free(data);
+
+		audioStream = Audio::makeRawStream(decoded, (size - 2) * 2, rate, Audio::FLAG_UNSIGNED, DisposeAfterUse::YES);
+	} else {
+		audioStream = Audio::makeWAVStream(stream, DisposeAfterUse::YES);
+	}
+
+	if (!audioStream)
+		return false;
+
+	_mixer->playStream(soundType, &handle, audioStream, -1, Audio::Mixer::kMaxChannelVolume);
+	return true;
+}
+
+} // End of namespace Sherlock
+
diff --git a/engines/sherlock/sound.h b/engines/sherlock/sound.h
new file mode 100644
index 0000000000..0a0ff83d1f
--- /dev/null
+++ b/engines/sherlock/sound.h
@@ -0,0 +1,153 @@
+/* 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 SHERLOCK_SOUND_H
+#define SHERLOCK_SOUND_H
+
+#include "common/scummsys.h"
+#include "common/str.h"
+#include "audio/audiostream.h"
+#include "audio/mixer.h"
+#include "access/files.h"
+#include "audio/midiplayer.h"
+#include "audio/midiparser.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+enum WaitType {
+	WAIT_RETURN_IMMEDIATELY = 0, WAIT_FINISH = 1, WAIT_KBD_OR_FINISH = 2
+};
+
+#define MAX_MIXER_CHANNELS 10
+
+class Sound {
+private:
+	SherlockEngine *_vm;
+	Audio::Mixer *_mixer;
+	Audio::SoundHandle _scalpelEffectsHandle;
+	Audio::SoundHandle _aiffHandle;
+	Audio::SoundHandle _tattooEffectsHandle[MAX_MIXER_CHANNELS];
+	Audio::SoundHandle _speechHandle;
+	int _curPriority;
+
+	/**
+	 * Decode a sound sample
+	 */
+	byte decodeSample(byte sample, byte& reference, int16& scale);
+
+	/**
+	 * Handle playing a sound or speech
+	 */
+	bool playSoundResource(const Common::String &name, const Common::String &libFilename,
+		Audio::Mixer::SoundType soundType, Audio::SoundHandle &handle);
+
+	/**
+	 * Form a filename from a passed sound resource name
+	 */
+	Common::String formFilename(const Common::String &name);
+public:
+	bool _digitized;
+	int _voices;
+	bool _soundOn;
+	bool _speechOn;
+	bool _soundPlaying;
+	bool _speechPlaying;
+	int _soundVolume;
+
+	Common::String _talkSoundFile;
+public:
+	Sound(SherlockEngine *vm, Audio::Mixer *mixer);
+
+	/**
+	 * Saves sound-related settings
+	 */
+	void syncSoundSettings();
+
+	/**
+	 * Load a sound
+	 */
+	void loadSound(const Common::String &name, int priority);
+	
+	/**
+	 * Play the sound in the specified resource
+	 */
+	bool playSound(const Common::String &name, WaitType waitType, int priority = 100, const char *libraryFilename = nullptr);
+
+	/**
+	 * Play the specified AIFF file. (Used for the 3DO Scalpel intro.)
+	 */
+	void playAiff(const Common::String &name, int volume = Audio::Mixer::kMaxChannelVolume, bool loop = false);
+
+	/**
+	 * Stop the AIFF sound that was started with playAiff().
+	 */
+	void stopAiff();
+	
+	/**
+	 * Play a previously loaded sound
+	 */
+	void playLoadedSound(int bufNum, WaitType waitType);
+	
+	/**
+	 * Free any previously loaded sounds
+	 */
+	void freeLoadedSounds();
+	
+	/**
+	 * Stop playing any active sound
+	 */
+	void stopSound();
+
+	void freeDigiSound();
+
+	/**
+	 * Return a sound handle to use
+	 */
+	Audio::SoundHandle &getFreeSoundHandle();
+
+	/**
+	 * Set the volume
+	 */
+	void setVolume(int volume);
+
+	/**
+	 * Play a specified voice resource
+	 */
+	void playSpeech(const Common::String &name);
+
+	/**
+	 * Stop any currently playing speech
+	 */
+	void stopSpeech();
+
+	/**
+	 * Returns true if speech is currently playing
+	 */
+	bool isSpeechPlaying();
+};
+
+} // End of namespace Sherlock
+
+#endif
+
diff --git a/engines/sherlock/surface.cpp b/engines/sherlock/surface.cpp
new file mode 100644
index 0000000000..b7fc76325c
--- /dev/null
+++ b/engines/sherlock/surface.cpp
@@ -0,0 +1,281 @@
+/* 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 "sherlock/surface.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/resources.h"
+#include "common/system.h"
+#include "graphics/palette.h"
+
+namespace Sherlock {
+
+Surface::Surface(uint16 width, uint16 height) : Fonts(), _freePixels(true) {
+	create(width, height);
+}
+
+Surface::Surface() : Fonts(), _freePixels(false) {
+}
+
+Surface::~Surface() {
+	if (_freePixels)
+		_surface.free();
+}
+
+void Surface::create(uint16 width, uint16 height) {
+	if (_freePixels)
+		_surface.free();
+
+	if (_vm->getPlatform() == Common::kPlatform3DO) {
+		_surface.create(width, height, Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0));
+	} else {
+		_surface.create(width, height, Graphics::PixelFormat::createFormatCLUT8());
+	}
+	_freePixels = true;
+}
+
+Graphics::PixelFormat Surface::getPixelFormat() {
+	return _surface.format;
+}
+
+void Surface::blitFrom(const Surface &src) {
+	blitFrom(src, Common::Point(0, 0));
+}
+
+void Surface::blitFrom(const ImageFrame &src) {
+	blitFrom(src._frame, Common::Point(0, 0));
+}
+
+void Surface::blitFrom(const Graphics::Surface &src) {
+	blitFrom(src, Common::Point(0, 0));
+}
+
+void Surface::blitFrom(const Surface &src, const Common::Point &pt) {
+	blitFrom(src, pt, Common::Rect(0, 0, src._surface.w, src._surface.h));
+}
+
+void Surface::blitFrom(const ImageFrame &src, const Common::Point &pt) {
+	blitFrom(src._frame, pt, Common::Rect(0, 0, src._frame.w, src._frame.h));
+}
+
+void Surface::blitFrom(const Graphics::Surface &src, const Common::Point &pt) {
+	blitFrom(src, pt, Common::Rect(0, 0, src.w, src.h));
+}
+
+void Surface::blitFrom(const Graphics::Surface &src, const Common::Point &pt, const Common::Rect &srcBounds) {
+	Common::Rect srcRect = srcBounds;
+	Common::Rect destRect(pt.x, pt.y, pt.x + srcRect.width(), pt.y + srcRect.height());
+
+	if (srcRect.isValidRect() && clip(srcRect, destRect)) {
+		// Surface is at least partially or completely on-screen
+		addDirtyRect(destRect);
+		_surface.copyRectToSurface(src, destRect.left, destRect.top, srcRect);
+	}
+}
+
+void Surface::blitFrom(const ImageFrame &src, const Common::Point &pt, const Common::Rect &srcBounds) {
+	blitFrom(src._frame, pt, srcBounds);
+}
+
+void Surface::blitFrom(const Surface &src, const Common::Point &pt, const Common::Rect &srcBounds) {
+	blitFrom(src._surface, pt, srcBounds);
+}
+
+void Surface::transBlitFrom(const ImageFrame &src, const Common::Point &pt,
+		bool flipped, int overrideColor, int scaleVal) {
+	Common::Point drawPt(pt.x + src.sDrawXOffset(scaleVal), pt.y + src.sDrawYOffset(scaleVal));
+	transBlitFrom(src._frame, drawPt, flipped, overrideColor, scaleVal);
+}
+
+void Surface::transBlitFrom(const Surface &src, const Common::Point &pt,
+		bool flipped, int overrideColor, int scaleVal) {
+	const Graphics::Surface &s = src._surface;
+	transBlitFrom(s, pt, flipped, overrideColor, scaleVal);
+}
+
+void Surface::transBlitFrom(const Graphics::Surface &src, const Common::Point &pt,
+		bool flipped, int overrideColor, int scaleVal) {
+	if (scaleVal == SCALE_THRESHOLD) {
+		transBlitFromUnscaled(src, pt, flipped, overrideColor);
+		return;
+	}
+
+	int destWidth = src.w * SCALE_THRESHOLD / scaleVal;
+	int destHeight = src.h * SCALE_THRESHOLD / scaleVal;
+
+	// Loop through drawing output lines
+	for (int destY = pt.y, scaleYCtr = 0; destY < (pt.y + destHeight); ++destY, scaleYCtr += scaleVal) {
+		if (destY < 0 || destY >= this->h())
+			continue;
+		const byte *srcLine = (const byte *)src.getBasePtr(0, scaleYCtr / SCALE_THRESHOLD);
+		byte *destLine = (byte *)getBasePtr(pt.x, destY);
+
+		// Loop through drawing individual rows
+		for (int xCtr = 0, scaleXCtr = 0; xCtr < destWidth; ++xCtr, scaleXCtr += scaleVal) {
+			int destX = pt.x + xCtr;
+			if (destX < 0 || destX >= this->w())
+				continue;
+
+			byte srcVal = srcLine[flipped ? src.w - scaleXCtr / SCALE_THRESHOLD - 1 : scaleXCtr / SCALE_THRESHOLD];
+			if (srcVal != TRANSPARENCY)
+				destLine[xCtr] = srcVal;
+		}
+	}
+
+	// Mark the affected area
+	addDirtyRect(Common::Rect(pt.x, pt.y, pt.x + destWidth, pt.y + destHeight));
+}
+
+void Surface::transBlitFromUnscaled(const Graphics::Surface &src, const Common::Point &pt,
+		bool flipped, int overrideColor) {
+	Common::Rect drawRect(0, 0, src.w, src.h);
+	Common::Rect destRect(pt.x, pt.y, pt.x + src.w, pt.y + src.h);
+
+	// Clip the display area to on-screen
+	if (!clip(drawRect, destRect))
+		// It's completely off-screen
+		return;
+
+	if (flipped)
+		drawRect = Common::Rect(src.w - drawRect.right, drawRect.top,
+			src.w - drawRect.left, drawRect.bottom);
+
+	Common::Point destPt(destRect.left, destRect.top);
+	addDirtyRect(Common::Rect(destPt.x, destPt.y, destPt.x + drawRect.width(),
+		destPt.y + drawRect.height()));
+
+	switch (src.format.bytesPerPixel) {
+	case 1:
+		// 8-bit palettized: Draw loop
+		assert(_surface.format.bytesPerPixel == 1); // Security check
+		for (int yp = 0; yp < drawRect.height(); ++yp) {
+			const byte *srcP = (const byte *)src.getBasePtr(
+				flipped ? drawRect.right - 1 : drawRect.left, drawRect.top + yp);
+			byte *destP = (byte *)getBasePtr(destPt.x, destPt.y + yp);
+
+			for (int xp = 0; xp < drawRect.width(); ++xp, ++destP) {
+				if (*srcP != TRANSPARENCY)
+					*destP = overrideColor ? overrideColor : *srcP;
+
+				srcP = flipped ? srcP - 1 : srcP + 1;
+			}
+		}
+		break;
+	case 2:
+		// 3DO 15-bit RGB565: Draw loop
+		assert(_surface.format.bytesPerPixel == 2); // Security check
+		for (int yp = 0; yp < drawRect.height(); ++yp) {
+			const uint16 *srcP = (const uint16 *)src.getBasePtr(
+				flipped ? drawRect.right - 1 : drawRect.left, drawRect.top + yp);
+			uint16 *destP = (uint16 *)getBasePtr(destPt.x, destPt.y + yp);
+
+			for (int xp = 0; xp < drawRect.width(); ++xp, ++destP) {
+				if (*srcP) // RGB 0, 0, 0 -> transparent on 3DO
+					*destP = *srcP; // overrideColor ? overrideColor : *srcP;
+
+				srcP = flipped ? srcP - 1 : srcP + 1;
+			}
+		}
+		break;
+	default:
+		error("Surface: unsupported bytesperpixel");
+		break;
+	}
+}
+
+void Surface::fillRect(int x1, int y1, int x2, int y2, uint color) {
+	fillRect(Common::Rect(x1, y1, x2, y2), color);
+}
+
+void Surface::fillRect(const Common::Rect &r, uint color) {
+	_surface.fillRect(r, color);
+	addDirtyRect(r);
+}
+
+void Surface::fill(uint color) {
+	fillRect(Common::Rect(_surface.w, _surface.h), color);
+}
+
+bool Surface::clip(Common::Rect &srcBounds, Common::Rect &destBounds) {
+	if (destBounds.left >= w() || destBounds.top >= h() ||
+			destBounds.right <= 0 || destBounds.bottom <= 0)
+		return false;
+
+	// Clip the bounds if necessary to fit on-screen
+	if (destBounds.right > w()) {
+		srcBounds.right -= destBounds.right - w();
+		destBounds.right = w();
+	}
+
+	if (destBounds.bottom > h()) {
+		srcBounds.bottom -= destBounds.bottom - h();
+		destBounds.bottom = h();
+	}
+
+	if (destBounds.top < 0) {
+		srcBounds.top += -destBounds.top;
+		destBounds.top = 0;
+	}
+
+	if (destBounds.left < 0) {
+		srcBounds.left += -destBounds.left;
+		destBounds.left = 0;
+	}
+
+	return true;
+}
+
+void Surface::clear() {
+	fillRect(Common::Rect(0, 0, w(), h()), 0);
+}
+
+void Surface::free() {
+	if (_freePixels) {
+		_surface.free();
+		_freePixels = false;
+	}
+}
+
+void Surface::setPixels(byte *pixels, int width, int height, Graphics::PixelFormat pixelFormat) {
+	_surface.format = pixelFormat;
+	_surface.w = width;
+	_surface.h = height;
+	_surface.pitch = width * pixelFormat.bytesPerPixel;
+	_surface.setPixels(pixels);
+}
+
+void Surface::writeString(const Common::String &str, const Common::Point &pt, uint overrideColor) {
+	Fonts::writeString(this, str, pt, overrideColor);
+}
+
+void Surface::writeFancyString(const Common::String &str, const Common::Point &pt, uint overrideColor1, uint overrideColor2) {
+	writeString(str, Common::Point(pt.x, pt.y), overrideColor1);
+	writeString(str, Common::Point(pt.x + 1, pt.y), overrideColor1);
+	writeString(str, Common::Point(pt.x + 2, pt.y), overrideColor1);
+	writeString(str, Common::Point(pt.x, pt.y + 1), overrideColor1);
+	writeString(str, Common::Point(pt.x + 2, pt.y + 1), overrideColor1);
+	writeString(str, Common::Point(pt.x, pt.y + 2), overrideColor1);
+	writeString(str, Common::Point(pt.x + 1, pt.y + 2), overrideColor1);
+	writeString(str, Common::Point(pt.x + 2, pt.y + 2), overrideColor1);
+	writeString(str, Common::Point(pt.x + 1, pt.y + 1), overrideColor2);
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/surface.h b/engines/sherlock/surface.h
new file mode 100644
index 0000000000..378c9be9cd
--- /dev/null
+++ b/engines/sherlock/surface.h
@@ -0,0 +1,186 @@
+/* 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 SHERLOCK_GRAPHICS_H
+#define SHERLOCK_GRAPHICS_H
+
+#include "common/rect.h"
+#include "common/platform.h"
+#include "graphics/surface.h"
+#include "sherlock/fonts.h"
+
+namespace Sherlock {
+
+#define SCALE_THRESHOLD 0x100
+#define TRANSPARENCY 255
+
+struct ImageFrame;
+
+class Surface: public Fonts {
+private:
+	bool _freePixels;
+
+	/**
+	 * Copy a surface into this one
+	 */
+	void blitFrom(const Graphics::Surface &src);
+protected:
+	Graphics::Surface _surface;
+
+	/**
+	 * Clips the given source bounds so the passed destBounds will be entirely on-screen
+	 */
+	bool clip(Common::Rect &srcBounds, Common::Rect &destBounds);
+
+	/**
+	 * Base method stub for signalling dirty rect areas
+	 */
+	virtual void addDirtyRect(const Common::Rect &r) {}
+
+	/**
+	 * Draws a sub-section of a surface at a given position within this surface
+	 */
+	virtual void blitFrom(const Graphics::Surface &src, const Common::Point &pt, const Common::Rect &srcBounds);
+
+	/**
+	 * Draws a surface at a given position within this surface with transparency
+	 */
+	virtual void transBlitFromUnscaled(const Graphics::Surface &src, const Common::Point &pt, bool flipped, 
+		int overrideColor);
+public:
+	Surface(uint16 width, uint16 height);
+	Surface();
+	virtual ~Surface();
+
+	/**
+	 * Sets up an internal surface with the specified dimensions that will be automatically freed
+	 * when the surface object is destroyed
+	 */
+	void create(uint16 width, uint16 height);
+
+	Graphics::PixelFormat getPixelFormat();
+
+	/**
+	 * Copy a surface into this one
+	 */
+	void blitFrom(const Surface &src);
+
+	/**
+	 * Copy an image frame into this surface
+	 */
+	void blitFrom(const ImageFrame &src);
+
+	/**
+	 * Draws a surface at a given position within this surface
+	 */
+	void blitFrom(const Surface &src, const Common::Point &pt);
+
+	/**
+	 * Copy an image frame onto this surface at a given position
+	 */
+	void blitFrom(const ImageFrame &src, const Common::Point &pt);
+
+	/**
+	 * Draws a sub-section of a surface at a given position within this surface
+	 */
+	void blitFrom(const Surface &src, const Common::Point &pt, const Common::Rect &srcBounds);
+
+	/**
+	 * Copy a sub-area of a source image frame into this surface at a given position
+	 */
+	void blitFrom(const ImageFrame &src, const Common::Point &pt, const Common::Rect &srcBounds);
+
+	/**
+	 * Draws a surface at a given position within this surface
+	 */
+	void blitFrom(const Graphics::Surface &src, const Common::Point &pt);
+
+	/**
+	 * Draws an image frame at a given position within this surface with transparency
+	 */
+	void transBlitFrom(const ImageFrame &src, const Common::Point &pt,
+		bool flipped = false, int overrideColor = 0, int scaleVal = 256);
+	
+	/**
+	* Draws a surface at a given position within this surface with transparency
+	*/
+	void transBlitFrom(const Surface &src, const Common::Point &pt,
+		bool flipped = false, int overrideColor = 0, int scaleVal = 256);
+
+	/**
+	 * Draws a surface at a given position within this surface with transparency
+	 */
+	void transBlitFrom(const Graphics::Surface &src, const Common::Point &pt,
+		bool flipped = false, int overrideColor = 0, int scaleVal = 256);
+
+	/**
+	 * Fill a given area of the surface with a given color
+	 */
+	void fillRect(int x1, int y1, int x2, int y2, uint color);
+	
+	/**
+	 * Fill a given area of the surface with a given color
+	 */
+	virtual void fillRect(const Common::Rect &r, uint color);
+
+	void fill(uint color);
+
+	/**
+	 * Clear the surface
+	 */
+	void clear();
+
+	/**
+	 * Free the underlying surface
+	 */
+	void free();
+
+	/**
+	 * Returns true if the surface is empty
+	 */
+	bool empty() const { return _surface.getPixels() == nullptr; }
+
+	/**
+	 * Set the pixels for the surface to an existing data block
+	 */
+	void setPixels(byte *pixels, int width, int height, Graphics::PixelFormat format);
+
+	/**
+	 * Draws the given string into the back buffer using the images stored in _font
+	 */
+	virtual void writeString(const Common::String &str, const Common::Point &pt, uint overrideColor);
+	void writeFancyString(const Common::String &str, const Common::Point &pt, uint overrideColor1, uint overrideColor2);
+
+	inline virtual uint16 w() const { return _surface.w; }
+	inline virtual uint16 h() const { return _surface.h; }
+	inline const byte *getPixels() const { return (const byte *)_surface.getPixels(); }
+	inline byte *getPixels() { return (byte *)_surface.getPixels(); }
+	inline byte *getBasePtr(int x, int y) { return (byte *)_surface.getBasePtr(x, y); }
+	inline const byte *getBasePtr(int x, int y) const { return (const byte *)_surface.getBasePtr(x, y); }
+	inline Graphics::Surface &getRawSurface() { return _surface; }
+	inline void hLine(int x, int y, int x2, uint color) { _surface.hLine(x, y, x2, color); }
+	inline void vLine(int x, int y, int y2, uint color) { _surface.vLine(x, y, y2, color); }
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/talk.cpp b/engines/sherlock/talk.cpp
new file mode 100644
index 0000000000..e9c52276f6
--- /dev/null
+++ b/engines/sherlock/talk.cpp
@@ -0,0 +1,1207 @@
+/* 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 "sherlock/talk.h"
+#include "sherlock/sherlock.h"
+#include "sherlock/screen.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/scalpel/scalpel_people.h"
+#include "sherlock/scalpel/scalpel_talk.h"
+#include "sherlock/scalpel/scalpel_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/tattoo/tattoo_people.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_talk.h"
+
+namespace Sherlock {
+
+SequenceEntry::SequenceEntry() {
+	_objNum = 0;
+	_obj = nullptr;
+	_seqStack = 0;
+	_seqTo = 0;
+	_sequenceNumber = _frameNumber = 0;
+	_seqCounter = _seqCounter2 = 0;
+}
+
+/*----------------------------------------------------------------*/
+
+void Statement::load(Common::SeekableReadStream &s, bool isRoseTattoo) {
+	int length;
+
+	length = s.readUint16LE();
+	for (int idx = 0; idx < length - 1; ++idx)
+		_statement += (char)s.readByte();
+	s.readByte();	// Null ending
+
+	length = s.readUint16LE();
+	for (int idx = 0; idx < length - 1; ++idx)
+		_reply += (char)s.readByte();
+	s.readByte();	// Null ending
+
+	length = s.readUint16LE();
+	for (int idx = 0; idx < length - 1; ++idx)
+		_linkFile += (char)s.readByte();
+	s.readByte();	// Null ending
+
+	length = s.readUint16LE();
+	for (int idx = 0; idx < length - 1; ++idx)
+		_voiceFile += (char)s.readByte();
+	s.readByte();	// Null ending
+
+	_required.resize(s.readByte());
+	_modified.resize(s.readByte());
+
+	// Read in flag required/modified data
+	for (uint idx = 0; idx < _required.size(); ++idx)
+		_required[idx] = s.readSint16LE();
+	for (uint idx = 0; idx < _modified.size(); ++idx)
+		_modified[idx] = s.readSint16LE();
+
+	_portraitSide = s.readByte();
+	_quotient = s.readUint16LE();
+	_journal = isRoseTattoo ? s.readByte() : 0;
+}
+
+/*----------------------------------------------------------------*/
+
+TalkHistoryEntry::TalkHistoryEntry() {
+	Common::fill(&_data[0], &_data[16], false);
+}
+
+/*----------------------------------------------------------------*/
+
+Talk *Talk::init(SherlockEngine *vm) {
+	if (vm->getGameID() == GType_SerratedScalpel)
+		return new Scalpel::ScalpelTalk(vm);
+	else
+		return new Tattoo::TattooTalk(vm);
+}
+
+Talk::Talk(SherlockEngine *vm) : _vm(vm) {
+	_talkCounter = 0;
+	_talkToAbort = false;
+	_openTalkWindow = false;
+	_speaker = 0;
+	_talkIndex = 0;
+	_talkTo = 0;
+	_scriptSelect = 0;
+	_converseNum = -1;
+	_talkStealth = 0;
+	_talkToFlag = -1;
+	_moreTalkDown = _moreTalkUp = false;
+	_scriptMoreFlag = 0;
+	_scriptSaveIndex = -1;
+	_opcodes = nullptr;
+	_opcodeTable = nullptr;
+	_3doSpeechIndex = -1;
+
+	_charCount = 0;
+	_line = 0;
+	_yp = 0;
+	_wait = 0;
+	_pauseFlag = false;
+	_seqCount = 0;
+	_scriptStart = _scriptEnd = nullptr;
+	_endStr = _noTextYet = false;
+
+	_talkHistory.resize(IS_ROSE_TATTOO ? 1500 : 500);
+}
+
+void Talk::talkTo(const Common::String filename) {
+	Events &events = *_vm->_events;
+	Inventory &inv = *_vm->_inventory;
+	Journal &journal = *_vm->_journal;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Sound &sound = *_vm->_sound;
+	UserInterface &ui = *_vm->_ui;
+	Common::Rect savedBounds = screen.getDisplayBounds();
+	bool abortFlag = false;
+
+	if (filename.empty())
+		// No filename passed, so exit
+		return;
+
+	// If there any canimations currently running, or a portrait is being cleared,
+	// save the filename for later executing when the canimation is done
+	bool ongoingAnim = scene._canimShapes.size() > 0;
+	if (IS_ROSE_TATTOO) {
+		ongoingAnim = static_cast<Tattoo::TattooScene *>(_vm->_scene)->_activeCAnim.active();
+	}
+	if (ongoingAnim || people._clearingThePortrait) {
+		// Make sure we're not in the middle of a script
+		if (!_scriptMoreFlag) {
+			_scriptName = filename;
+			_scriptSaveIndex = 0;
+
+			// Flag the selection, since we don't yet know which statement yet
+			_scriptSelect = 100;
+			_scriptMoreFlag = 3;
+		}
+
+		return;
+	}
+
+	// Save the ui mode temporarily and switch to talk mode
+	MenuMode savedMode = ui._menuMode;
+	ui._menuMode = TALK_MODE;
+
+	// Turn on the Exit option
+	ui._endKeyActive = true;
+
+	if (people[HOLMES]._walkCount || (!people[HOLMES]._walkTo.empty() && 
+			(IS_SERRATED_SCALPEL || people._allowWalkAbort))) {
+		// Only interrupt if trying to do an action, and not just if player is walking around the scene
+		if (people._allowWalkAbort)
+			abortFlag = true;
+
+		people[HOLMES].gotoStand();
+	}
+
+	if (_talkToAbort)
+		return;
+
+	freeTalkVars();
+
+	// If any sequences have changed in the prior talk file, restore them
+	if (_savedSequences.size() > 0) {
+		for (uint idx = 0; idx < _savedSequences.size(); ++idx) {
+			SequenceEntry &ss = _savedSequences[idx];
+			for (uint idx2 = 0; idx2 < ss._sequences.size(); ++idx2)
+				scene._bgShapes[ss._objNum]._sequences[idx2] = ss._sequences[idx2];
+
+			// Reset the object's frame to the beginning of the sequence
+			scene._bgShapes[ss._objNum]._frameNumber = 0;
+		}
+	}
+
+	if (IS_ROSE_TATTOO) {
+		pullSequence();
+	} else {
+		while (!isSequencesEmpty())
+			pullSequence();
+	}
+
+	if (IS_SERRATED_SCALPEL) {
+		// Restore any pressed button
+		if (!ui._windowOpen && savedMode != STD_MODE)
+			static_cast<Scalpel::ScalpelUserInterface *>(_vm->_ui)->restoreButton((int)(savedMode - 1));
+	} else {
+		static_cast<Tattoo::TattooPeople *>(_vm->_people)->pullNPCPaths();
+	}
+
+	// Clear the ui counter so that anything displayed on the info line
+	// before the window was opened isn't cleared
+	ui._menuCounter = 0;
+
+	// Close any previous window before starting the talk
+	if (ui._windowOpen) {
+		switch (savedMode) {
+		case LOOK_MODE:
+			events.setCursor(ARROW);
+
+			if (ui._invLookFlag) {
+				screen.resetDisplayBounds();
+				ui.drawInterface(2);
+			}
+
+			ui.banishWindow();
+			ui._windowBounds.top = CONTROLS_Y1;
+			ui._temp = ui._oldTemp = ui._lookHelp = 0;
+			ui._menuMode = STD_MODE;
+			events._pressed = events._released = events._oldButtons = 0;
+			ui._invLookFlag = false;
+			break;
+
+		case TALK_MODE:
+			if (_speaker < SPEAKER_REMOVE)
+				people.clearTalking();
+			if (_talkCounter)
+				return;
+
+			// If we were in inventory mode looking at an object, restore the
+			// back buffers before closing the window, so we get the ui restored
+			// rather than the inventory again
+			if (ui._invLookFlag) {
+				screen.resetDisplayBounds();
+				ui.drawInterface(2);
+				ui._invLookFlag = ui._lookScriptFlag = false;
+			}
+
+			ui.banishWindow();
+			ui._windowBounds.top = CONTROLS_Y1;
+			abortFlag = true;
+			break;
+
+		case INV_MODE:
+		case USE_MODE:
+		case GIVE_MODE:
+			inv.freeInv();
+			if (ui._invLookFlag) {
+				screen.resetDisplayBounds();
+				ui.drawInterface(2);
+				ui._invLookFlag = ui._lookScriptFlag = false;
+			}
+
+			ui._infoFlag = true;
+			ui.clearInfo();
+			ui.banishWindow(false);
+			ui._key = -1;
+			break;
+
+		case FILES_MODE:
+			ui.banishWindow(true);
+			ui._windowBounds.top = CONTROLS_Y1;
+			abortFlag = true;
+			break;
+
+		case SETUP_MODE:
+			ui.banishWindow(true);
+			ui._windowBounds.top = CONTROLS_Y1;
+			ui._temp = ui._oldTemp = ui._lookHelp = ui._invLookFlag = false;
+			ui._menuMode = STD_MODE;
+			events._pressed = events._released = events._oldButtons = 0;
+			abortFlag = true;
+			break;
+
+		default:
+			break;
+		}
+	}
+
+	screen.resetDisplayBounds();
+	events._pressed = events._released = false;
+	loadTalkFile(filename);
+	ui._selector = ui._oldSelector = ui._key = ui._oldKey = -1;
+
+	// Find the first statement that has the correct flags
+	int select = -1;
+	for (uint idx = 0; idx < _statements.size() && select == -1; ++idx) {
+		if (_statements[idx]._talkMap == 0)
+			select = _talkIndex = idx;
+	}
+
+	// If there's a pending automatic selection to be made, then use it
+	if (_scriptMoreFlag && _scriptSelect != 100)
+		select = _scriptSelect;
+
+	if (select == -1)
+		error("Couldn't find statement to display");
+
+	// Add the statement into the journal and talk history
+	if (_talkTo != -1 && !_talkHistory[_converseNum][select])
+		journal.record(_converseNum, select, true);
+	_talkHistory[_converseNum][select] = true;
+
+	// Check if the talk file is meant to be a non-seen comment
+	if (filename.size() < 8 || filename[7] != '*') {
+		// Should we start in stealth mode?
+		if (_statements[select]._statement.hasPrefix("^")) {
+			_talkStealth = 2;
+		} else {
+			// Not in stealth mode, so bring up the ui window
+			_talkStealth = 0;
+			++_talkToFlag;
+			events.setCursor(WAIT);
+
+			ui._windowBounds.top = CONTROLS_Y;
+			ui._infoFlag = true;
+			ui.clearInfo();
+		}
+
+		// Handle replies until there's no further linked file,
+		// or the link file isn't a reply first cnversation
+		while (!_vm->shouldQuit()) {
+			clearSequences();
+			_scriptSelect = select;
+			_speaker = _talkTo;
+
+			// Set up the talk file extension
+			if (IS_ROSE_TATTOO && sound._speechOn && _scriptMoreFlag != 1)
+				sound._talkSoundFile += Common::String::format("%02dB", select + 1);
+
+			// Make a copy of the statement (in case the script frees the statement list), and then execute it
+			Statement statement = _statements[select];
+			doScript(_statements[select]._reply);
+
+			if (IS_ROSE_TATTOO) {
+				for (int idx = 0; idx < MAX_CHARACTERS; ++idx)
+					people[idx]._misc = 0;
+			}
+
+			if (_talkToAbort)
+				return;
+
+			if (!_talkStealth)
+				ui.clearWindow();
+
+			if (statement._modified.size() > 0) {
+				for (uint idx = 0; idx < statement._modified.size(); ++idx)
+					_vm->setFlags(statement._modified[idx]);
+
+				setTalkMap();
+			}
+
+			// Check for a linked file
+			if (!statement._linkFile.empty() && !_scriptMoreFlag) {
+				Common::String linkFilename = statement._linkFile;
+				freeTalkVars();
+				loadTalkFile(linkFilename);
+
+				// Scan for the first valid statement in the newly loaded file
+				select = -1;
+				for (uint idx = 0; idx < _statements.size(); ++idx) {
+					if (_statements[idx]._talkMap == 0) {
+						select = idx;
+						break;
+					}
+				}
+
+				if (_talkToFlag == 1)
+					pullSequence();
+
+				// Set the stealth mode for the new talk file
+				Statement &newStatement = _statements[select];
+				_talkStealth = newStatement._statement.hasPrefix("^") ? 2 : 0;
+
+				// If the new conversion is a reply first, then we don't need
+				// to display any choices, since the reply needs to be shown
+				if (!newStatement._statement.hasPrefix("*") && !newStatement._statement.hasPrefix("^")) {
+					_talkIndex = select;
+					showTalk();
+
+					// Break out of loop now that we're waiting for player input
+					events.setCursor(ARROW);
+					break;
+				} else {
+					// Add the statement into the journal and talk history
+					if (_talkTo != -1 && !_talkHistory[_converseNum][select])
+						journal.record(_converseNum, select, true);
+					_talkHistory[_converseNum][select] = true;
+				}
+
+				ui._key = ui._oldKey = Scalpel::COMMANDS[TALK_MODE - 1];
+				ui._temp = ui._oldTemp = 0;
+				ui._menuMode = TALK_MODE;
+				_talkToFlag = 2;
+			} else {
+				freeTalkVars();
+
+				if (IS_SERRATED_SCALPEL) {
+					if (!ui._lookScriptFlag) {
+						ui.drawInterface(2);
+						ui._menuMode = STD_MODE;
+						ui._windowBounds.top = CONTROLS_Y1;
+					}
+				} else {
+					ui._menuMode = static_cast<Tattoo::TattooScene *>(_vm->_scene)->_labTableScene ? LAB_MODE : STD_MODE;
+				}
+
+				ui.banishWindow();
+				break;
+			}
+		}
+	}
+
+	_talkStealth = 0;
+	events._pressed = events._released = events._oldButtons = 0;
+	events.clearKeyboard();
+
+	if (savedBounds.bottom == SHERLOCK_SCREEN_HEIGHT)
+		screen.resetDisplayBounds();
+	else
+		screen.setDisplayBounds(savedBounds);
+
+	_talkToAbort = abortFlag;
+
+	// If a script was added to the script stack, restore state so that the
+	// previous script can continue
+	popStack();
+
+	events.setCursor(ARROW);
+}
+
+void Talk::initTalk(int objNum) {
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	UserInterface &ui = *_vm->_ui;
+
+	ui._windowBounds.top = CONTROLS_Y;
+	ui._infoFlag = true;
+	_speaker = SPEAKER_REMOVE;
+
+	Common::String talkFilename = (objNum >= 1000) ? people[objNum - 1000]._npcName : scene._bgShapes[objNum]._name;
+	loadTalkFile(talkFilename);
+
+	// Find the first statement with the correct flags
+	int select = -1;
+	for (uint idx = 0; idx < _statements.size(); ++idx) {
+		if (_statements[idx]._talkMap == 0) {
+			select = idx;
+			break;
+		}
+	}
+
+	if (select == -1) {
+		freeTalkVars();
+		if (!scumm_strnicmp(talkFilename.c_str(), "PATH", 4))
+			error("No entries found to execute in path file");
+
+		nothingToSay();
+		return;
+	}
+
+	// See if the statement is a stealth mode reply
+	Statement &statement = _statements[select];
+	if (statement._statement.hasPrefix("^")) {
+		clearSequences();
+
+		// Start talk in stealth mode
+		_talkStealth = 2;
+
+		talkTo(talkFilename);
+	} else if (statement._statement.hasPrefix("*")) {
+		// Character being spoken to will speak first
+		if (objNum > 1000) {
+			(*static_cast<Tattoo::TattooPeople *>(_vm->_people))[objNum - 1000].walkHolmesToNPC();
+		} else {
+			Object &obj = scene._bgShapes[objNum];
+			clearSequences();
+			pushSequence(_talkTo);
+			people.setListenSequence(_talkTo, 129);
+
+			events.setCursor(WAIT);
+			if (obj._lookPosition.y != 0)
+				// Need to walk to character first
+				people[HOLMES].walkToCoords(obj._lookPosition, obj._lookPosition._facing);
+			events.setCursor(ARROW);
+		}
+
+		if (!_talkToAbort)
+			talkTo(talkFilename);
+	} else {
+		// Holmes will be speaking first
+		_talkToFlag = false;
+
+		if (objNum > 1000) {
+			(*static_cast<Tattoo::TattooPeople *>(_vm->_people))[objNum - 1000].walkHolmesToNPC();
+		} else {
+			Object &obj = scene._bgShapes[objNum];
+			clearSequences();
+			pushSequence(_talkTo);
+			people.setListenSequence(_talkTo, 129);
+
+			events.setCursor(WAIT);
+			if (obj._lookPosition.y != 0)
+				// Walk over to person to talk to
+				people[HOLMES].walkToCoords(obj._lookPosition, obj._lookPosition._facing);
+			events.setCursor(ARROW);
+		}
+
+		if (!_talkToAbort) {
+			// See if walking over triggered a conversation
+			if (_talkToFlag) {
+				if (_talkToFlag == 1) {
+					events.setCursor(ARROW);
+					// _sequenceStack._count = 1;
+					pullSequence();
+				}
+			} else {
+				_talkIndex = select;
+				showTalk();
+
+				// Break out of loop now that we're waiting for player input
+				events.setCursor(ARROW);
+			}
+
+			_talkToFlag = -1;
+		}
+	}
+}
+
+void Talk::freeTalkVars() {
+	_statements.clear();
+}
+
+void Talk::loadTalkFile(const Common::String &filename) {
+	People &people = *_vm->_people;
+	Resources &res = *_vm->_res;
+	Sound &sound = *_vm->_sound;
+
+	// Save a copy of the talk filename
+	_scriptName = filename;
+
+	// Check for an existing person being talked to
+	_talkTo = -1;
+	for (int idx = 0; idx < (int)people._characters.size(); ++idx) {
+		if (!scumm_strnicmp(filename.c_str(), people._characters[idx]._portrait, 4)) {
+			_talkTo = idx;
+			break;
+		}
+	}
+
+	const char *chP = strchr(filename.c_str(), '.');
+	Common::String talkFile = chP ? Common::String(filename.c_str(), chP) + ".tlk" :
+		Common::String(filename.c_str(), filename.c_str() + 7) + ".tlk";
+
+	// Create the base of the sound filename used for talking in Rose Tattoo
+	if (IS_ROSE_TATTOO && _scriptMoreFlag != 1)
+		sound._talkSoundFile = Common::String(filename.c_str(), filename.c_str() + 7) + ".";
+
+	// Open the talk file for reading
+	Common::SeekableReadStream *talkStream = res.load(talkFile);
+	_converseNum = res.resourceIndex();
+	talkStream->skip(2);	// Skip talk file version num
+
+	_statements.clear();
+	_statements.resize(talkStream->readByte());
+	for (uint idx = 0; idx < _statements.size(); ++idx)
+		_statements[idx].load(*talkStream, IS_ROSE_TATTOO);
+
+	delete talkStream;
+
+	if (!sound._voices)
+		stripVoiceCommands();
+	setTalkMap();
+}
+
+void Talk::stripVoiceCommands() {
+	for (uint sIdx = 0; sIdx < _statements.size(); ++sIdx) {
+		Statement &statement = _statements[sIdx];
+
+		// Scan for an sound effect byte, which indicates to play a sound
+		for (uint idx = 0; idx < statement._reply.size(); ++idx) {
+			if (statement._reply[idx] == (char)_opcodes[OP_SFX_COMMAND]) {
+				// Replace instruction character with a space, and delete the
+				// rest of the name following it
+				statement._reply = Common::String(statement._reply.c_str(),
+					statement._reply.c_str() + idx) + " " +
+					Common::String(statement._reply.c_str() + idx + 9);
+			}
+		}
+
+		// Ensure the last character of the reply is not a space from the prior
+		// conversion loop, to avoid any issues with the space ever causing a page
+		// wrap, and ending up displaying another empty page
+		while (statement._reply.lastChar() == ' ')
+			statement._reply.deleteLastChar();
+	}
+}
+
+void Talk::setTalkMap() {
+	int statementNum = 0;
+
+	for (uint sIdx = 0; sIdx < _statements.size(); ++sIdx) {
+		Statement &statement = _statements[sIdx];
+
+		// Set up talk map entry for the statement
+		bool valid = true;
+		for (uint idx = 0; idx < statement._required.size(); ++idx) {
+			if (!_vm->readFlags(statement._required[idx]))
+				valid = false;
+		}
+
+		statement._talkMap = valid ? statementNum++ : -1;
+	}
+}
+
+void Talk::pushSequence(int speaker) {
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+
+	// Only proceed if a speaker is specified
+	if (speaker != -1) {
+		int objNum = people.findSpeaker(speaker);
+		if (objNum != -1)
+			pushSequenceEntry(&scene._bgShapes[objNum]);
+	}
+}
+
+void Talk::doScript(const Common::String &script) {
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	UserInterface &ui = *_vm->_ui;
+
+	_savedSequences.clear();
+
+	_scriptStart = (const byte *)script.c_str();
+	_scriptEnd = _scriptStart + script.size();
+	const byte *str = _scriptStart;
+	_charCount = 0;
+	_line = 0;
+	_wait = 0;
+	_pauseFlag = false;
+	_seqCount = 0;
+	_noTextYet = true;
+	_endStr = false;
+	_openTalkWindow = false;
+
+	if (IS_SERRATED_SCALPEL)
+		_yp = CONTROLS_Y + 12;
+	else
+		_yp = (_talkTo == -1) ? 5 : screen.fontHeight() + 11;
+
+	if (IS_ROSE_TATTOO) {
+		for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+			Tattoo::TattooPerson &p = (*(Tattoo::TattooPeople *)_vm->_people)[idx];
+			p._savedNpcSequence = p._sequenceNumber;
+			p._savedNpcFrame = p._frameNumber;
+			p._resetNPCPath = true;
+		}
+	}
+
+	if (_scriptMoreFlag) {
+		_scriptMoreFlag = 0;
+		str = _scriptStart + _scriptSaveIndex;
+	}
+
+	// Check if the script begins with a Stealh Mode Active command
+	if (str[0] == _opcodes[OP_STEALTH_MODE_ACTIVE] || _talkStealth) {
+		_talkStealth = 2;
+		_speaker |= SPEAKER_REMOVE;
+	} else {
+		if (IS_SERRATED_SCALPEL)
+			pushSequence(_speaker);
+		if (IS_SERRATED_SCALPEL || ui._windowOpen)
+			ui.clearWindow();
+
+		// Need to switch speakers?
+		if (str[0] == _opcodes[OP_SWITCH_SPEAKER]) {
+			_speaker = str[1] - 1;
+
+			if (IS_SERRATED_SCALPEL) {
+				str += 2;
+				pullSequence();
+				pushSequence(_speaker);
+			} else {
+				str += 3;
+			}
+
+			people.setTalkSequence(_speaker);
+		} else {
+			people.setTalkSequence(_speaker);
+		}
+
+		if (IS_SERRATED_SCALPEL) {
+			// Assign portrait location?
+			if (str[0] == _opcodes[OP_ASSIGN_PORTRAIT_LOCATION]) {
+				switch (str[1] & 15) {
+				case 1:
+					people._portraitSide = 20;
+					break;
+				case 2:
+					people._portraitSide = 220;
+					break;
+				case 3:
+					people._portraitSide = 120;
+					break;
+				default:
+					break;
+
+				}
+
+				if (str[1] > 15)
+					people._speakerFlip = true;
+				str += 2;
+			}
+
+			if (IS_SERRATED_SCALPEL) {
+				// Remove portrait?
+				if ( str[0] == _opcodes[OP_REMOVE_PORTRAIT]) {
+					_speaker = -1;
+				} else {
+					// Nope, so set the first speaker
+					((Scalpel::ScalpelPeople *)_vm->_people)->setTalking(_speaker);
+				}
+			}
+		}
+	}
+
+	do {
+		Common::String tempString;
+		_wait = 0;
+
+		byte c = str[0];
+		if (!c) {
+			_endStr = true;
+		} else if (c == '{') {
+			// Start of comment, so skip over it
+			while (*str++ != '}')
+				;
+		} else if (isOpcode(c)) {
+			// the original interpreter checked for c being >= 0x80
+			// and if that is the case, it tried to process it as opcode, BUT ALSO ALWAYS skipped over it
+			// This was done inside the Spanish + German interpreters of Serrated Scalpel, not the original
+			// English interpreter (reverse engineered from the binaries).
+			//
+			// This resulted in special characters not getting shown in case they occurred at the start
+			// of sentences like for example the inverted exclamation mark and the inverted question mark.
+			// For further study see fonts.cpp
+			//
+			// We create an inverted exclamation mark for the Spanish version and we show it.
+			//
+			// Us not skipping over those characters may result in an assert() happening inside fonts.cpp
+			// in case more invalid characters exist.
+			// More information see bug #6931
+			//
+
+			// Handle control code
+			switch ((this->*_opcodeTable[c - _opcodes[0]])(str)) {
+			case RET_EXIT:
+				return;
+			case RET_CONTINUE:
+				continue;
+			default:
+				break;
+			}
+
+			++str;
+		} else {
+			// Handle drawing the talk interface with the text
+			talkInterface(str);
+		}
+
+		// Open window if it wasn't already open, and text has already been printed
+		if ((_openTalkWindow && _wait) || (_openTalkWindow && str[0] >= _opcodes[0] && str[0] != _opcodes[OP_END_TEXT_WINDOW])) {
+			if (!ui._slideWindows) {
+				screen.slamRect(Common::Rect(0, CONTROLS_Y, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+			} else {
+				ui.summonWindow();
+			}
+
+			ui._windowOpen = true;
+			_openTalkWindow = false;
+		}
+
+		if (_wait)
+			// Handling pausing
+			talkWait(str);
+	} while (!_vm->shouldQuit() && !_endStr);
+
+	if (_wait != -1) {
+		for (int ssIndex = 0; ssIndex < (int)_savedSequences.size(); ++ssIndex) {
+			SequenceEntry &seq = _savedSequences[ssIndex];
+			Object &object = scene._bgShapes[seq._objNum];
+
+			for (uint idx = 0; idx < seq._sequences.size(); ++idx)
+				object._sequences[idx] = seq._sequences[idx];
+			object._frameNumber = seq._frameNumber;
+			object._seqTo = seq._seqTo;
+		}
+
+		pullSequence();
+
+		if (IS_SERRATED_SCALPEL) {
+			if (_speaker >= 0 && _speaker < SPEAKER_REMOVE)
+				people.clearTalking();
+		} else {
+			static_cast<Tattoo::TattooPeople *>(_vm->_people)->pullNPCPaths();
+		}
+	}
+}
+
+int Talk::waitForMore(int delay) {
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Sound &sound = *_vm->_sound;
+	UserInterface &ui = *_vm->_ui;
+	CursorId oldCursor = events.getCursor();
+	int key2 = 254;
+	bool playingSpeech = false;
+
+	// Unless we're in stealth mode, show the appropriate cursor
+	if (!_talkStealth) {
+		events.setCursor(ui._lookScriptFlag ? MAGNIFY : ARROW);
+	}
+
+	// Handle playing any speech associated with the text being displayed
+	switchSpeaker();
+	if (sound._speechOn && IS_ROSE_TATTOO) {
+		sound.playSpeech(sound._talkSoundFile);
+		sound._talkSoundFile.setChar(sound._talkSoundFile.lastChar() + 1, sound._talkSoundFile.size() - 1);
+	}
+	playingSpeech = sound.isSpeechPlaying();
+
+	do {
+		if (IS_SERRATED_SCALPEL && playingSpeech && !sound.isSpeechPlaying())
+			people._portrait._frameNumber = -1;
+
+		scene.doBgAnim();
+
+		// If talkTo call was done via doBgAnim, abort out of talk quietly
+		if (_talkToAbort) {
+			key2 = -1;
+			events._released = true;
+		} else {
+			// See if there's been a button press
+			events.pollEventsAndWait();
+			events.setButtonState();
+
+			if (events.kbHit()) {
+				Common::KeyState keyState = events.getKey();
+				if (keyState.keycode == Common::KEYCODE_ESCAPE) {
+					if (IS_ROSE_TATTOO && static_cast<Tattoo::TattooEngine *>(_vm)->_runningProlog) {
+						// Skip out of the introduction
+						_vm->setFlags(-76);
+						_vm->setFlags(396);
+						scene._goToScene = 1;
+					}
+					break;
+
+				} else if (Common::isPrint(keyState.ascii))
+					key2 = keyState.keycode;
+			}
+
+			if (_talkStealth) {
+				key2 = 254;
+				events._released = false;
+			}
+		}
+
+		// Count down the delay
+		if ((delay > 0 && !ui._invLookFlag && !ui._lookScriptFlag) || _talkStealth)
+			--delay;
+
+		if (playingSpeech && !sound.isSpeechPlaying())
+			delay = 0;
+	} while (!_vm->shouldQuit() && key2 == 254 && (delay || (playingSpeech && sound.isSpeechPlaying()))
+		&& !events._released && !events._rightReleased);
+
+	// If voices was set 2 to indicate a Scalpel voice file was playing, then reset it back to 1
+	if (sound._voices == 2)
+		sound._voices = 1;
+
+	if (delay > 0 && sound.isSpeechPlaying())
+		sound.stopSpeech();
+
+	// Adjust _talkStealth mode:
+	// mode 1 - It was by a pause without stealth being on before the pause, so reset back to 0
+	// mode 3 - It was set by a pause with stealth being on before the pause, to set it to active
+	// mode 0/2 (Inactive/active) No change
+	switch (_talkStealth) {
+	case 1:
+		_talkStealth = 0;
+		break;
+	case 2:
+		_talkStealth = 2;
+		break;
+	default:
+		break;
+	}
+
+
+	sound.stopSpeech();
+	events.setCursor(_talkToAbort ? ARROW : oldCursor);
+	events._pressed = events._released = false;
+
+	return key2;
+}
+
+bool Talk::isOpcode(byte checkCharacter) {
+	if ((checkCharacter < _opcodes[0]) || (checkCharacter >= (_opcodes[0] + 99)))
+		return false; // outside of range
+	if (_opcodeTable[checkCharacter - _opcodes[0]])
+		return true;
+	return false;
+}
+
+void Talk::popStack() {
+	if (!_scriptStack.empty()) {
+		ScriptStackEntry scriptEntry = _scriptStack.pop();
+		_scriptName = scriptEntry._name;
+		_scriptSaveIndex = scriptEntry._currentIndex;
+		_scriptSelect = scriptEntry._select;
+		_scriptMoreFlag = 1;
+	}
+}
+
+void Talk::synchronize(Serializer &s) {
+	for (uint idx = 0; idx < _talkHistory.size(); ++idx) {
+		TalkHistoryEntry &he = _talkHistory[idx];
+
+		for (int flag = 0; flag < 16; ++flag)
+			s.syncAsByte(he._data[flag]);
+	}
+}
+
+OpcodeReturn Talk::cmdAddItemToInventory(const byte *&str) {
+	Inventory &inv = *_vm->_inventory;
+	Common::String tempString;
+
+	++str;
+	for (int idx = 0; idx < str[0]; ++idx)
+		tempString += str[idx + 1];
+	str += str[0];
+
+	inv.putNameInInventory(tempString);
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdAdjustObjectSequence(const byte *&str) {
+	Scene &scene = *_vm->_scene;
+	Common::String tempString;
+
+	// Get the name of the object to adjust
+	++str;
+	for (int idx = 0; idx < (str[0] & 127); ++idx)
+		tempString += str[idx + 2];
+
+	// Scan for object
+	int objId = -1;
+	for (uint idx = 0; idx < scene._bgShapes.size(); ++idx) {
+		if (tempString.equalsIgnoreCase(scene._bgShapes[idx]._name))
+			objId = idx;
+	}
+	if (objId == -1)
+		error("Could not find object %s to change", tempString.c_str());
+
+	// Should the script be overwritten?
+	if (str[0] > 0x80) {
+		// Save the current sequence
+		_savedSequences.push(SequenceEntry());
+		SequenceEntry &seqEntry = _savedSequences.top();
+		seqEntry._objNum = objId;
+		seqEntry._seqTo = scene._bgShapes[objId]._seqTo;
+		for (uint idx = 0; idx < scene._bgShapes[objId]._seqSize; ++idx)
+			seqEntry._sequences.push_back(scene._bgShapes[objId]._sequences[idx]);
+	}
+
+	// Get number of bytes to change
+	_seqCount = str[1];
+	str += (str[0] & 127) + 2;
+
+	// Copy in the new sequence
+	for (int idx = 0; idx < _seqCount; ++idx, ++str)
+		scene._bgShapes[objId]._sequences[idx] = str[0] - 1;
+
+	// Reset object back to beginning of new sequence
+	scene._bgShapes[objId]._frameNumber = 0;
+
+	return RET_CONTINUE;
+}
+
+OpcodeReturn Talk::cmdBanishWindow(const byte *&str) {
+	People &people = *_vm->_people;
+	UserInterface &ui = *_vm->_ui;
+
+	if (!(_speaker & SPEAKER_REMOVE))
+		people.clearTalking();
+	pullSequence();
+
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	_speaker |= SPEAKER_REMOVE;
+	ui.banishWindow();
+	ui._menuMode = TALK_MODE;
+	_noTextYet = true;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdDisableEndKey(const byte *&str) {
+	_vm->_ui->_endKeyActive = false;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdEnableEndKey(const byte *&str) {
+	_vm->_ui->_endKeyActive = true;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdEndTextWindow(const byte *&str) {
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdHolmesOff(const byte *&str) {
+	People &people = *_vm->_people;
+	people[HOLMES]._type = REMOVE;
+	people._holmesOn = false;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdHolmesOn(const byte *&str) {
+	People &people = *_vm->_people;
+	people[HOLMES]._type = CHARACTER;
+	people._holmesOn = true;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdPause(const byte *&str) {
+	_charCount = *++str;
+	_wait = _pauseFlag = true;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdPauseWithoutControl(const byte *&str) {
+	Events &events = *_vm->_events;
+	Scene &scene = *_vm->_scene;
+	++str;
+
+	events.incWaitCounter();
+
+	for (int idx = 0; idx < (str[0] - 1); ++idx) {
+		scene.doBgAnim();
+		if (_talkToAbort)
+			return RET_EXIT;
+
+		// Check for button press
+		events.pollEvents();
+		events.setButtonState();
+	}
+
+	events.decWaitCounter();
+
+	_endStr = false;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdRemoveItemFromInventory(const byte *&str) {
+	Inventory &inv = *_vm->_inventory;
+	Common::String tempString;
+
+	++str;
+	for (int idx = 0; idx < str[0]; ++idx)
+		tempString += str[idx + 1];
+	str += str[0];
+
+	inv.deleteItemFromInventory(tempString);
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdRunCAnimation(const byte *&str) {
+	Scene &scene = *_vm->_scene;
+
+	++str;
+	scene.startCAnim((str[0] - 1) & 127, (str[0] & 0x80) ? -1 : 1);
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	// Check if next character is changing side or changing portrait
+	_wait = 0;
+	if (_charCount && (str[1] == _opcodes[OP_SWITCH_SPEAKER] ||
+			(IS_SERRATED_SCALPEL && str[1] == _opcodes[OP_ASSIGN_PORTRAIT_LOCATION])))
+		_wait = 1;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdSetFlag(const byte *&str) {
+	++str;
+	int flag1 = (str[0] - 1) * 256 + str[1] - 1 - (str[1] == 1 ? 1 : 0);
+	int flag = (flag1 & 0x3fff) * (flag1 >= 0x4000 ? -1 : 1);
+	_vm->setFlags(flag);
+	++str;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdSetObject(const byte *&str) {
+	Scene &scene = *_vm->_scene;
+	Common::String tempString;
+
+	++str;
+	for (int idx = 0; idx < (str[0] & 127); ++idx)
+		tempString += str[idx + 1];
+
+	// Set comparison state according to if we want to hide or unhide
+	bool state = (str[0] >= SPEAKER_REMOVE);
+	str += str[0] & 127;
+
+	for (uint idx = 0; idx < scene._bgShapes.size(); ++idx) {
+		Object &object = scene._bgShapes[idx];
+		if (tempString.equalsIgnoreCase(object._name)) {
+			// Only toggle the object if it's not in the desired state already
+			if ((object._type == HIDDEN && state) || (object._type != HIDDEN && !state))
+				object.toggleHidden();
+		}
+	}
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdStealthModeActivate(const byte *&str) {
+	_talkStealth = 2;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdStealthModeDeactivate(const byte *&str) {
+	Events &events = *_vm->_events;
+
+	_talkStealth = 0;
+	events.clearKeyboard();
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdToggleObject(const byte *&str) {
+	Scene &scene = *_vm->_scene;
+	Common::String tempString;
+
+	++str;
+	for (int idx = 0; idx < str[0]; ++idx)
+		tempString += str[idx + 1];
+
+	scene.toggleObject(tempString);
+	str += str[0];
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn Talk::cmdWalkToCAnimation(const byte *&str) {
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+
+	++str;
+	CAnim &animation = scene._cAnim[str[0] - 1];
+	people[HOLMES].walkToCoords(animation._goto[0], animation._goto[0]._facing);
+	
+	return _talkToAbort ? RET_EXIT : RET_SUCCESS;
+}
+
+void Talk::talkWait(const byte *&str) {
+	if (!_pauseFlag && _charCount < 160)
+		_charCount = 160;
+
+	_wait = waitForMore(_charCount);
+	if (_wait == -1)
+		_endStr = true;
+
+	// If a key was pressed to finish the window, see if further voice files should be skipped
+	if (IS_SERRATED_SCALPEL && _wait >= 0 && _wait < 254) {
+		if (str[0] == _opcodes[OP_SFX_COMMAND])
+			str += 9;
+	}
+
+	_pauseFlag = false;
+}
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/talk.h b/engines/sherlock/talk.h
new file mode 100644
index 0000000000..2c0da24d69
--- /dev/null
+++ b/engines/sherlock/talk.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 SHERLOCK_TALK_H
+#define SHERLOCK_TALK_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/rect.h"
+#include "common/stream.h"
+#include "common/stack.h"
+#include "sherlock/objects.h"
+#include "sherlock/saveload.h"
+
+namespace Sherlock {
+
+#define SPEAKER_REMOVE 0x80
+#define MAX_TALK_SEQUENCES 11
+
+enum {
+	OP_SWITCH_SPEAKER			= 0,
+	OP_RUN_CANIMATION			= 1,
+	OP_ASSIGN_PORTRAIT_LOCATION = 2,
+	OP_PAUSE					= 3,
+	OP_REMOVE_PORTRAIT			= 4,
+	OP_CLEAR_WINDOW				= 5,
+	OP_ADJUST_OBJ_SEQUENCE		= 6,
+	OP_WALK_TO_COORDS			= 7,
+	OP_PAUSE_WITHOUT_CONTROL	= 8,
+	OP_BANISH_WINDOW			= 9,
+	OP_SUMMON_WINDOW			= 10,
+	OP_SET_FLAG					= 11,
+	OP_SFX_COMMAND				= 12,
+	OP_TOGGLE_OBJECT			= 13,
+	OP_STEALTH_MODE_ACTIVE		= 14,
+	OP_IF_STATEMENT				= 15,
+	OP_ELSE_STATEMENT			= 16,
+	OP_END_IF_STATEMENT			= 17,
+	OP_STEALTH_MODE_DEACTIVATE	= 18,
+	OP_TURN_HOLMES_OFF			= 19,
+	OP_TURN_HOLMES_ON			= 20,
+	OP_GOTO_SCENE				= 21,
+	OP_PLAY_PROLOGUE			= 22,
+	OP_ADD_ITEM_TO_INVENTORY	= 23,
+	OP_SET_OBJECT				= 24,
+	OP_CALL_TALK_FILE			= 25,
+	OP_MOVE_MOUSE				= 26,
+	OP_DISPLAY_INFO_LINE		= 27,
+	OP_CLEAR_INFO_LINE			= 28,
+	OP_WALK_TO_CANIMATION		= 29,
+	OP_REMOVE_ITEM_FROM_INVENTORY = 30,
+	OP_ENABLE_END_KEY			= 31,
+	OP_DISABLE_END_KEY			= 32,
+	OP_END_TEXT_WINDOW			= 33,
+	
+	OP_MOUSE_OFF_ON				= 34,
+	OP_SET_WALK_CONTROL			= 35,
+	OP_SET_TALK_SEQUENCE		= 36,
+	OP_PLAY_SONG				= 37,
+	OP_WALK_HOLMES_AND_NPC_TO_CANIM = 38,
+	OP_SET_NPC_PATH_DEST		= 39,
+	OP_NEXT_SONG				= 40,
+	OP_SET_NPC_PATH_PAUSE		= 41,
+	OP_NEED_PASSWORD			= 42,
+	OP_SET_SCENE_ENTRY_FLAG		= 43,
+	OP_WALK_NPC_TO_CANIM		= 44,
+	OP_WALK_NPC_TO_COORDS		= 45,
+	OP_WALK_HOLMES_AND_NPC_TO_COORDS = 46,
+	OP_SET_NPC_TALK_FILE		= 47,
+	OP_TURN_NPC_OFF				= 48,
+	OP_TURN_NPC_ON				= 49,
+	OP_NPC_DESC_ON_OFF			= 50,
+	OP_NPC_PATH_PAUSE_TAKING_NOTES	= 51,
+	OP_NPC_PATH_PAUSE_LOOKING_HOLMES = 52,
+	OP_ENABLE_TALK_INTERRUPTS	= 53,
+	OP_DISABLE_TALK_INTERRUPTS	= 54,
+	OP_SET_NPC_INFO_LINE		= 55,
+	OP_SET_NPC_POSITION			= 56,
+	OP_NPC_PATH_LABEL			= 57,
+	OP_PATH_GOTO_LABEL			= 58,
+	OP_PATH_IF_FLAG_GOTO_LABEL	= 59,
+	OP_NPC_WALK_GRAPHICS		= 60,
+	OP_NPC_VERB					= 61,
+	OP_NPC_VERB_CANIM			= 62,
+	OP_NPC_VERB_SCRIPT			= 63,
+	OP_RESTORE_PEOPLE_SEQUENCE	= 64,
+	OP_NPC_VERB_TARGET			= 65,
+	OP_TURN_SOUNDS_OFF			= 66,
+	OP_NULL						= 67
+};
+
+enum OpcodeReturn { RET_EXIT = -1, RET_SUCCESS = 0, RET_CONTINUE = 1 };
+
+class SherlockEngine;
+class Talk;
+namespace Scalpel { class ScalpelUserInterface; }
+
+typedef OpcodeReturn(Talk::*OpcodeMethod)(const byte *&str);
+
+struct SequenceEntry {
+	int _objNum;
+	Common::Array<byte> _sequences;
+	Object *_obj;			// Pointer to the bgshape that these values go to
+	short _frameNumber;		// Frame number in frame sequence to draw
+	short _sequenceNumber;	// Start frame of sequences that are repeated
+	int _seqStack;			// Allows gosubs to return to calling frame
+	int _seqTo;				// Allows 1-5, 8-3 type sequences encoded 
+	int _seqCounter;		// How many times this sequence has been executed
+	int _seqCounter2;
+
+	SequenceEntry();
+};
+
+struct ScriptStackEntry {
+	Common::String _name;
+	int _currentIndex;
+	int _select;
+};
+
+struct Statement {
+	Common::String _statement;
+	Common::String _reply;
+	Common::String _linkFile;
+	Common::String _voiceFile;
+	Common::Array<int> _required;
+	Common::Array<int> _modified;
+	int _portraitSide;
+	int _quotient;
+	int _talkMap;
+	Common::Rect _talkPos;
+	int _journal;
+
+	/**
+	 * Load the data for a single statement within a talk file
+	 */
+	void load(Common::SeekableReadStream &s, bool isRoseTattoo);
+};
+
+struct TalkHistoryEntry {
+	bool _data[16];
+
+	TalkHistoryEntry();
+	bool &operator[](int index) { return _data[index]; }
+};
+
+class Talk {
+	friend class Scalpel::ScalpelUserInterface;
+private:
+	/**
+	 * Remove any voice commands from a loaded statement list
+	 */
+	void stripVoiceCommands();
+protected:
+	SherlockEngine *_vm;
+	OpcodeMethod *_opcodeTable;
+	Common::Stack<SequenceEntry> _savedSequences;
+	Common::Stack<ScriptStackEntry> _scriptStack;
+	Common::Array<TalkHistoryEntry> _talkHistory;
+	int _talkIndex;
+	int _scriptSelect;
+	int _talkStealth;
+	int _talkToFlag;
+	int _scriptSaveIndex;
+	int _3doSpeechIndex;
+
+	// These fields are used solely by doScript, but are fields because all the script opcodes are
+	// separate methods now, and need access to these fields
+	int _yp;
+	int _charCount;
+	int _line;
+	int _wait;
+	bool _pauseFlag;
+	bool _endStr, _noTextYet;
+	int _seqCount;
+	const byte *_scriptStart, *_scriptEnd;
+protected:
+	Talk(SherlockEngine *vm);
+
+	OpcodeReturn cmdAddItemToInventory(const byte *&str);
+	OpcodeReturn cmdAdjustObjectSequence(const byte *&str);
+	OpcodeReturn cmdBanishWindow(const byte *&str);
+	OpcodeReturn cmdDisableEndKey(const byte *&str);
+	OpcodeReturn cmdEnableEndKey(const byte *&str);
+	OpcodeReturn cmdEndTextWindow(const byte *&str);
+	OpcodeReturn cmdHolmesOff(const byte *&str);
+	OpcodeReturn cmdHolmesOn(const byte *&str);
+	OpcodeReturn cmdPause(const byte *&str);
+	OpcodeReturn cmdPauseWithoutControl(const byte *&str);
+	OpcodeReturn cmdRemoveItemFromInventory(const byte *&str);
+	OpcodeReturn cmdRunCAnimation(const byte *&str);
+	OpcodeReturn cmdSetFlag(const byte *&str);
+	OpcodeReturn cmdSetObject(const byte *&str);
+	OpcodeReturn cmdStealthModeActivate(const byte *&str);
+	OpcodeReturn cmdStealthModeDeactivate(const byte *&str);
+	OpcodeReturn cmdToggleObject(const byte *&str);
+	OpcodeReturn cmdWalkToCAnimation(const byte *&str);
+protected:
+	/**
+	 * Checks if a character is an opcode
+	 */
+	bool isOpcode(byte checkCharacter);
+
+	/**
+	 * Form a table of the display indexes for statements
+	 */
+	void setTalkMap();
+
+	/**
+	 * When the talk window has been displayed, waits a period of time proportional to
+	 * the amount of text that's been displayed
+	 */
+	virtual int waitForMore(int delay);
+
+	/**
+	 * Display the talk interface window
+	 */
+	virtual void talkInterface(const byte *&str) = 0;
+
+	/**
+	 * Pause when displaying a talk dialog on-screen
+	 */
+	virtual void talkWait(const byte *&str);
+
+	/**
+	 * Show the talk display
+	 */
+	virtual void showTalk() = 0;
+
+	/**
+	 * Called when a character being spoken to has no talk options to display
+	 */
+	virtual void nothingToSay() = 0;
+
+	/**
+	 * Called when the active speaker is switched
+	 */
+	virtual void switchSpeaker() {}
+public:
+	Common::Array<Statement> _statements;
+	bool _talkToAbort;
+	int _talkCounter;
+	int _talkTo;
+	int _scriptMoreFlag;
+	bool _openTalkWindow;
+	Common::String _scriptName;
+	bool _moreTalkUp, _moreTalkDown;
+	int _converseNum;
+	const byte *_opcodes;
+	int _speaker;
+public:
+	static Talk *init(SherlockEngine *vm);
+	virtual ~Talk() {}
+
+	/**
+	 * Return a given talk statement
+	 */
+	Statement &operator[](int idx) { return _statements[idx]; }
+
+	/**
+	 * Called whenever a conversation or item script needs to be run. For standard conversations,
+	 * it opens up a description window similar to how 'talk' does, but shows a 'reply' directly
+	 * instead of waiting for a statement option.
+	 * @remarks		It seems that at some point, all item scripts were set up to use this as well.
+	 *	In their case, the conversation display is simply suppressed, and control is passed on to
+	 *	doScript to implement whatever action is required.
+	 */
+	virtual void talkTo(const Common::String filename);
+
+	/**
+	 * Parses a reply for control codes and display text. The found text is printed within
+	 * the text window, handles delays, animations, and animating portraits.
+	 */
+	void doScript(const Common::String &script);
+
+	/**
+	 * Main method for handling conversations when a character to talk to has been
+	 * selected. It will make Holmes walk to the person to talk to, draws the
+	 * interface window for the conversation and passes on control to give the
+	 * player a list of options to make a selection from
+	 */
+	void initTalk(int objNum);
+
+	/**
+	 * Clear loaded talk data
+	 */
+	void freeTalkVars();
+
+	/**
+	 * Opens the talk file 'talk.tlk' and searches the index for the specified
+	 * conversation. If found, the data for that conversation is loaded
+	 */
+	virtual void loadTalkFile(const Common::String &filename);
+
+	/**
+	 * Push the sequence of a background object that's an NPC that needs to be
+	 * saved onto the sequence stack.
+	 */
+	void pushSequence(int speaker);
+	
+	/**
+	 * Push the details of a passed object onto the saved sequences stack
+	 */
+	virtual void pushSequenceEntry(Object *obj) = 0;
+
+	/**
+	 * Clears the stack of pending object sequences associated with speakers in the scene
+	 */
+	virtual void clearSequences() = 0;
+
+	/**
+	 * Pops an entry off of the script stack
+	 */
+	void popStack();
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	void synchronize(Serializer &s);
+
+	/**
+	 * Draws the interface for conversation display
+	 */
+	virtual void drawInterface() {}
+
+	/**
+	 * Display a list of statements in a window at the bottom of the screen that the
+	 * player can select from.
+	 */
+	virtual bool displayTalk(bool slamIt) { return false; }
+
+	/**
+	 * Prints a single conversation option in the interface window
+	 */
+	virtual int talkLine(int lineNum, int stateNum, byte color, int lineY, bool slamIt) { return 0; }
+	
+	/**
+	 * Pulls a background object sequence from the sequence stack and restore's the
+	 * object's sequence
+	 */
+	virtual void pullSequence(int slot = -1) = 0;
+
+	/**
+	 * Returns true if the script stack is empty
+	 */
+	virtual bool isSequencesEmpty() const = 0;
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/tattoo.cpp b/engines/sherlock/tattoo/tattoo.cpp
new file mode 100644
index 0000000000..3131df7649
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo.cpp
@@ -0,0 +1,214 @@
+/* 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/config-manager.h"
+#include "engines/util.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_resources.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/widget_base.h"
+#include "sherlock/people.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+TattooEngine::TattooEngine(OSystem *syst, const SherlockGameDescription *gameDesc) :
+		SherlockEngine(syst, gameDesc), _darts(this), _foolscapWidget(this) {
+	_runningProlog = false;
+	_fastMode = false;
+	_allowFastMode = true;
+	_transparentMenus = true;
+	_textWindowsOn = true;
+}
+
+TattooEngine::~TattooEngine() {
+}
+
+void TattooEngine::showOpening() {
+	// No implementation - opening is done using in-game scenes
+}
+
+void TattooEngine::initialize() {
+	initGraphics(640, 480, true);
+
+	// Initialize the base engine
+	SherlockEngine::initialize();
+
+	// Initialise the global flags
+	_flags.resize(3200);
+	_flags[1] = _flags[4] = _flags[76] = true;
+	_runningProlog = true;
+
+	// Add some more files to the cache
+	_res->addToCache("walk.lib");
+	
+	// Set up list of people
+	TattooFixedText &fixedText = *(TattooFixedText *)_fixedText;
+	const char *peopleNamePtr = nullptr;
+
+	for (int idx = 0; idx < TATTOO_MAX_PEOPLE; ++idx) {
+		peopleNamePtr = fixedText.getText(PEOPLE_DATA[idx].fixedTextId);
+
+		_people->_characters.push_back(PersonData(
+			peopleNamePtr,
+			PEOPLE_DATA[idx].portrait, nullptr, nullptr));
+	}
+
+	// Load the inventory
+	loadInventory();
+
+	// Starting scene
+	_scene->_goToScene = STARTING_INTRO_SCENE;
+
+	// Load an initial palette
+	loadInitialPalette();
+}
+
+void TattooEngine::startScene() {
+	TattooUserInterface &ui = *(TattooUserInterface *)_ui;
+
+	switch (_scene->_goToScene) {
+	case 7:
+	case 8:
+	case 18:
+	case 53:
+	case 68:
+		// Load overlay mask(s) for the scene
+		ui._mask = _res->load(Common::String::format("res%02d.msk", _scene->_goToScene));
+		if (_scene->_goToScene == 8)
+			ui._mask1 = _res->load("res08a.msk");
+		else if (_scene->_goToScene == 18 || _scene->_goToScene == 68)
+			ui._mask1 = _res->load("res08a.msk");
+		break;
+
+	case STARTING_INTRO_SCENE:
+		// Disable input so that the intro can't be skipped until the game's logo has been shown
+		ui._lockoutTimer = STARTUP_KEYS_DISABLED_DELAY;
+		break;
+
+	case OVERHEAD_MAP:
+	case OVERHEAD_MAP2:
+		// Show the map
+		_scene->_currentScene = OVERHEAD_MAP;
+		_scene->_goToScene = _map->show();
+
+		_people->_savedPos = Common::Point(-1, -1);
+		_people->_savedPos._facing = -1;
+		break;
+
+	case 101:
+		// Darts Board minigame
+		_darts.playDarts(GAME_CRICKET);
+		break;
+	
+	case 102:
+		// Darts Board minigame
+		_darts.playDarts(GAME_301);
+		break;
+
+	case 103:
+		// Darts Board minigame
+		_darts.playDarts(GAME_501);
+		break;
+
+	default:
+		break;
+	}
+
+	_events->setCursor(ARROW);
+}
+
+void TattooEngine::loadInitialPalette() {
+	byte palette[768];
+	Common::SeekableReadStream *stream = _res->load("room.pal");
+	stream->read(palette, PALETTE_SIZE);
+	_screen->translatePalette(palette);
+	_screen->setPalette(palette);
+
+	delete stream;
+}
+
+void TattooEngine::loadInventory() {
+	Inventory &inv = *_inventory;
+
+	Common::String inv1 = _fixedText->getText(kFixedText_Inv1);
+	Common::String inv2 = _fixedText->getText(kFixedText_Inv2);
+	Common::String inv3 = _fixedText->getText(kFixedText_Inv3);
+	Common::String inv4 = _fixedText->getText(kFixedText_Inv4);
+	Common::String inv5 = _fixedText->getText(kFixedText_Inv5);
+	Common::String inv6 = _fixedText->getText(kFixedText_Inv6);
+	Common::String inv7 = _fixedText->getText(kFixedText_Inv7);
+	Common::String inv8 = _fixedText->getText(kFixedText_Inv8);
+	Common::String invDesc1 = _fixedText->getText(kFixedText_InvDesc1);
+	Common::String invDesc2 = _fixedText->getText(kFixedText_InvDesc2);
+	Common::String invDesc3 = _fixedText->getText(kFixedText_InvDesc3);
+	Common::String invDesc4 = _fixedText->getText(kFixedText_InvDesc4);
+	Common::String invDesc5 = _fixedText->getText(kFixedText_InvDesc5);
+	Common::String invDesc6 = _fixedText->getText(kFixedText_InvDesc6);
+	Common::String invDesc7 = _fixedText->getText(kFixedText_InvDesc7);
+	Common::String invDesc8 = _fixedText->getText(kFixedText_InvDesc8);
+	Common::String solve = _fixedText->getText(kFixedText_Solve);
+
+	// Initial inventory
+	inv._holdings = 5;
+	inv.push_back(InventoryItem(0, inv1, invDesc1, "_ITEM01A"));
+	inv.push_back(InventoryItem(0, inv2, invDesc2, "_ITEM02A"));
+	inv.push_back(InventoryItem(0, inv3, invDesc3, "_ITEM03A"));
+	inv.push_back(InventoryItem(0, inv4, invDesc4, "_ITEM04A"));
+	inv.push_back(InventoryItem(0, inv5, invDesc5, "_ITEM05A"));
+
+	// Hidden items
+	inv.push_back(InventoryItem(295, inv6, invDesc6, "_PAP212D", solve));
+	inv.push_back(InventoryItem(294, inv7, invDesc7, "_PAP212I"));
+	inv.push_back(InventoryItem(818, inv8, invDesc8, "_LANT02I"));
+}
+
+void TattooEngine::doFoolscapPuzzle() {
+	_foolscapWidget.show();
+}
+
+void TattooEngine::loadConfig() {
+	SherlockEngine::loadConfig();
+
+	_transparentMenus = ConfMan.getBool("transparent_windows");
+	_textWindowsOn = ConfMan.getBool("subtitles") || !_sound->_speechOn;
+}
+
+void TattooEngine::saveConfig() {
+	SherlockEngine::saveConfig();
+
+	ConfMan.setBool("transparent_windows", _transparentMenus);
+	ConfMan.setBool("subtitles", _textWindowsOn);
+	ConfMan.flushToDisk();
+}
+
+bool TattooEngine::canSaveGameStateCurrently() {
+	TattooUserInterface &ui = *(TattooUserInterface *)_ui;
+	return _canLoadSave && !ui._creditsWidget.active() && !_runningProlog;
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo.h b/engines/sherlock/tattoo/tattoo.h
new file mode 100644
index 0000000000..71872ab1b9
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo.h
@@ -0,0 +1,115 @@
+/* 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 SHERLOCK_TATTOO_H
+#define SHERLOCK_TATTOO_H
+
+#include "sherlock/sherlock.h"
+#include "sherlock/tattoo/tattoo_darts.h"
+#include "sherlock/tattoo/widget_foolscap.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+enum {
+	INV_FOREGROUND		= 167,
+	INV_BACKGROUND		= 1,
+	INFO_FOREGROUND		= 233,
+	INFO_BACKGROUND		= 239,
+	INFO_TOP			= 185,
+	INFO_MIDDLE			= 186,
+	INFO_BOTTOM			= 188,
+	MENU_BACKGROUND		= 225,
+	COMMAND_FOREGROUND	= 15,
+	COMMAND_HIGHLIGHTED	= 254,
+	COMMAND_NULL		= 193,
+	PEN_COLOR			= 248,
+	PEN_HIGHLIGHT_COLOR	= 129
+};
+
+enum {
+	FLAG_PLAYER_IS_HOLMES	= 76,
+	FLAG_ALT_MAP_MUSIC		= 525
+};
+
+class TattooEngine : public SherlockEngine {
+private:
+	Darts _darts;
+	WidgetFoolscap _foolscapWidget;
+
+	/**
+	 * Loads the initial palette for the game
+	 */
+	void loadInitialPalette();
+
+	/**
+	 * Load the initial inventory
+	 */
+	void loadInventory();
+protected:
+	/**
+	 * Initialize the engine
+	 */
+	virtual void initialize();
+
+	virtual void showOpening();
+
+	/**
+	 * Starting a scene within the game
+	 */
+	virtual void startScene();
+
+	/**
+	 * Load configuration options
+	 */
+	virtual void loadConfig();
+public:
+	bool _runningProlog;
+	bool _fastMode, _allowFastMode;
+	bool _transparentMenus;
+	bool _textWindowsOn;
+public:
+	TattooEngine(OSystem *syst, const SherlockGameDescription *gameDesc);
+	virtual ~TattooEngine();
+
+	/**
+	 * Shows the foolscap puzzle
+	 */
+	void doFoolscapPuzzle();
+
+	/**
+	 * Save the game configuration
+	 */
+	virtual void saveConfig();
+
+	/**
+	 * Returns true if the game can be saved
+	 */
+	virtual bool canSaveGameStateCurrently();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/tattoo_darts.cpp b/engines/sherlock/tattoo/tattoo_darts.cpp
new file mode 100644
index 0000000000..274d80e3e1
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_darts.cpp
@@ -0,0 +1,992 @@
+/* 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 "sherlock/tattoo/tattoo_darts.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+enum {
+	DART_COLOR_FORE	= 5,
+	PLAYER_COLOR	= 11,
+	DART_BAR_FORE	= 208
+};
+
+static const int STATUS_INFO_X = 430;
+static const int STATUS_INFO_Y = 50;
+static const int STATUS_INFO_WIDTH = 205;
+static const int STATUS_INFO_HEIGHT = 330;
+static const int STATUS2_INFO_X = 510;
+static const int STATUS2_X_ADD = STATUS2_INFO_X - STATUS_INFO_X;
+static const int DART_BAR_VX = 10;
+static const int DART_HEIGHT_Y = 121;
+static const int DART_BAR_SIZE = 150;
+static const int DARTBOARD_LEFT = 73;
+static const int DARTBOARD_TOP = 68;
+static const int DARTBOARD_WIDTH = 257;
+static const int DARTBOARD_HEIGHT = 256;
+static const int DARTBOARD_TOTALX = DARTBOARD_WIDTH * 120 / 100;
+static const int DARTBOARD_TOTALY = DARTBOARD_HEIGHT * 120 / 100;
+static const int DARTBOARD_TOTALTOP = DARTBOARD_TOP - DARTBOARD_WIDTH / 10;
+static const int DARTBOARD_TOTALLEFT = DARTBOARD_LEFT - DARTBOARD_HEIGHT / 10;
+static const int CRICKET_VALUE[7] = { 20, 19, 18, 17, 16, 15, 25 };
+
+Darts::Darts(SherlockEngine *vm) : _vm(vm) {
+	_gameType = GAME_301;
+	_hand1 = _hand2 = nullptr;
+	_dartGraphics = nullptr;
+	_dartsLeft = nullptr;
+	_dartMap = nullptr;
+	_dartBoard = nullptr;
+	Common::fill(&_cricketScore[0][0], &_cricketScore[0][7], 0);
+	Common::fill(&_cricketScore[1][0], &_cricketScore[1][7], 0);
+	_score1 = _score2 = 0;
+	_roundNum = 0;
+	_roundScore = 0;
+	_level = 0;
+	_oldDartButtons = false;
+	_handX = 0;
+	_compPlay = 1;
+	_escapePressed = false;
+}
+
+void Darts::playDarts(GameType gameType) {
+	Events &events = *_vm->_events;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	int oldFontType = screen.fontNumber();
+	int playerNum = 0;
+	int lastDart;
+	int numHits = 0;
+	bool gameOver = false;
+	bool done = false;
+	const char *const NUM_HITS_STR[3] = { "a", FIXED(Double), FIXED(Triple) };
+
+	screen.setFont(7);
+	_spacing = screen.fontHeight() + 2;
+
+	// Load dart graphics and initialize values
+	loadDarts();
+	initDarts();
+	events.hideCursor();
+
+	while (!done && !_vm->shouldQuit()) {
+		int roundStart, score;
+		roundStart = score = (playerNum == 0) ? _score1 : _score2;
+
+		showNames(playerNum);
+		showStatus(playerNum);
+		_roundScore = 0;
+
+		for (int idx = 0; idx < 3 && !_vm->shouldQuit(); ++idx) {
+			if (_compPlay == 1)
+				lastDart = throwDart(idx + 1, playerNum * 2);  /* Throw one dart */
+			else
+				if (_compPlay == 2)
+					lastDart = throwDart(idx + 1, playerNum + 1);  /* Throw one dart */
+				else
+					lastDart = throwDart(idx + 1, 0);    /* Throw one dart */
+
+			if (_gameType == GAME_301) {
+				score -= lastDart;
+				_roundScore += lastDart;
+			} else {
+				numHits = lastDart >> 16;
+				if (numHits == 0)
+					numHits = 1;
+				if (numHits > 3)
+					numHits = 3;
+				
+				lastDart = lastDart & 0xffff;
+				updateCricketScore(playerNum, lastDart, numHits);
+				score = (playerNum == 0) ? _score1 : _score2;
+			}
+
+			// Special case for ScummVM: I'm making pressing Escape to exit out of the Darts game as a way to skip
+			// it entirely if you don't want to play all the way through it
+			if (_escapePressed) {
+				gameOver = true;
+				done = true;
+				playerNum = 0;
+			}
+				
+
+			if (_gameType == GAME_301) {
+				if (playerNum == 0)
+					_score1 = score;
+				else
+					_score2 = score;
+
+				if (score == 0)
+					// Someone won
+					gameOver = true;
+			} else {
+				// check for cricket game over
+				bool allClosed = true;
+
+				for (int y = 0; y < 7; y++) {
+					if (_cricketScore[playerNum][y] < 3)
+						allClosed = false;
+				}
+
+				if (allClosed) {
+					int nOtherScore = (playerNum == 0) ? _score2 : _score1;
+					if (score >= nOtherScore)
+						gameOver = true;
+				}
+			}
+
+			// Show scores
+			showStatus(playerNum);
+			screen._backBuffer2.blitFrom(screen._backBuffer1, Common::Point(_dartInfo.left, _dartInfo.top - 1),
+				Common::Rect(_dartInfo.left, _dartInfo.top - 1, _dartInfo.right, _dartInfo.bottom - 1));
+			screen.print(Common::Point(_dartInfo.left, _dartInfo.top), 0, "%s # %d", FIXED(Dart), idx + 1);
+
+			if (_gameType == GAME_301) {
+				if (_vm->getLanguage() == Common::FR_FRA)
+					screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing), 0,
+						"%s %s: %d", FIXED(Scored), FIXED(Points), lastDart);
+				else
+					screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing), 0,
+						"%s %d %s", FIXED(Scored), lastDart, FIXED(Points));
+			} else {
+				if (lastDart != 25)
+					screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing), 0, 
+						"%s %s %d", FIXED(Hit), NUM_HITS_STR[numHits - 1], lastDart);
+				else
+					screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing), 0,
+						"%s %s %s", FIXED(Hit), NUM_HITS_STR[numHits - 1], FIXED(Bullseye));
+			}
+
+			if (score != 0 && playerNum == 0 && !gameOver)
+				screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing * 3), 0, 
+					"%s", FIXED(PressAKey));
+
+			if (gameOver) {
+				screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing * 3),
+					0, "%s", FIXED(GameOver));
+				if (playerNum == 0) {
+					screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing * 4), 0,
+						"%s %s", FIXED(Holmes), FIXED(Wins));
+					_vm->setFlagsDirect(531);
+				} else {
+					screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing * 4), 0,
+						"%s %s!", _opponent.c_str(), FIXED(Wins));
+					_vm->setFlagsDirect(530);
+				}
+
+				screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing * 5), 0,
+					"%s", FIXED(PressAKey));
+
+				done = true;
+				idx = 10;
+			} else if (_gameType == GAME_301 && score < 0) {
+				screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing * 2), 0,
+					"%s!", FIXED(Busted));
+
+				// End turn
+				idx = 10;
+				score = roundStart;
+				if (playerNum == 0)
+					_score1 = score;
+				else
+					_score2 = score;
+			}
+
+			// Clear keyboard events
+			events.clearEvents();
+
+			if ((playerNum == 0 && _compPlay == 1) || _compPlay == 0 || done) {
+				if (_escapePressed) {
+					done = true;
+					break;
+				}
+			} else {
+				events.wait(20);
+			}
+
+			screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(_dartInfo.left, _dartInfo.top - 1),
+				Common::Rect(_dartInfo.left, _dartInfo.top - 1, _dartInfo.right, _dartInfo.bottom - 1));
+			screen.blitFrom(screen._backBuffer1);
+		}
+
+		playerNum ^= 1;
+		if (!playerNum)
+			++_roundNum;
+
+		if (!done) {
+			screen._backBuffer2.blitFrom((*_dartBoard)[0], Common::Point(0, 0));
+			screen._backBuffer1.blitFrom(screen._backBuffer2);
+			screen.blitFrom(screen._backBuffer2);
+		}
+	}
+
+	// Wait for a keypress
+	do {
+		events.pollEventsAndWait();
+		events.setButtonState();
+	} while (!_vm->shouldQuit() && !events.kbHit() && !events._pressed);
+	events.clearEvents();
+
+	closeDarts();
+	screen.fadeToBlack();
+	screen.setFont(oldFontType);
+
+	// Flag to return to the Billard's Academy scene
+	scene._goToScene = 26;
+}
+
+void Darts::initDarts() {
+	_dartInfo = Common::Rect(430, 245, 430 + 205, 245 + 150);
+	_escapePressed = false;
+
+	if (_gameType == GAME_CRICKET) {
+		_dartInfo = Common::Rect(430, 245, 430 + 205, 245 + 150);
+	}
+
+	Common::fill(&_cricketScore[0][0], &_cricketScore[0][7], 0);
+	Common::fill(&_cricketScore[1][0], &_cricketScore[1][7], 0);
+
+	switch (_gameType) {
+	case GAME_501:
+		_score1 = _score2 = 501;
+		_gameType = GAME_301;
+		break;
+
+	case GAME_301:
+		_score1 = _score2 = 301;
+		break;
+
+	default:
+		// Cricket
+		_score1 = _score2 = 0;
+		break;
+	}
+
+	_roundNum = 1;
+
+	if (_level == 9) {
+		// No computer players
+		_compPlay = 0;
+		_level = 0;
+	} else if (_level == 8) {
+		_level = _vm->getRandomNumber(3);
+		_compPlay = 2;
+	} else {
+		// Check for opponent flags
+		for (int idx = 0; idx < 4; ++idx) {
+			if (_vm->readFlags(314 + idx))
+				_level = idx;
+		}
+	}
+
+	_opponent = FIXED(Jock);
+}
+
+void Darts::loadDarts() {
+	Resources &res = *_vm->_res;
+	Screen &screen = *_vm->_screen;
+	byte palette[PALETTE_SIZE];
+
+	// Load images
+	_hand1 = new ImageFile("hand1.vgs");
+	_hand2 = new ImageFile("hand2.vgs");
+	_dartGraphics = new ImageFile("darts.vgs");
+	_dartsLeft = new ImageFile("DartsLft.vgs");
+	_dartMap = new ImageFile("DartMap.vgs");
+	_dartBoard = new ImageFile("DartBd.vgs");
+
+	// Load and set the palette
+	Common::SeekableReadStream *stream = res.load("DartBd.pal");
+	stream->read(palette, PALETTE_SIZE);
+	screen.translatePalette(palette);
+	screen.setPalette(palette);
+	delete stream;
+
+	// Load the initial background
+	screen._backBuffer1.blitFrom((*_dartBoard)[0], Common::Point(0, 0));
+	screen._backBuffer2.blitFrom(screen._backBuffer1);
+	screen.blitFrom(screen._backBuffer1);
+}
+
+void Darts::closeDarts() {
+	delete _dartBoard;
+	delete _dartsLeft;
+	delete _dartGraphics;
+	delete _dartMap;
+	delete _hand1;
+	delete _hand2;
+}
+
+void Darts::showNames(int playerNum) {
+	Screen &screen = *_vm->_screen;
+	byte color;
+
+	color = playerNum == 0 ? PLAYER_COLOR : DART_COLOR_FORE;
+	screen.print(Common::Point(STATUS_INFO_X, STATUS_INFO_Y), 0, "%s", FIXED(Holmes));
+	screen._backBuffer1.fillRect(Common::Rect(STATUS_INFO_X, STATUS_INFO_Y + _spacing + 1, 
+		STATUS_INFO_X + 50, STATUS_INFO_Y + _spacing + 3), color);
+	screen.fillRect(Common::Rect(STATUS_INFO_X, STATUS_INFO_Y + _spacing + 1,
+		STATUS_INFO_X + 50, STATUS_INFO_Y + _spacing + 3), color);
+
+	color = playerNum == 1 ? PLAYER_COLOR : DART_COLOR_FORE;
+	screen.print(Common::Point(STATUS2_INFO_X, STATUS_INFO_Y), 0, "%s", _opponent.c_str());
+	screen._backBuffer1.fillRect(Common::Rect(STATUS2_INFO_X, STATUS_INFO_Y + _spacing + 1, 
+		STATUS2_INFO_X + 50, STATUS_INFO_Y + _spacing + 3), color);
+	screen.fillRect(Common::Rect(STATUS2_INFO_X, STATUS_INFO_Y + _spacing + 1,
+		STATUS2_INFO_X + 50, STATUS_INFO_Y + _spacing + 3), color);
+
+	screen._backBuffer2.blitFrom(screen._backBuffer1);
+}
+
+void Darts::showStatus(int playerNum) {
+	Screen &screen = *_vm->_screen;
+	const char *const CRICKET_SCORE_NAME[7] = { "20", "19", "18", "17", "16", "15", FIXED(Bull) };
+
+	screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(STATUS_INFO_X, STATUS_INFO_Y + 10),
+		Common::Rect(STATUS_INFO_X, STATUS_INFO_Y + 10, STATUS_INFO_X + STATUS_INFO_WIDTH,
+		STATUS_INFO_Y + STATUS_INFO_HEIGHT - 10));
+	screen.print(Common::Point(STATUS_INFO_X + 30, STATUS_INFO_Y + _spacing + 4), 0, "%d", _score1);
+
+	screen.print(Common::Point(STATUS2_INFO_X + 30, STATUS_INFO_Y + _spacing + 4), 0, "%d", _score2);
+
+	int temp = (_gameType == GAME_CRICKET) ? STATUS_INFO_Y + 10 * _spacing + 5 : STATUS_INFO_Y + 55;
+	screen.print(Common::Point(STATUS_INFO_X, temp), 0, "%s: %d", FIXED(Round), _roundNum);
+
+	if (_gameType == GAME_301) {
+		screen.print(Common::Point(STATUS_INFO_X, STATUS_INFO_Y + 75), 0, "%s: %d", FIXED(TurnTotal), _roundScore);
+	} else {
+		// Show cricket scores
+		for (int x = 0; x < 7; ++x) {
+			screen.print(Common::Point(STATUS_INFO_X, STATUS_INFO_Y + 40 + x * _spacing), 0, "%s:", CRICKET_SCORE_NAME[x]);
+
+			for (int y = 0; y < 2; ++y) {
+				switch (CRICKET_SCORE_NAME[y][x]) {
+				case 1:
+					screen.print(Common::Point(STATUS_INFO_X + 38 + y*STATUS2_X_ADD, STATUS_INFO_Y + 40 + x * _spacing), 0, "/");
+					break;
+				case 2:
+					screen.print(Common::Point(STATUS_INFO_X + 38 + y*STATUS2_X_ADD, STATUS_INFO_Y + 40 + x * _spacing), 0, "X");
+					break;
+				case 3:
+					screen.print(Common::Point(STATUS_INFO_X + 38 + y * STATUS2_X_ADD - 1, STATUS_INFO_Y + 40 + x * _spacing), 0, "X");
+					screen.print(Common::Point(STATUS_INFO_X + 37 + y * STATUS2_X_ADD, STATUS_INFO_Y + 40 + x * _spacing), 0, "O");
+					break;
+				default:
+					break;
+				}
+			}
+		}
+	}
+
+	screen.blitFrom(screen._backBuffer1, Common::Point(STATUS_INFO_X, STATUS_INFO_Y + 10),
+		Common::Rect(STATUS_INFO_X, STATUS_INFO_Y + 10, STATUS_INFO_X + STATUS_INFO_WIDTH, 
+			STATUS_INFO_Y + STATUS_INFO_HEIGHT - 10));
+}
+
+void Darts::erasePowerBars() {
+	Screen &screen = *_vm->_screen;
+
+	// Erase the old power bars and replace them with empty ones
+	screen._backBuffer1.fillRect(Common::Rect(DART_BAR_VX, DART_HEIGHT_Y, DART_BAR_VX + 9, DART_HEIGHT_Y + DART_BAR_SIZE), 0);
+	screen._backBuffer1.transBlitFrom((*_dartGraphics)[0], Common::Point(DART_BAR_VX - 1, DART_HEIGHT_Y - 1));
+	screen.slamArea(DART_BAR_VX - 1, DART_HEIGHT_Y - 1, 10, DART_BAR_SIZE + 2);
+}
+
+bool Darts::dartHit() {
+	Events &events = *_vm->_events;
+	events.pollEvents();
+	events.setButtonState();
+
+	// Keyboard check
+	if (events.kbHit()) {
+		if (events.getKey().keycode == Common::KEYCODE_ESCAPE)
+			_escapePressed = true;
+
+		events.clearEvents();
+		return true;
+	}
+
+	bool result = events._pressed && !_oldDartButtons;
+	_oldDartButtons = events._pressed;
+	return result;
+}
+
+int Darts::doPowerBar(const Common::Point &pt, byte color, int goToPower, int orientation) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	int idx = 0;
+
+	events.clearEvents();
+	events.delay(100);
+
+	while (!_vm->shouldQuit() && idx < DART_BAR_SIZE) {
+		if ((goToPower - 1) == idx)
+			break;
+		else if (goToPower == 0) {
+			if (dartHit())
+				break;
+		}
+
+		screen._backBuffer1.hLine(pt.x, pt.y + DART_BAR_SIZE- 1 - idx, pt.x + 8, color);
+		screen._backBuffer1.transBlitFrom((*_dartGraphics)[0], Common::Point(pt.x - 1, pt.y - 1));
+		screen.slamArea(pt.x, pt.y + DART_BAR_SIZE - 1 - idx, 8, 2);
+
+		if (!(idx % 8))
+			events.wait(1);
+
+		++idx;
+	}
+
+	return MIN(idx * 100 / DART_BAR_SIZE, 100);
+}
+
+int Darts::drawHand(int goToPower, int computer) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	const int HAND_OFFSET[2] = { 72, 44 };
+	ImageFile *hands;
+	int hand;
+
+	goToPower = (goToPower * DARTBOARD_WIDTH) / 150;
+
+	if (!computer) {
+		hand = 0;
+		hands = _hand1;
+	} else {
+		hand = 1;
+		hands = _hand2;
+	}
+
+	_handSize.x = (*hands)[0]._offset.x + (*hands)[0]._width;
+	_handSize.y = (*hands)[0]._offset.y + (*hands)[0]._height;
+
+	// Clear keyboard buffer
+	events.clearEvents();
+	events.delay(100);
+
+	Common::Point pt(DARTBOARD_LEFT - HAND_OFFSET[hand], SHERLOCK_SCREEN_HEIGHT - _handSize.y);
+	int x = 0;
+
+	while (!_vm->shouldQuit() && x < DARTBOARD_WIDTH) {
+		if (computer && x >= (goToPower - 1))
+			break;
+		else if (goToPower == 0) {
+			if (dartHit())
+				break;
+		}
+
+		screen._backBuffer1.transBlitFrom((*hands)[0], pt);
+		screen.slamArea(pt.x - 1, pt.y, _handSize.x + 1, _handSize.y);
+		screen.restoreBackground(Common::Rect(pt.x, pt.y, pt.x + _handSize.x, pt.y + _handSize.y));
+
+		if (!(x % 8))
+			events.wait(1);
+
+		++x;
+		++pt.x;
+	}
+
+	_handX = pt.x - 1;
+
+	return MIN(x * 100 / DARTBOARD_WIDTH, 100);
+}
+
+Common::Point Darts::convertFromScreenToScoreCoords(const Common::Point &pt) const {
+	return Common::Point(CLIP((int)pt.x, 0, DARTBOARD_WIDTH), CLIP((int)pt.y, 0, DARTBOARD_HEIGHT));
+}
+
+int Darts::dartScore(const Common::Point &pt) {
+	Common::Point pos(pt.x - DARTBOARD_LEFT, pt.y - DARTBOARD_TOP);
+	if (pos.x < 0 || pos.y < 0)
+		return 0;
+	int score;
+
+	if (pos.x < DARTBOARD_WIDTH && pos.y < DARTBOARD_HEIGHT) {
+		pos = convertFromScreenToScoreCoords(pos);
+		score = *(const byte *)(*_dartMap)[0]._frame.getBasePtr(pos.x, pos.y);
+
+		if (_gameType == GAME_301) {
+			if (score >= 100) {
+				if (score <= 120)
+					// Hit a double
+					score = (score - 100) * 2;
+				else
+					// Hit a triple
+					score = (score - 120) * 3;
+			}
+		} else if (score >= 100) {
+			if (score >= 120)
+				// Hit a double
+				score = (2 << 16) + (score - 100);
+			else
+				// Hit a triple
+				score = (3 << 16) + (score - 120);
+		}
+	} else {
+		score = 0;
+	}
+
+	return score;
+}
+
+void Darts::drawDartThrow(const Common::Point &dartPos, int computer) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	int cx, cy;
+	int xSize = 0, ySize = 0, oldxSize = 0, oldySize = 0;
+	int handOCx = 0, handOCy = 0;
+	int ocx = 0, ocy = 0;
+	int handOldxSize, handOldySize;
+	int delta = 9;
+	int dartNum;
+	int hddy;
+	Common::Point drawPos, oldDrawPos;
+
+	// Draw the animation of the hand throwing the dart first
+	// See which hand animation to use
+	ImageFile &hands = !computer ? *_hand1 : *_hand2;
+	int numFrames = !computer ? 14 : 13;
+
+	oldxSize = oldySize = handOldxSize = handOldySize = 1;
+	cx = dartPos.x;
+	cy = SHERLOCK_SCREEN_HEIGHT - _handSize.y - 20;
+
+	hddy = (cy - dartPos.y) / (numFrames - 7);
+	hddy += 2;
+	hddy = hddy * 10 / 8;
+	if (dartPos.y > 275)
+		hddy += 3;
+
+	for (int idx = 0; idx < numFrames; ++idx) {
+		_handSize.x = hands[idx]._offset.x + hands[idx]._width;
+		_handSize.y = hands[idx]._offset.y + hands[idx]._height;
+		int handCy = SHERLOCK_SCREEN_HEIGHT - _handSize.y;
+
+		screen._backBuffer1.transBlitFrom(hands[idx], Common::Point(_handX, handCy));
+		screen.slamArea(_handX, handCy, _handSize.x + 1, _handSize.y);
+		screen.slamArea(handOCx, handOCy, handOldxSize, handOldySize);
+		screen.restoreBackground(Common::Rect(_handX, handCy, _handX + _handSize.x, handCy + _handSize.y));
+
+		handOCx = _handX;
+		handOCy = handCy;
+		handOldxSize = _handSize.x;
+		handOldySize = _handSize.y;
+
+		if (idx > 6) {
+			dartNum = idx - 6;
+			if (computer)
+				dartNum += 19;
+
+			xSize = (*_dartGraphics)[dartNum]._width;
+			ySize = (*_dartGraphics)[dartNum]._height;
+
+			ocx = drawPos.x = cx - (*_dartGraphics)[dartNum]._width / 2;
+			ocy = drawPos.y = cy - (*_dartGraphics)[dartNum]._height;
+
+			// Draw dart
+			screen._backBuffer1.transBlitFrom((*_dartGraphics)[dartNum], drawPos);
+
+			if (drawPos.x < 0) {
+				xSize += drawPos.x;
+				if (xSize < 0)
+					xSize = 1;
+				drawPos.x = 0;
+			}
+
+			if (drawPos.y < 0) {
+				ySize += drawPos.y;
+				if (ySize < 0)
+					ySize = 1;
+				drawPos.y = 0;
+			}
+
+			// Flush the drawn dart to the screen
+			screen.slamArea(drawPos.x, drawPos.y, xSize, ySize);
+			if (oldDrawPos.x != -1)
+				// Flush the erased dart area
+				screen.slamArea(oldDrawPos.x, oldDrawPos.y, oldxSize, oldySize); 
+
+			screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(drawPos.x, drawPos.y), 
+				Common::Rect(drawPos.x, drawPos.y, drawPos.x + xSize, drawPos.y + ySize));
+
+			oldDrawPos.x = drawPos.x;
+			oldDrawPos.y = drawPos.y;
+			oldxSize = xSize;
+			oldySize = ySize;
+
+			cy -= hddy;
+		}
+
+		events.wait(1);
+	}
+
+	// Clear the last little bit of the hand from the screen
+	screen.slamArea(handOCx, handOCy, handOldxSize, handOldySize);
+
+	// Erase the old dart
+	if (oldDrawPos.x != -1)
+		screen.slamArea(oldDrawPos.x, oldDrawPos.y, oldxSize, oldySize);
+
+	screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(drawPos.x, drawPos.y),
+		Common::Rect(drawPos.x, drawPos.y, drawPos.x + xSize, drawPos.y + ySize));
+
+	cx = dartPos.x;
+	cy = dartPos.y + 2;
+	oldDrawPos.x = oldDrawPos.y = -1;
+
+	for (int idx = 5; idx <= 23; ++idx) {
+		dartNum = idx - 4;
+		if (computer)
+			dartNum += 19;
+
+		if (idx < 14)
+			cy -= delta--;
+		else
+			if (idx == 14)
+				delta = 1;
+		if (idx > 14)
+			cy += delta++;
+
+		xSize = (*_dartGraphics)[dartNum]._width;
+		ySize = (*_dartGraphics)[dartNum]._height;
+
+		ocx = drawPos.x = cx - (*_dartGraphics)[dartNum]._width / 2;
+		ocy = drawPos.y = cy - (*_dartGraphics)[dartNum]._height;
+
+		screen._backBuffer1.transBlitFrom((*_dartGraphics)[dartNum], Common::Point(drawPos.x, drawPos.y));
+
+		if (drawPos.x < 0) {
+			xSize += drawPos.x;
+			if (xSize < 0)
+				xSize = 1;
+			drawPos.x = 0;
+		}
+
+		if (drawPos.y < 0) {
+			ySize += drawPos.y;
+			if (ySize < 0)
+				ySize = 1;
+			drawPos.y = 0;
+		}
+
+		// flush the dart
+		screen.slamArea(drawPos.x, drawPos.y, xSize, ySize);
+		if (oldDrawPos.x != -1)
+			screen.slamArea(oldDrawPos.x, oldDrawPos.y, oldxSize, oldySize);
+
+		if (idx != 23)
+			screen._backBuffer1.blitFrom(screen._backBuffer2, drawPos, 
+				Common::Rect(drawPos.x, drawPos.y, drawPos.x + xSize, drawPos.y + ySize)); // erase dart
+
+		events.wait(1);
+
+		oldDrawPos = drawPos;
+		oldxSize = xSize;
+		oldySize = ySize;
+	}
+
+	dartNum = 19;
+	if (computer)
+		dartNum += 19;
+	xSize = (*_dartGraphics)[dartNum]._width;
+	ySize = (*_dartGraphics)[dartNum]._height;
+
+	// Draw final dart on the board
+	screen._backBuffer1.transBlitFrom((*_dartGraphics)[dartNum], Common::Point(ocx, ocy));
+	screen._backBuffer2.transBlitFrom((*_dartGraphics)[dartNum], Common::Point(ocx, ocy));
+	screen.slamArea(ocx, ocy, xSize, ySize);
+}
+
+int Darts::findNumberOnBoard(int aim, Common::Point &pt) {
+	ImageFrame &img = (*_dartMap)[0];
+
+	if ((aim > 20) && ((aim != 25) && (aim != 50))) {
+		if ((aim <= 40) && ((aim & 1) == 0)) {
+			aim /= 2;
+			aim += 100;
+		} else {
+			aim /= 3;
+			aim += 120;
+		}
+	}
+
+	bool done = false;
+	for (int y = 0; y < img._width && !done; ++y) {
+		for (int x = 0; x < img._height && !done; ++x) {
+			byte score = *(const byte *)img._frame.getBasePtr(x, y);
+
+			if (score == aim) {
+				// Found a match. Aim at non-double/triple numbers whenever possible.
+				// ie. Aim at 18 instead of triple 6 or double 9
+				done = true;
+
+				if (aim < 21) {
+					pt.x = x + 10;
+					pt.y = y + 10;
+
+					score = *(const byte *)img._frame.getBasePtr(x, y);
+					if (score != aim)
+						done = false;
+				} else {
+					// Aiming at double or triple
+					pt.x = x + 3;
+					pt.y = y + 3;
+				}
+			}
+		}
+	}
+	
+	pt = convertFromScreenToScoreCoords(pt);
+
+	if (aim == 3)
+		pt.y += 30;
+	if (aim == 17)
+		pt.y += 10;
+
+	if (aim == 15) {
+		pt.y += 5;
+		pt.x += 5;
+	}
+
+	pt.y = DARTBOARD_HEIGHT - pt.y;
+	return done;
+}
+
+void Darts::getComputerNumber(int playerNum, Common::Point &targetPos) {
+	int score;
+	int aim = 0;
+	Common::Point pt;
+	bool shootBull = false;
+
+	score = (playerNum == 0) ? _score1 : _score2;
+
+	if (_gameType == GAME_301) {
+		// Try to hit number
+		aim = score; 
+		if(score > 60)
+			shootBull = true;
+	} else {
+		bool cricketaimset = false;
+		if (_cricketScore[playerNum][6] < 3) {
+			// shoot at bull first
+			aim = CRICKET_VALUE[6];
+			cricketaimset = true;
+		} else {
+			// Now check and shoot in this order: 20,19,18,17,16,15
+			for (int idx = 0; idx < 7; ++idx) {
+				if (_cricketScore[playerNum][idx] < 3) {
+					aim = CRICKET_VALUE[idx];
+					cricketaimset = true;
+					break;
+				}
+			}
+		}
+
+		if (!cricketaimset) {
+			// Everything is closed
+			// just in case we don't get set in loop below, which should never happen
+			aim = 14;  
+			for (int idx = 0; idx < 7; ++idx) {
+				if (_cricketScore[playerNum^1][idx] < 3) {
+					// Opponent has this open
+					aim = CRICKET_VALUE[idx];
+
+					if (idx == 6)
+						shootBull = true;
+				}
+			}
+		}
+	}
+
+	if (shootBull) {
+		// Aim at bulls eye
+		targetPos.x = targetPos.y = 75;
+
+		if (_level <= 1) {
+			if (_vm->getRandomNumber(1) == 1) {
+				targetPos.x += (_vm->getRandomNumber(20)-10);
+				targetPos.y += (_vm->getRandomNumber(20)-10);
+			}
+		}
+	} else {
+		// Loop in case number does not exist on board
+		bool done = false;
+		do {
+			done = findNumberOnBoard(aim, pt);
+			--aim;
+		} while (!done);
+
+		pt.x += DARTBOARD_TOTALLEFT * 70 / 100;
+		pt.y += DARTBOARD_TOTALTOP * 70 / 100;
+
+		// old * 3/2
+		targetPos.x = pt.x * 100 / DARTBOARD_TOTALX * 3 / 2;
+		targetPos.y = pt.y * 100 / DARTBOARD_TOTALY * 3 / 2;
+	}
+
+	// the higher the level, the more accurate the throw
+	int v = _vm->getRandomNumber(9);
+	v += _level * 2; 
+
+	if (v <= 2) {
+		targetPos.x += _vm->getRandomNumber(70) - 35;
+		targetPos.y += _vm->getRandomNumber(70) - 35;
+	} else if (v <= 4) {
+		targetPos.x += _vm->getRandomNumber(50) - 25;
+		targetPos.y += _vm->getRandomNumber(50) - 25;
+	} else if (v <= 6) {
+		targetPos.x += _vm->getRandomNumber(30) - 15;
+		targetPos.y += _vm->getRandomNumber(30) - 15;
+	} else if (v <= 8) {
+		targetPos.x += _vm->getRandomNumber(20) -10;
+		targetPos.y += _vm->getRandomNumber(20) -10;
+	} else if (v <= 10) {
+		targetPos.x += _vm->getRandomNumber(11) - 5;
+		targetPos.y += _vm->getRandomNumber(11) - 5;
+	}
+
+	if (targetPos.x < 1)
+		targetPos.x = 1;
+	if (targetPos.y < 1)
+		targetPos.y = 1;
+}
+
+int Darts::throwDart(int dartNum, int computer) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	int height;
+	int horiz;
+	Common::Point targetPos;
+	Common::String temp;
+
+	/* clear keyboard buffer */
+	events.clearEvents();
+
+	erasePowerBars();
+	screen.print(Common::Point(_dartInfo.left, _dartInfo.top), 0, "%s # %d", FIXED(Dart), dartNum);
+
+	drawDartsLeft(dartNum, computer);
+
+	if (!computer) {
+		screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing), 0, "%s", FIXED(HitAKey));
+		screen.print(Common::Point(_dartInfo.left, _dartInfo.top + _spacing * 2), 0, "%s", FIXED(ToStart));
+	}
+
+	if (!computer) {
+		// Wait for a hit
+		while (!dartHit() && !_vm->shouldQuit())
+			events.wait(1);
+		if (_escapePressed)
+			return 0;
+	} else {
+		events.wait(1);
+	}
+
+	drawDartsLeft(dartNum + 1, computer);
+	screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(_dartInfo.left, _dartInfo.top - 1),
+		Common::Rect(_dartInfo.left, _dartInfo.top - 1, _dartInfo.right, _dartInfo.bottom - 1));
+	screen.blitFrom(screen._backBuffer1, Common::Point(_dartInfo.left, _dartInfo.top - 1),
+		Common::Rect(_dartInfo.left, _dartInfo.top - 1, _dartInfo.right, _dartInfo.bottom - 1));
+
+	if (computer) {
+		getComputerNumber(computer - 1, targetPos);
+	} else {
+		// Keyboard control
+		targetPos = Common::Point(0, 0);
+	}
+
+	horiz = drawHand(targetPos.x, computer);
+	if (_escapePressed)
+		return 0;
+
+	height = doPowerBar(Common::Point(DART_BAR_VX, DART_HEIGHT_Y), DART_BAR_FORE, targetPos.y, 1);
+	if (_escapePressed)
+		return 0;
+
+	// Invert height
+	height = 101 - height;
+
+	// Copy power bars to the secondary back buffer
+	screen._backBuffer2.blitFrom(screen._backBuffer1, Common::Point(DART_BAR_VX - 1, DART_HEIGHT_Y - 1),
+		Common::Rect(DART_BAR_VX - 1, DART_HEIGHT_Y - 1, DART_BAR_VX - 1 + 10, 
+		DART_HEIGHT_Y - 1 + DART_BAR_SIZE + 2));
+
+	Common::Point dartPos(DARTBOARD_TOTALLEFT + horiz*DARTBOARD_TOTALX / 100,
+		DARTBOARD_TOTALTOP + height * DARTBOARD_TOTALY / 100);
+	
+	dartPos.x += 2 - _vm->getRandomNumber(4);
+	dartPos.y += 2 - _vm->getRandomNumber(4);
+
+	drawDartThrow(dartPos, computer);
+	return dartScore(dartPos);
+}
+
+void Darts::doCricketScoreHits(int player, int scoreIndex, int numHits) {
+	while (numHits--) {
+		if (_cricketScore[player][scoreIndex] < 3)
+			_cricketScore[player][scoreIndex]++;
+		else if (_cricketScore[player ^ 1][scoreIndex] < 3) {
+			if (player == 0)
+				_score1 += CRICKET_VALUE[scoreIndex];
+			else
+				_score2 += CRICKET_VALUE[scoreIndex];
+		}
+	}
+}
+
+void Darts::updateCricketScore(int player, int dartVal, int multiplier) {
+	if (dartVal < 15)
+		return;
+
+	if (dartVal <= 20)
+		doCricketScoreHits(player, 20 - dartVal, multiplier);
+	else if (dartVal == 25)
+		doCricketScoreHits(player, 6, multiplier);
+}
+
+void Darts::drawDartsLeft(int dartNum, int computer) {
+	Screen &screen = *_vm->_screen;
+	const int DART_X1[3] = { 391, 451, 507 };
+	const int DART_Y1[3] = { 373, 373, 373 };
+	const int DART_X2[3] = { 393, 441, 502 };
+	const int DART_Y2[3] = { 373, 373, 373 };
+
+	screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(DART_X1[0], DART_Y1[0]),
+		Common::Rect(DART_X1[0], DART_Y1[0], SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+
+	for (int idx = 2; idx >= dartNum - 1; --idx) {
+		if (computer)
+			screen._backBuffer1.transBlitFrom((*_dartsLeft)[idx + 3], Common::Point(DART_X2[idx], DART_Y2[idx]));
+		else
+			screen._backBuffer1.transBlitFrom((*_dartsLeft)[idx], Common::Point(DART_X1[idx], DART_Y1[idx]));
+	}
+
+	screen.slamArea(DART_X1[0], DART_Y1[0], SHERLOCK_SCREEN_WIDTH - DART_X1[0], SHERLOCK_SCREEN_HEIGHT - DART_Y1[0]);
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_darts.h b/engines/sherlock/tattoo/tattoo_darts.h
new file mode 100644
index 0000000000..ab6b1c8204
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_darts.h
@@ -0,0 +1,173 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_TATTOO_DARTS_H
+#define SHERLOCK_TATTOO_DARTS_H
+
+#include "common/scummsys.h"
+#include "sherlock/image_file.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+enum GameType { GAME_301, GAME_CRICKET, GAME_501 };
+
+class Darts {
+private:
+	SherlockEngine *_vm;
+	GameType _gameType;
+	ImageFile *_hand1, *_hand2;
+	ImageFile *_dartGraphics;
+	ImageFile *_dartsLeft;
+	ImageFile *_dartMap;
+	ImageFile *_dartBoard;
+	Common::Rect _dartInfo;
+	int _cricketScore[2][7];
+	int _score1, _score2;
+	int _roundNum;
+	int _roundScore;
+	int _level;
+	int _compPlay;
+	Common::String _opponent;
+	int _spacing;
+	bool _oldDartButtons;
+	int _handX;
+	Common::Point _handSize;
+	bool _escapePressed;
+
+	/**
+	 * Initialize game variables
+	 */
+	void initDarts();
+
+	/**
+	 * Load dartboard graphics
+	 */
+	void loadDarts();
+
+	/**
+	 * Free loaded dart images
+	 */
+	void closeDarts();
+
+	/**
+	 * Show the player names
+	 */
+	void showNames(int playerNum);
+
+	/**
+	 * Show the current scores
+	 */
+	void showStatus(int playerNum);
+
+	/**
+	 * Erases the power bars
+	 */
+	void erasePowerBars();
+
+	/**
+	 * Returns true if a mouse button or key is pressed
+	 */
+	bool dartHit();
+
+	/**
+	 * Shows a power bar and increments it until a key or mouse button is pressed. If the bar
+	 * reaches the end, it will also end. The reached power bar number is returned.
+	 * @param pt			Bar position
+	 * @param color			draw color
+	 * @param goToPower		If provided, input is ignored, and the bar is increased up to the specified level
+	 * @param orientation	0=Horizontal, 1=Vertical
+	 */
+	int doPowerBar(const Common::Point &pt, byte color, int goToPower, int orientation);
+
+	/**
+	 * This is similar to doPowerBar, except it draws the player's hand moving across the 
+	 * bottom of the screen to indicate the positioning of the darts
+	 */
+	int drawHand(int goToPower, int computer);
+
+	/**
+	 * Converts a passed co-ordinates from screen co-ordinates to an offset within the dartboard
+	 */
+	Common::Point convertFromScreenToScoreCoords(const Common::Point &pt) const;
+
+	/**
+	 * Return the score a dart at the given position will get
+	 */
+	int dartScore(const Common::Point &pt);
+
+	/**
+	 * Draw a dart travelling to the board
+	 */
+	void drawDartThrow(const Common::Point &dartPos, int computer);
+
+	/**
+	 * Looks for the passed number on the dartboard. If it finds it, it will return
+	 * the co-ordinates of the center of the number
+	 */
+	int findNumberOnBoard(int aim, Common::Point &pt);
+
+	/**
+	 * Calculates a position for the comptuer wants to throw, and then calculates where they
+	 * actually did throw. The computer will not always hit what it's aiming it.
+	 */
+	void getComputerNumber(int playerNum, Common::Point &targetPos);
+
+	/**
+	 * Throw one dart. If computer is 1 or 2, the computer will throw the dart, and user input
+	 * will be ignored.
+	 * @param computer		1=1st computer player, 2=2nd computer player
+	 */
+	int throwDart(int dartNum, int computer);
+
+	/**
+	 * This will update the number of hits for the target score, as well as updating the
+	 * score if it's closed
+	 */
+	void doCricketScoreHits(int player, int scoreIndex, int numHits);
+
+	/**
+	 * Updates the score based upon what the dart hit
+	 */
+	void updateCricketScore(int player, int dartVal, int multiplier);
+
+	/**
+	 * Draw the darts left
+	 */
+	void drawDartsLeft(int dartNum, int computer);
+public:
+	Darts(SherlockEngine *vm);
+
+	/**
+	 * Play the darts game
+	 */
+	void playDarts(GameType gameType);
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/zvision/detection.h b/engines/sherlock/tattoo/tattoo_debugger.cpp
index f80cac79ec..8d59b4c592 100644
--- a/engines/zvision/detection.h
+++ b/engines/sherlock/tattoo/tattoo_debugger.cpp
@@ -20,24 +20,16 @@
  *
  */
 
-#ifndef ZVISION_DETECTION_H
-#define ZVISION_DETECTION_H
+#include "sherlock/tattoo/tattoo_debugger.h"
+#include "sherlock/sherlock.h"
 
-#include "engines/advancedDetector.h"
+namespace Sherlock {
 
-namespace ZVision {
-
-enum ZVisionGameId {
-	GID_NONE = 0,
-	GID_NEMESIS = 1,
-	GID_GRANDINQUISITOR = 2
-};
-
-struct ZVisionGameDescription {
-	ADGameDescription desc;
-	ZVisionGameId gameId;
-};
+namespace Tattoo {
 
+TattooDebugger::TattooDebugger(SherlockEngine *vm) : Debugger(vm) {
 }
 
-#endif
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_debugger.h b/engines/sherlock/tattoo/tattoo_debugger.h
new file mode 100644
index 0000000000..e729262b11
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_debugger.h
@@ -0,0 +1,44 @@
+/* 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 SHERLOCK_TATTOO_DEBUGGER_H
+#define SHERLOCK_TATTOO_DEBUGGER_H
+
+#include "sherlock/debugger.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+class TattooDebugger : public Debugger {
+public:
+	TattooDebugger(SherlockEngine *vm);
+	virtual ~TattooDebugger() {}
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif	/* SHERLOCK_TATTOO_DEBUGGER_H */
diff --git a/engines/sherlock/tattoo/tattoo_fixed_text.cpp b/engines/sherlock/tattoo/tattoo_fixed_text.cpp
new file mode 100644
index 0000000000..38acd78aba
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_fixed_text.cpp
@@ -0,0 +1,792 @@
+/* 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 "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/sherlock.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+static const char *const fixedTextEN[] = {
+	"Money",
+	"Money",
+	"Card",
+	"Card",
+	"Tobacco",
+	"Tobacco",
+	"Timetable",
+	"Timetable",
+	"Summons",
+	"Summons",
+	"Foolscap",
+	"Foolscap",
+	"Damp Paper",
+	"Foolscap",
+	"Bull's Eye",
+	"Bull's Eye Lantern",
+
+	"Open",
+	"Look",
+	"Talk",
+	"Use",
+	"Journal",
+	"Inventory",
+	"Options",
+	"Solve",
+	"with",
+	"No effect...",
+	"This person has nothing to say at the moment",
+	"Picked up",
+
+	"Page %d",
+	"Close Journal",
+	"Search Journal",
+	"Save Journal",
+	"Abort Search",
+	"Search Backwards",
+	"Search Forwards",
+	"Text Not Found !",
+
+	"Holmes",
+	"Jock",
+	"Bull",
+	"Round",
+	"Turn Total",
+	"Dart",
+	"to start",
+	"Hit a key",
+	"Press a key",
+	"bullseye", // ??
+	"GAME OVER",
+	"BUSTED",
+	"Wins",
+	"Scored",
+	"points",
+	"Hit %s %d",
+	"Double",
+	"Triple",
+
+	"Apply",
+	"Water",
+	"Heat",
+	"Load Game",
+	"Save Game",
+	"Music",
+	"Sound Effects",
+	"Voices",
+	"Text Windows",
+	"Transparent Menus",
+	"Change Font Style",
+	"Off",
+	"On",
+	"Quit",
+	"Are you sure you",
+	"wish to Quit ?",
+	"Yes",
+	"No",
+	"Enter Password",
+	"Going East", // correct password, was not and should not to be translated
+	// SH2: People names
+	"Sherlock Holmes",
+	"Dr. Watson",
+	"Mrs. Hudson",
+	"Stanley Forbes",
+	"Mycroft Holmes",
+	"Wiggins",
+	"Police Constable Burns",
+	"Augustus Trimble",
+	"Police Constable Daley",
+	"Matron",
+	"Sister Grace",
+	"Preston McCabe",
+	"Bob Colleran",
+	"Jonas Rigby",
+	"Police Constable Roach",
+	"James Dewar",
+	"Sergeant Jeremy Duncan",
+	"Inspector Gregson",
+	"Inspector Lestrade",
+	"Jesse Needhem",
+	"Arthur Fleming",
+	"Mr. Thomas Pratt",
+	"Mathilda (Tillie) Mason",
+	"Adrian Russell",
+	"Eldridge Whitney",
+	"Hepplethwaite",
+	"Horace Silverbridge",
+	"Old Sherman",
+	"Maxwell Verner",
+	"Millicent Redding",
+	"Virgil Silverbridge",
+	"George O'Keeffe",
+	"Lord Denys Lawton",
+	"Jenkins",
+	"Jock Mahoney",
+	"Bartender",
+	"Lady Cordelia Lockridge",
+	"Pettigrew",
+	"Sir Avery Fanshawe",
+	"Hodgkins",
+	"Wilbur \"Birdy\" Heywood",
+	"Jacob Farthington",
+	"Philip Bledsoe",
+	"Sidney Fowler",
+	"Professor Theodore Totman",
+	"Rose Hinchem",
+	"Tallboy",
+	"Ethlebert \"Stitch\" Rumsey",
+	"Charles Freedman",
+	"Nigel Hemmings",
+	"Fairfax Carter",
+	"Wilhelm II",
+	"Wachthund",
+	"Jonathan Wilson",
+	"David Lloyd-Jones",
+	"Edward Hargrove",
+	"Misteray",
+	"The Lascar",
+	"Parrot",
+	"Vincent Scarrett",
+	"Alexandra",
+	"Queen Victoria",
+	"John Brown",
+	"A Patient",
+	"A Patient",
+	"Patron",
+	"Queen Victoria",
+	"Patient in white",
+	"Lush",
+	"Drunk",
+	"Prostitute",
+	"Mudlark",
+	"Grinder",
+	"Bouncer",
+	"Agnes Ratchet",
+	"Aloysius Ratchet",
+	"Real Estate Agent",
+	"Candy Clerk",
+	"Beadle",
+	"Prussian",
+	"Mrs. Rowbottom",
+	"Miss Lloyd-Jones",
+	"Tavern patron",
+	"User",
+	"Toby",
+	"Stationer",
+	"Law Clerk",
+	"Ministry Clerk",
+	"Bather",
+	"Maid",
+	"Lady Fanshawe",
+	"Sidney Ratchet",
+	"Boy",
+	"Patron",
+	"Constable Brit",
+	"Wagon Driver"
+};
+
+// sharp-s       : 0xE1 / octal 341
+// small a-umlaut: 0x84 / octal 204
+// small o-umlaut: 0x94 / octal 224
+// small u-umlaut: 0x81 / octal 201
+// large O-umlaut: 0x99 / octal 231
+static const char *const fixedTextDE[] = {
+	"Geld",
+	"Geld",
+	"S. Holmes",
+	"S. Holmes",
+	"Tabak",
+	"Tabak",
+	"Plan",
+	"Plan",
+	"Aufforderg.",
+	"Aufforderg.",
+	"Blatt pap.",
+	"Pergament",
+	"Dunstig pap",
+	"Dunstig pap",
+	"Handlampe",
+	"Handlampe",
+
+	"\231ffne",
+	"Schau",
+	"Rede",
+	"Benutze",
+	"Tagebuch",
+	"Tasche",
+	"Optionen",
+	"L\224osen",
+	"mit",
+	"Keine Wirkung...",
+	"Diese Person wei\341 im Augenblick nichts zu berichten.",
+	"Picked up", // <-- ??
+
+	"Seite %d",
+	"Schlie\341en",
+	"Lessen", // <--
+	"In Datei sichern",
+	"Suche abbrechen",
+	"R\201ckw\204rts suchen ",
+	"Vorwarts suchen ",
+	"Text nicht gefunden",
+
+	"Holmes",
+	"Jock",
+	"Bull",
+	"Runde: %d",
+	"Gesamt: %d",
+	"Pfeil # %d",
+	"zum Starten",
+	"Taste dr\201cken",
+	"Taste dr\201cken",
+	"Bullseye", // ??
+	"SPIEL BEENDET!",
+	"VERLOREN!",
+	"Gewinnt!", // "Holmes Gewinnt!", "%s Gewinnt!"
+	"Erzielte %d Punkte",
+	"Punkte", // ??
+	"Treffer %s %d",
+	"Doppel",
+	"Dreifach",
+
+	"Benutze",
+	"Wasser",
+	"Erhitze",
+	"Spiel laden",
+	"Spiel sichern",
+	"Musik",
+	"Soundeffekte",
+	"Voices",
+	"Textfenster",
+	"Transparente Men\201s",
+	"Schriftart andern",
+	"Aus",
+	"An",
+	"Ende",
+	"Spiel beenden? ",
+	"Sind Sie sicher ?",
+	"Ja",
+	"Nein",
+	"Pa\341wort eingeben",
+	"Going East", // correct password, was not and should not to be translated
+	// SH2: People names
+	"Sherlock Holmes", // note: People names were not translated in the German interpreter
+	"Dr. Watson",
+	"Mrs. Hudson",
+	"Stanley Forbes",
+	"Mycroft Holmes",
+	"Wiggins",
+	"Police Constable Burns",
+	"Augustus Trimble",
+	"Police Constable Daley",
+	"Matron",
+	"Sister Grace",
+	"Preston McCabe",
+	"Bob Colleran",
+	"Jonas Rigby",
+	"Police Constable Roach",
+	"James Dewar",
+	"Sergeant Jeremy Duncan",
+	"Inspector Gregson",
+	"Inspector Lestrade",
+	"Jesse Needhem",
+	"Arthur Fleming",
+	"Mr. Thomas Pratt",
+	"Mathilda (Tillie) Mason",
+	"Adrian Russell",
+	"Eldridge Whitney",
+	"Hepplethwaite",
+	"Horace Silverbridge",
+	"Old Sherman",
+	"Maxwell Verner",
+	"Millicent Redding",
+	"Virgil Silverbridge",
+	"George O'Keeffe",
+	"Lord Denys Lawton",
+	"Jenkins",
+	"Jock Mahoney",
+	"Bartender",
+	"Lady Cordelia Lockridge",
+	"Pettigrew",
+	"Sir Avery Fanshawe",
+	"Hodgkins",
+	"Wilbur \"Birdy\" Heywood",
+	"Jacob Farthington",
+	"Philip Bledsoe",
+	"Sidney Fowler",
+	"Professor Theodore Totman",
+	"Rose Hinchem",
+	"Tallboy",
+	"Ethlebert \"Stitch\" Rumsey",
+	"Charles Freedman",
+	"Nigel Hemmings",
+	"Fairfax Carter",
+	"Wilhelm II",
+	"Wachthund",
+	"Jonathan Wilson",
+	"David Lloyd-Jones",
+	"Edward Hargrove",
+	"Misteray",
+	"The Lascar",
+	"Parrot",
+	"Vincent Scarrett",
+	"Alexandra",
+	"Queen Victoria",
+	"John Brown",
+	"A Patient",
+	"A Patient",
+	"Patron",
+	"Queen Victoria",
+	"Patient in white",
+	"Lush",
+	"Drunk",
+	"Prostitute",
+	"Mudlark",
+	"Grinder",
+	"Bouncer",
+	"Agnes Ratchet",
+	"Aloysius Ratchet",
+	"Real Estate Agent",
+	"Candy Clerk",
+	"Beadle",
+	"Prussian",
+	"Mrs. Rowbottom",
+	"Miss Lloyd-Jones",
+	"Tavern patron",
+	"User",
+	"Toby",
+	"Stationer",
+	"Law Clerk",
+	"Ministry Clerk",
+	"Bather",
+	"Maid",
+	"Lady Fanshawe",
+	"Sidney Ratchet",
+	"Boy",
+	"Patron",
+	"Constable Brit",
+	"Wagon Driver"
+};
+
+// small a w/ accent grave: 0x85 / octal 205
+// small e w/ accent acute: 0x82 / octal 202
+// small e w/ accent grave: 0x8A / octal 212
+// small e w/ circonflexe:  0x88 / octal 210
+// small cedilla:           0x87 / octal 207
+static const char *const fixedTextFR[] = {
+	"Argent",
+	"Argent",
+	"S. Holmes",
+	"S. Holmes",
+	"Tabac",
+	"Tabac",
+	"Horaire",
+	"Horaire",
+	"Convocation",
+	"Convocation",
+	"Feuille",
+	"Feuille",
+	"F. humide",
+	"Feuille",
+	"Lanterne",
+	"Lanterne",
+
+	"Ouvrir",
+	"Regarder",
+	"Parler",
+	"Utiliser",
+	"Journal", // <--
+	"Inventaire",
+	"Options",
+	"R\202soudre",
+	"avec",
+	"Sans effet...",
+	"Cette personne n'a rien \205 ajouter pour le moment.",
+	"Picked up", // <-- ??
+
+	"Page %d",
+	"Fermer",
+	"Lessen", // <--
+	"Sauvegarder",
+	"Annuler ",
+	"Chercher avant",
+	"Chercher apr\212s",
+	"Texte introuvable !",
+
+	"Holmes",
+	"Jock",
+	"Bull",
+	"Tour: %d",
+	"Total: %d",
+	"Fl\202chette # %d",
+	"pour commencer",
+	"Appuyez sur C",
+	"Appuyez sur C",
+	"Bullseye", // ??
+	"FIN DE LA PARTIE!", // original: "Fin de la partie!"
+	"FIASCO!",
+	"Gagnant!", // "Holmes Gagnant!", "%s Gagnant!"
+	"Total des points: %d",
+	"Punkte", // ??
+	"Treffer %s %d",
+	"double",
+	"triple",
+
+	"Mouillez",
+	"Puis",
+	"Chauffez",
+	"Charger",
+	"Sauvegarder",
+	"Musique",
+	"Sons",
+	"Voix",
+	"Fen\210tres de texte", // 0x88
+	"Menu Transparent",
+	"Changer la fonte",
+	"Aus", // ???
+	"An", // ???
+	"Quitter",
+	"Voulez-vous quitter?",
+	"Sind Sie sicher ?", // ???
+	"Oui",
+	"Non",
+	"Entrez le mot de passe",
+	"Going East", // correct password, was not and should not to be translated
+	// SH2: People names
+	"Sherlock Holmes",
+	"Dr. Watson",
+	"Mme. Hudson",
+	"Stanley Forbes",
+	"Mycroft Holmes",
+	"Wiggins",
+	"Sergent Burns",
+	"Augustus Trimble",
+	"Sergent Daley",
+	"Infirmi\212re chef",
+	"Mme. Grace",
+	"Preston McCabe",
+	"Bob Colleran",
+	"Jonas Rigby",
+	"Sergent Roach",
+	"James Dewar",
+	"Sergent Jeremy Duncan",
+	"Inspecteur Gregson",
+	"Inspecteur Lestrade",
+	"Jesse Needhem",
+	"Arthur Fleming",
+	"M. Thomas Pratt",
+	"Mathilda (Tillie) Mason",
+	"Adrian Russell",
+	"Eldridge Whitney",
+	"Hepplethwaite",
+	"Horace Silverbridge",
+	"Sherman",
+	"Maxwell Verner",
+	"Millicent Redding",
+	"Virgil Silverbridge",
+	"George O'Keeffe",
+	"Lord Denys Lawton",
+	"Jenkins",
+	"Jock Mahoney",
+	"Serveur",
+	"Lady Cordelia Lockridge",
+	"Pettigrew",
+	"Sir Avery Fanshawe",
+	"Hodgkins",
+	"Wilbur \"Birdy\" Heywood",
+	"Jacob Farthington",
+	"Philip Bledsoe",
+	"Sidney Fowler",
+	"Professeur Theodore Totman",
+	"Rose Hinchem",
+	"Tallboy",
+	"Ethlebert \"Stitch\" Rumsey",
+	"Charles Freedman",
+	"Nigel Hemmings",
+	"Fairfax Carter",
+	"Wilhelm II",
+	"Wachthund",
+	"Jonathan Wilson",
+	"David Lloyd-Jones",
+	"Edward Hargrove",
+	"Misteray",
+	"Le Lascar",
+	"Oiseau",
+	"Vincent Scarrett",
+	"Alexandra",
+	"Queen Victoria",
+	"John Brown",
+	"Patient",
+	"Patient",
+	"Client",
+	"Queen Victoria",
+	"Patient en blanc",
+	"Ivrogne",
+	"Ivrogne",
+	"Belle femme",
+	"Mudlark",
+	"Broyeur",
+	"Videur",
+	"Agnes Ratchet",
+	"Aloysius Ratchet",
+	"Immobilier",
+	"Gar\207on",
+	"Beadle",
+	"Prussian",
+	"Mme. Rowbottom",
+	"Mme Lloyd-Jones",
+	"Tavern Client",
+	"User",
+	"Toby",
+	"Papeterie",
+	"Law Clerc",
+	"Ministry Employ\202",
+	"Clint du thermes",
+	"Bonne",
+	"Lady Fanshawe",
+	"Sidney Ratchet",
+	"Gar\207on",
+	"Client",
+	"Sergent Brit",
+	"Wagon Driver"
+};
+
+// small a w/ accent bottom to top : 0xA0 / octal 240
+// small i w/ accent bottom to top : 0xA1 / octal 241
+// small o w/ accent bottom to top : 0xA2 / octal 242
+// small u w/ accent bottom to top : 0xA3 / octal 243
+// small n w/ wavy line            : 0xA4 / octal 244
+// inverted question mark          : 0xA8 / octal 250
+static const char *const fixedTextES[] = {
+	"Dinero",
+	"Dinero",
+	"Tarjeta",
+	"Tarjeta",
+	"Tabaco",
+	"Tabaco",
+	"Horarios",
+	"Horarios",
+	"Mensaje",
+	"Mensaje",
+	"Papel",
+	"Papel",
+	"Papel",
+	"Papel",
+	"Linterna",
+	"Linterna",
+
+	"Abrir",
+	"Mirar",
+	"Hablar",
+	"Usar",
+	"Diario",
+	"Inventario",
+	"Opciones",
+	"Resolver",
+	"con",
+	"Sin Efecto...",
+	"Esta persona no tiene nada que decir en este momento",
+	"Picked up", // <-- ??
+
+	"P\240gina %d",
+	"Cerrar Diario",
+	"Lessen", // <-- not included?!?!
+	"Salvar en Archivo",
+	"Detener B\243squeda",
+	"Buscar Hacia Atr\240s",
+	"Buscar Hacia Delante",
+	"Texto No Encontrado !",
+
+	"Holmes", //
+	"Jock",
+	"Bull",
+	"Vuelta: %d",
+	"Total del Turno: %d",
+	"Dardo # %d",
+	"para empezar",
+	"Pulsa una tecla",
+	"Pulsa una tecla",
+	"Golpe %s ojo de buey", // ??
+	"FIN DE LA PARTIDA!",
+	"ROTO!",
+	"Gana!", // "Holmes Gana!", "%s Gana!"
+	"Puntuado %d puntos",
+	"puntos", // ??
+	"Golpe %s %d",
+	"doble",
+	"triple",
+
+	"aplicar",
+	"Agua",
+	"Calentar",
+	"Cargar Partida",
+	"Salvar Partida",
+	"M\243sica",
+	"Efectos de Sonido",
+	"Voces",
+	"Ventanas de Texto",
+	"Men\243s Transparentes",
+	"Cambiar Tipo de Letra",
+	"Off", // ???
+	"On", // ???
+	"Salir",
+	"quieres salir?",
+	"\250Est\240s seguro de que",
+	"Si",
+	"Non",
+	"Introducir Palabra Clave",
+	"Vas al Este", // correct password, was translated in Spanish version (???)
+	// SH2: People names
+	"Sherlock Holmes",
+	"Dr. Watson",
+	"Sta. Hudson",
+	"Stanley Forbes",
+	"Mycroft Holmes",
+	"Wiggins",
+	"Agente de Polic\241a Burns",
+	"Augustus Trimble",
+	"Agente de Polic\241a Daley",
+	"Enfermera",
+	"Hermana Grace",
+	"Preston McCabe",
+	"Bob Colleran",
+	"Jonas Rigby",
+	"Agente de Polic\241a Roach",
+	"James Dewar",
+	"Sargento Jeremy Duncan",
+	"Inspector Gregson",
+	"Inspector Lestrade",
+	"Jesse Needhem",
+	"Arthur Fleming",
+	"Sr. Thomas Pratt",
+	"Mathilda (Tillie) Mason",
+	"Adrian Russell",
+	"Eldridge Whitney",
+	"Hepplethwaite",
+	"Horace Silverbridge",
+	"Old Sherman",
+	"Maxwell Verner",
+	"Millicent Redding",
+	"Virgil Silverbridge",
+	"George O'Keeffe",
+	"Lord Denys Lawton",
+	"Jenkins",
+	"Jock Mahoney",
+	"Camarero",
+	"Lady Cordelia Lockridge",
+	"Pettigrew",
+	"Sir Avery Fanshawe",
+	"Hodgkins",
+	"Wilbur \"Birdy\" Heywood",
+	"Jacob Farthington",
+	"Philip Bledsoe",
+	"Sidney Fowler",
+	"Profesor Theodore Totman",
+	"Rose Hinchem",
+	"Tallboy",
+	"Ethlebert \"Stitch\" Rumsey",
+	"Charles Freedman",
+	"Nigel Hemmings",
+	"Fairfax Carter",
+	"Guillermo II",
+	"Wachthund",
+	"Jonathan Wilson",
+	"David Lloyd-Jones",
+	"Edward Hargrove",
+	"Misteray",
+	"The Lascar",
+	"Loro",
+	"Vincent Scarrett",
+	"Alexandra",
+	"Reina Victoria",
+	"John Brown",
+	"Un Paciente",
+	"Un Paciente",
+	"Cliente",
+	"Reina Victoria",
+	"Paciente de blanco",
+	"Exuberante",
+	"Borracho",
+	"Prostituta",
+	"Mudlark",
+	"Grinder",
+	"Mat\242n", // sic? means block in Spanish and not bouncer?!
+	"Agnes Ratchet",
+	"Aloysius Ratchet",
+	"Agente de Bienes Ra\241ces",
+	"Candy Clerk",
+	"Beadle",
+	"Prusiano",
+	"Sta. Rowbottom",
+	"Sra. Lloyd-Jones",
+	"Parroquiano",
+	"Usuario",
+	"Toby",
+	"Papelero",
+	"Secretario de Justicia",
+	"Secreatrio del Ministerio",
+	"Ba\244ista",
+	"Criada",
+	"Lady Fanshawe",
+	"Sidney Ratchet",
+	"Chico",
+	"Patron", // ??? not found??
+	"Agente Brit",
+	"Cochero"
+};
+
+// TODO: There also was a Spanish version of Sherlock Holmes 2
+static const FixedTextLanguageEntry fixedTextLanguages[] = {
+	{ Common::DE_DEU,   fixedTextDE },
+	{ Common::ES_ESP,   fixedTextES },
+	{ Common::EN_ANY,   fixedTextEN },
+	{ Common::FR_FRA,   fixedTextFR },
+	{ Common::UNK_LANG, fixedTextEN }
+};
+
+TattooFixedText::TattooFixedText(SherlockEngine *vm) : FixedText(vm) {
+	// Figure out which fixed texts to use
+	Common::Language curLanguage = _vm->getLanguage();
+
+	const FixedTextLanguageEntry *curLanguageEntry = fixedTextLanguages;
+
+	while (curLanguageEntry->language != Common::UNK_LANG) {
+		if (curLanguageEntry->language == curLanguage)
+			break; // found current language
+		curLanguageEntry++;
+	}
+	_curLanguageEntry = curLanguageEntry;
+}
+
+const char *TattooFixedText::getText(int fixedTextId) {
+	return _curLanguageEntry->fixedTextArray[fixedTextId];
+}
+
+const Common::String TattooFixedText::getActionMessage(FixedTextActionId actionId, int messageIndex) {
+	return Common::String();
+}
+
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_fixed_text.h b/engines/sherlock/tattoo/tattoo_fixed_text.h
new file mode 100644
index 0000000000..48d237db3c
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_fixed_text.h
@@ -0,0 +1,236 @@
+/* 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 SHERLOCK_TATTOO_FIXED_TEXT_H
+#define SHERLOCK_TATTOO_FIXED_TEXT_H
+
+#include "sherlock/fixed_text.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+enum FixedTextId {
+	kFixedText_Inv1,
+	kFixedText_InvDesc1,
+	kFixedText_Inv2,
+	kFixedText_InvDesc2,
+	kFixedText_Inv3,
+	kFixedText_InvDesc3,
+	kFixedText_Inv4,
+	kFixedText_InvDesc4,
+	kFixedText_Inv5,
+	kFixedText_InvDesc5,
+	kFixedText_Inv6,
+	kFixedText_InvDesc6,
+	kFixedText_Inv7,
+	kFixedText_InvDesc7,
+	kFixedText_Inv8,
+	kFixedText_InvDesc8,
+	kFixedText_Open,
+	kFixedText_Look,
+	kFixedText_Talk,
+	kFixedText_Use,
+	kFixedText_Journal,
+	kFixedText_Inventory,
+	kFixedText_Options,
+	kFixedText_Solve,
+	kFixedText_With,
+	kFixedText_NoEffect,
+	kFixedText_NothingToSay,
+	kFixedText_PickedUp,
+
+	kFixedText_Page,
+	kFixedText_CloseJournal,
+	kFixedText_SearchJournal,
+	kFixedText_SaveJournal,
+	kFixedText_AbortSearch,
+	kFixedText_SearchBackwards,
+	kFixedText_SearchForwards,
+	kFixedText_TextNotFound,
+
+	kFixedText_Holmes,
+	kFixedText_Jock,
+	kFixedText_Bull,
+	kFixedText_Round,
+	kFixedText_TurnTotal,
+	kFixedText_Dart,
+	kFixedText_ToStart,
+	kFixedText_HitAKey,
+	kFixedText_PressAKey,
+	kFixedText_Bullseye,
+	kFixedText_GameOver,
+	kFixedText_Busted,
+	kFixedText_Wins,
+	kFixedText_Scored,
+	kFixedText_Points,
+	kFixedText_Hit,
+	kFixedText_Double,
+	kFixedText_Triple,
+
+	kFixedText_Apply,
+	kFixedText_Water,
+	kFixedText_Heat,
+	kFixedText_LoadGame,
+	kFixedText_SaveGame,
+	kFixedText_Music,
+	kFixedText_SoundEffects,
+	kFixedText_Voices,
+	kFixedText_TextWindows,
+	kFixedText_TransparentMenus,
+	kFixedText_ChangeFont,
+	kFixedText_Off,
+	kFixedText_On,
+	kFixedText_Quit,
+	kFixedText_AreYouSureYou,
+	kFixedText_WishToQuit,
+	kFixedText_Yes,
+	kFixedText_No,
+	kFixedText_EnterPassword,
+	kFixedText_CorrectPassword,
+	// SH2: People names
+	kFixedText_People_SherlockHolmes,
+	kFixedText_People_DrWatson,
+	kFixedText_People_MrsHudson,
+	kFixedText_People_StanleyForbes,
+	kFixedText_People_MycroftHolmes,
+	kFixedText_People_Wiggins,
+	kFixedText_People_PoliceConstableBurns,
+	kFixedText_People_AugustusTrimble,
+	kFixedText_People_PoliceConstableDaley,
+	kFixedText_People_Matron,
+	kFixedText_People_SisterGrace,
+	kFixedText_People_PrestonMcCabe,
+	kFixedText_People_BobColleran,
+	kFixedText_People_JonasRigby,
+	kFixedText_People_PoliceConstableRoach,
+	kFixedText_People_JamesDewar,
+	kFixedText_People_SergeantJeremyDuncan,
+	kFixedText_People_InspectorGregson,
+	kFixedText_People_InspectorLestrade,
+	kFixedText_People_JesseNeedhem,
+	kFixedText_People_ArthurFleming,
+	kFixedText_People_MrThomasPratt,
+	kFixedText_People_MathildaTillieMason,
+	kFixedText_People_AdrianRussell,
+	kFixedText_People_EldridgeWhitney,
+	kFixedText_People_Hepplethwaite,
+	kFixedText_People_HoraceSilverbridge,
+	kFixedText_People_OldSherman,
+	kFixedText_People_MaxwellVerner,
+	kFixedText_People_MillicentRedding,
+	kFixedText_People_VirgilSilverbridge,
+	kFixedText_People_GeorgeOKeeffe,
+	kFixedText_People_LordDenysLawton,
+	kFixedText_People_Jenkins,
+	kFixedText_People_JockMahoney,
+	kFixedText_People_Bartender,
+	kFixedText_People_LadyCordeliaLockridge,
+	kFixedText_People_Pettigrew,
+	kFixedText_People_SirAveryFanshawe,
+	kFixedText_People_Hodgkins,
+	kFixedText_People_WilburBirdyHeywood,
+	kFixedText_People_JacobFarthington,
+	kFixedText_People_PhilipBledsoe,
+	kFixedText_People_SidneyFowler,
+	kFixedText_People_ProfessorTheodoreTotman,
+	kFixedText_People_RoseHinchem,
+	kFixedText_People_Tallboy,
+	kFixedText_People_EthlebertStitchRumsey,
+	kFixedText_People_CharlesFreedman,
+	kFixedText_People_NigelHemmings,
+	kFixedText_People_FairfaxCarter,
+	kFixedText_People_WilhelmII,
+	kFixedText_People_Wachthund,
+	kFixedText_People_JonathanWilson,
+	kFixedText_People_DavidLloydJones,
+	kFixedText_People_EdwardHargrove,
+	kFixedText_People_Misteray,
+	kFixedText_People_TheLascar,
+	kFixedText_People_Parrot,
+	kFixedText_People_VincentScarrett,
+	kFixedText_People_Alexandra,
+	kFixedText_People_QueenVictoria,
+	kFixedText_People_JohnBrown,
+	kFixedText_People_APatient1,
+	kFixedText_People_APatient2,
+	kFixedText_People_Patron,
+	kFixedText_People_QueenVictoria2,
+	kFixedText_People_PatientInWhite,
+	kFixedText_People_Lush,
+	kFixedText_People_Drunk,
+	kFixedText_People_Prostitute,
+	kFixedText_People_Mudlark,
+	kFixedText_People_Grinder,
+	kFixedText_People_Bouncer,
+	kFixedText_People_AgnesRatchet,
+	kFixedText_People_AloysiusRatchet,
+	kFixedText_People_RealEstateAgent,
+	kFixedText_People_CandyClerk,
+	kFixedText_People_Beadle,
+	kFixedText_People_Prussian,
+	kFixedText_People_MrsRowbottom,
+	kFixedText_People_MissLloydJones,
+	kFixedText_People_TavernPatron,
+	kFixedText_People_User,
+	kFixedText_People_Toby,
+	kFixedText_People_Stationer,
+	kFixedText_People_LawClerk,
+	kFixedText_People_MinistryClerk,
+	kFixedText_People_Bather,
+	kFixedText_People_Maid,
+	kFixedText_People_LadyFanshawe,
+	kFixedText_People_SidneyRatchet,
+	kFixedText_People_Boy,
+	kFixedText_People_Patron2,
+	kFixedText_People_ConstableBrit,
+	kFixedText_People_WagonDriver
+};
+
+struct FixedTextLanguageEntry {
+	Common::Language language;
+	const char *const *fixedTextArray;
+};
+
+class TattooFixedText: public FixedText {
+private:
+	const FixedTextLanguageEntry *_curLanguageEntry;
+public:
+	TattooFixedText(SherlockEngine *vm);
+	virtual ~TattooFixedText() {}
+
+	/**
+	 * Gets text
+	 */
+	virtual const char *getText(int fixedTextId);
+
+	/**
+	 * Get action message
+	 */
+	virtual const Common::String getActionMessage(FixedTextActionId actionId, int messageIndex);
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/tattoo_inventory.cpp b/engines/sherlock/tattoo/tattoo_inventory.cpp
new file mode 100644
index 0000000000..14e79e9f33
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_inventory.cpp
@@ -0,0 +1,63 @@
+/* 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 "sherlock/tattoo/tattoo_inventory.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+TattooInventory::TattooInventory(SherlockEngine *vm) : Inventory(vm) {
+	_invShapes.resize(8);
+}
+
+TattooInventory::~TattooInventory() {
+}
+
+void TattooInventory::loadInv() {
+	// Exit if the inventory names are already loaded
+	if (_names.size() > 0)
+		return;
+
+	// Load the inventory names
+	Common::SeekableReadStream *stream = _vm->_res->load("invent.txt");
+
+	int count = stream->readByte();
+
+	for (int idx = 0; idx < count; ++idx) {
+		Common::String name;
+		char c;
+		while ((c = stream->readByte()) != 0)
+			name += c;
+
+		_names.push_back(name);
+	}
+
+	delete stream;
+
+	loadGraphics();
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_inventory.h b/engines/sherlock/tattoo/tattoo_inventory.h
new file mode 100644
index 0000000000..a18324b785
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_inventory.h
@@ -0,0 +1,48 @@
+/* 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 SHERLOCK_TATTOO_INVENTORY_H
+#define SHERLOCK_TATTOO_INVENTORY_H
+
+#include "sherlock/inventory.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+class TattooInventory : public Inventory {
+public:
+	TattooInventory(SherlockEngine *vm);
+	~TattooInventory();
+
+	/**
+	 * Load the list of names the inventory items correspond to, if not already loaded,
+	 * and then calls loadGraphics to load the associated graphics
+	 */
+	virtual void loadInv();	
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/tattoo_journal.cpp b/engines/sherlock/tattoo/tattoo_journal.cpp
new file mode 100644
index 0000000000..e836cca620
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_journal.cpp
@@ -0,0 +1,954 @@
+/* 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 "sherlock/tattoo/tattoo_journal.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+#define JOURNAL_BAR_WIDTH	450
+
+TattooJournal::TattooJournal(SherlockEngine *vm) : Journal(vm) {
+	_journalImages = nullptr;
+	_selector = _oldSelector = JH_NONE;
+	_wait = false;
+	_exitJournal = false;
+	_scrollingTimer = 0;
+	_savedIndex = _savedSub = _savedPage = 0;
+
+	loadLocations();
+}
+
+void TattooJournal::show() {
+	Events &events = *_vm->_events;
+	Resources &res = *_vm->_res;
+	Screen &screen = *_vm->_screen;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	byte palette[PALETTE_SIZE];
+	
+	Common::Point oldScroll = screen._currentScroll;
+	screen._currentScroll = Common::Point(0, 0);
+
+	// Load journal images
+	_journalImages = new ImageFile("journal.vgs");
+
+	// Load palette
+	Common::SeekableReadStream *stream = res.load("journal.pal");
+	stream->read(palette, PALETTE_SIZE);
+	ui.setupBGArea(palette);
+	screen.translatePalette(palette);
+	delete stream;
+
+	// Set screen to black, and set background
+	screen._backBuffer1.blitFrom((*_journalImages)[0], Common::Point(0, 0));
+	screen.empty();
+	screen.setPalette(palette);
+
+	if (_journal.empty()) {
+		_up = _down = false;
+	} else {
+		drawJournal(0, 0);
+	}
+	drawControls(0);
+	screen.slamRect(Common::Rect(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+
+	_exitJournal = false;
+	_scrollingTimer = 0;
+
+	do {
+		events.pollEventsAndWait();
+		events.setButtonState();
+		_wait = true;
+
+		handleKeyboardEvents();
+		highlightJournalControls(true);
+		
+		handleButtons();
+
+		if (_wait)
+			events.wait(2);
+		
+	} while (!_vm->shouldQuit() && !_exitJournal);
+
+	// Clear events
+	events.clearEvents();
+
+	// Free the images
+	delete _journalImages;
+	_journalImages = nullptr;
+
+	// Reset back to whatever scroll was active for the screen
+	screen._currentScroll = oldScroll;
+}
+
+void TattooJournal::handleKeyboardEvents() {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	Common::Point mousePos = events.mousePos();
+
+	if (!events.kbHit())
+		return;
+
+	Common::KeyState keyState = events.getKey();
+
+	if (keyState.keycode == Common::KEYCODE_TAB && (keyState.flags & Common::KBD_SHIFT)) {
+		// Shift tab
+		Common::Rect r(JOURNAL_BAR_WIDTH, BUTTON_SIZE + screen.fontHeight() + 13);
+		r.moveTo((SHERLOCK_SCREEN_WIDTH - r.width()) / 2, SHERLOCK_SCREEN_HEIGHT - r.height());
+
+		// See if mouse is over any of the journal controls
+		_selector = JH_NONE;
+		if (Common::Rect(r.left + 3, r.top + 3, r.right - 3, r.top + screen.fontHeight() + 4).contains(mousePos))
+			_selector = (mousePos.x - r.left) / (r.width() / 3);
+
+		// If the mouse is not over an option, move the mouse to that it points to the first option
+		if (_selector == JH_NONE) {
+			events.warpMouse(Common::Point(r.left + r.width() / 3 - 10, r.top + screen.fontHeight() + 2));
+		} else {
+			if (_selector == JH_CLOSE)
+				_selector = JH_PRINT;
+			else
+				--_selector;
+
+			events.warpMouse(Common::Point(r.left + (r.width() / 3) * (_selector + 1) - 10, mousePos.y));
+		}
+
+	} else if (keyState.keycode == Common::KEYCODE_PAGEUP) {
+		// See if they have Shift held down to go forward 10 pages
+		if (keyState.flags & Common::KBD_SHIFT) {
+			if (_page > 1) {
+				// Scroll Up 10 pages if possible
+				if (_page < 11)
+					drawJournal(1, (_page - 1) * LINES_PER_PAGE);
+				else
+					drawJournal(1, 10 * LINES_PER_PAGE);
+
+				drawScrollBar();
+				screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+				_wait = false;
+			}
+		} else {
+			if (_page > 1) {
+				// Scroll Up 1 page
+				drawJournal(1, LINES_PER_PAGE);
+				drawScrollBar();
+				drawJournal(0, 0);
+				screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+				_wait = false;
+			}
+		}
+
+	} else if (keyState.keycode == Common::KEYCODE_PAGEDOWN) {
+		if (keyState.flags & Common::KBD_SHIFT) {
+			if (_down) {
+				// Scroll down 10 Pages
+				if (_page + 10 > _maxPage)
+					drawJournal(2, (_maxPage - _page) * LINES_PER_PAGE);
+				else
+					drawJournal(2, 10 * LINES_PER_PAGE);
+				drawScrollBar();
+				screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+				_wait = false;
+			}
+		} else {
+			if (_down) {
+				// Scroll down 1 page
+				drawJournal(2, LINES_PER_PAGE);
+				drawScrollBar();
+				drawJournal(0, 0);
+				screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+				_wait = false;
+			}
+		}
+
+	} else if (keyState.keycode == Common::KEYCODE_HOME) {
+		// Scroll to start of journal
+		if (_page > 1) {
+			// Go to the beginning of the journal
+			_index = _sub = _up = _down = 0;
+			_page = 1;
+
+			drawFrame();
+			drawJournal(0, 0);
+
+			drawScrollBar();
+			screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+			_wait = false;
+		}
+
+	} else if (keyState.keycode == Common::KEYCODE_END) {
+		// Scroll to end of journal
+		if (_down) {
+			// Go to the end of the journal
+			drawJournal(2, 100000);
+			drawScrollBar();
+			screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+			_wait = false;
+		}
+	} else if (keyState.keycode == Common::KEYCODE_RETURN) {
+		events._pressed = false;
+		events._released = true;
+		events._oldButtons = 0;
+	} else if (keyState.keycode == Common::KEYCODE_ESCAPE) {
+		_exitJournal = true;
+	} else if (keyState.keycode == Common::KEYCODE_TAB) {
+		Common::Rect r(JOURNAL_BAR_WIDTH, BUTTON_SIZE + screen.fontHeight() + 13);
+		r.moveTo((SHERLOCK_SCREEN_WIDTH - r.width()) / 2, SHERLOCK_SCENE_HEIGHT - r.height());
+
+		// See if the mouse is over any of the journal controls
+		_selector = JH_NONE;
+		if (Common::Rect(r.left + 3, r.top + 3, r.right - 3, r.top + screen.fontHeight() + 4).contains(mousePos))
+			_selector = (mousePos.x - r.left) / (r.width() / 3);
+
+		// If the mouse is not over any of the options, move the mouse so that it points to the first option
+		if (_selector == JH_NONE) {
+			events.warpMouse(Common::Point(r.left + r.width() / 3 - 10, r.top + screen.fontHeight() + 2));
+		} else {
+			if (_selector == JH_PRINT)
+				_selector = JH_NONE;
+			else
+				++_selector;
+
+			events.warpMouse(Common::Point(r.left + (r.width() / 3) * (_selector + 1) - 10, mousePos.y));
+		}
+	}
+}
+
+void TattooJournal::handleButtons() {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	uint32 frameCounter = events.getFrameCounter();
+	Common::Point mousePos = events.mousePos();
+
+	// If they're dragging the scrollbar thumb, keep it selected whilst the button is being held
+	if ((events._pressed || events._released) && _selector == JH_THUMBNAIL) {
+		// FIgure out the left of the scrollbar scroll area and paging data
+		const int scrollingWidth = JOURNAL_BAR_WIDTH - BUTTON_SIZE * 2 - 6;
+		const int scrollingLeft = (SHERLOCK_SCREEN_WIDTH - JOURNAL_BAR_WIDTH) / 2 + BUTTON_SIZE + 3;
+		const int numPages = (_maxPage + LINES_PER_PAGE - 1) / LINES_PER_PAGE;
+		if (numPages == 1)
+			return;
+
+		const int barWidth = CLIP(scrollingWidth / numPages, BUTTON_SIZE, JOURNAL_BAR_WIDTH - BUTTON_SIZE * 2 - 6);
+		const int scrollOffset = mousePos.x - scrollingLeft;
+		const int page = scrollOffset * FIXED_INT_MULTIPLIER / ((scrollingWidth - barWidth) * (FIXED_INT_MULTIPLIER / (numPages - 1))) + 1;
+
+		if (page != _page) {
+			if (page < _page)
+				drawJournal(1, (_page - page) * LINES_PER_PAGE);
+			else
+				drawJournal(2, (page - _page) * LINES_PER_PAGE);
+			drawScrollBar();
+			screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+			_wait = false;
+		}
+	} else if (_selector != JH_NONE && events._pressed) {
+		if (frameCounter >= _scrollingTimer) {
+			// Set next scrolling time
+			_scrollingTimer = frameCounter + 6;
+			
+			// Handle different scrolling actions
+			switch (_selector) {
+			case JH_SCROLL_LEFT:
+				// Scroll left (1 page back)
+				if (_page > 1) {
+					// Scroll Up
+					drawJournal(1, LINES_PER_PAGE);
+					drawScrollBar();
+					screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+					_wait = false;
+				}
+				break;
+
+			case JH_PAGE_LEFT:
+				// Page left (10 pages back)
+				if (_page > 1) {
+					// Scroll Up 10 Pages if possible
+					if (_page < 11)
+						drawJournal(1, (_page - 1) * LINES_PER_PAGE);
+					else
+						drawJournal(1, 10 * LINES_PER_PAGE);
+					drawScrollBar();
+					drawJournal(0, 0);
+					screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+					_wait = false;
+				}
+				break;
+
+			case JH_PAGE_RIGHT:
+				// Page right (10 pages ahead)
+				if (_down) {
+					// Scroll Down 10 Pages
+					if (_page + 10 > _maxPage)
+						drawJournal(2, (_maxPage - _page) * LINES_PER_PAGE);
+					else
+						drawJournal(2, 10 * LINES_PER_PAGE);
+					drawScrollBar();
+					screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+					_wait = false;
+				}
+				break;
+
+			case JH_SCROLL_RIGHT:
+				// Scroll right (1 Page Ahead)
+				if (_down) {
+					// Scroll Down
+					drawJournal(2, LINES_PER_PAGE);
+					drawScrollBar();
+					screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+					_wait = false;
+				}
+				break;
+
+			default:
+				break;
+			}
+		}
+	}
+
+	if (events._released || events._rightReleased) {
+		_scrollingTimer = 0;
+
+		switch (_selector) {
+		case JH_CLOSE:
+			_exitJournal = true;
+			break;
+
+		case JH_SEARCH: {
+			// Search Journal
+			disableControls();
+
+			bool notFound = false;
+
+			do {
+				int dir;
+				if ((dir = getFindName(notFound)) != 0) {
+					_savedIndex = _index;
+					_savedSub = _sub;
+					_savedPage = _page;
+					
+					bool drawResult = drawJournal(dir + 2, 1000 * LINES_PER_PAGE);
+					if (!drawResult) {
+						_index = _savedIndex;
+						_sub = _savedSub;
+						_page = _savedPage;
+						
+						drawFrame();
+						drawJournal(0, 0);
+						notFound = true;
+					}
+
+					highlightJournalControls(false);
+					screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+					if (drawResult)
+						break;
+				} else {
+					break;
+				}
+			} while (!_vm->shouldQuit());
+			break;
+		}
+
+		case JH_PRINT:
+			// Print Journal - not implemented in ScummVM
+			break;
+
+		default:
+			break;
+		}
+	}
+}
+
+void TattooJournal::loadLocations() {
+	Resources &res = *_vm->_res;
+
+	_directory.clear();
+	_locations.clear();
+
+	Common::SeekableReadStream *dir = res.load("talk.lib");
+	dir->skip(4);		// Skip header
+
+	// Get the numer of entries
+	_directory.resize(dir->readUint16LE());
+	dir->seek((_directory.size() + 1) * 8, SEEK_CUR);
+
+	// Read in each entry
+	char buffer[17];
+	for (uint idx = 0; idx < _directory.size(); ++idx) {
+		dir->read(buffer, 17);
+		buffer[16] = '\0';
+
+		_directory[idx] = Common::String(buffer);
+	}
+
+	delete dir;
+
+	// Load in the locations stored in journal.txt
+	Common::SeekableReadStream *loc = res.load("journal.txt");
+
+	// Initialize locations
+	_locations.resize(100);
+	for (int idx = 0; idx < 100; ++idx)
+		_locations[idx] = "No Description";
+
+	while (loc->pos() < loc->size()) {
+		// In Rose Tattoo, each location line starts with the location
+		// number, followed by a dot, some spaces and its description
+		// in quotes
+		Common::String line = loc->readLine();
+		Common::String locNumStr;
+		int locNum = 0;
+		int i = 0;
+		Common::String locDesc;
+
+		// Get the location
+		while (Common::isDigit(line[i])) {
+			locNumStr += line[i];
+			i++;
+		}
+		locNum = atoi(locNumStr.c_str()) - 1;
+
+		// Skip the dot, spaces and initial quotation mark
+		while (line[i] == ' ' || line[i] == '.' || line[i] == '\"')
+			i++;
+
+		do {
+			locDesc += line[i];
+			i++;
+		} while (line[i] != '\"');
+
+		_locations[locNum] = locDesc;
+	}
+
+	delete loc;
+}
+
+void TattooJournal::drawFrame() {
+	Screen &screen = *_vm->_screen;
+
+	screen._backBuffer1.blitFrom((*_journalImages)[0], Common::Point(0, 0));
+	drawControls(0);
+
+}
+
+void TattooJournal::drawControls(int mode) {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Screen &screen = *_vm->_screen;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	ImageFile &images = *ui._interfaceImages;
+
+	Common::Rect r(JOURNAL_BAR_WIDTH, !mode ? (BUTTON_SIZE + screen.fontHeight() + 13) :
+		(screen.fontHeight() + 4) * 2 + 9);
+	r.moveTo((SHERLOCK_SCREEN_WIDTH - r.width()) / 2, !mode ? (SHERLOCK_SCREEN_HEIGHT - r.height()) :
+		(SHERLOCK_SCREEN_HEIGHT - r.height()) / 2);
+
+	Common::Rect inner = r;
+	inner.grow(-3);
+
+	if (vm._transparentMenus)
+		ui.makeBGArea(inner);
+	else
+		screen._backBuffer1.fillRect(inner, MENU_BACKGROUND);
+
+	// Draw the four corners of the info box
+	screen._backBuffer1.transBlitFrom(images[0], Common::Point(r.left, r.top));
+	screen._backBuffer1.transBlitFrom(images[1], Common::Point(r.right - images[1]._width, r.top));
+	screen._backBuffer1.transBlitFrom(images[1], Common::Point(r.left, r.bottom - images[1]._height));
+	screen._backBuffer1.transBlitFrom(images[1], Common::Point(r.right - images[1]._width, r.bottom - images[1]._height));
+
+	// Draw the top of the info box
+	screen._backBuffer1.hLine(r.left + images[0]._width, r.top, r.right - images[0]._height, INFO_TOP);
+	screen._backBuffer1.hLine(r.left + images[0]._width, r.top + 1, r.right - images[0]._height, INFO_MIDDLE);
+	screen._backBuffer1.hLine(r.left + images[0]._width, r.top + 2, r.right - images[0]._height, INFO_BOTTOM);
+
+	// Draw the bottom of the info box
+	screen._backBuffer1.hLine(r.left + images[0]._width, r.bottom - 3, r.right - images[0]._height, INFO_TOP);
+	screen._backBuffer1.hLine(r.left + images[0]._width, r.bottom - 2, r.right - images[0]._height, INFO_MIDDLE);
+	screen._backBuffer1.hLine(r.left + images[0]._width, r.bottom - 1, r.right - images[0]._height, INFO_BOTTOM);
+
+	// Draw the left side of the info box
+	screen._backBuffer1.vLine(r.left, r.top + images[0]._height, r.bottom - images[2]._height, INFO_TOP);
+	screen._backBuffer1.vLine(r.left + 1, r.top + images[0]._height, r.bottom - images[2]._height, INFO_MIDDLE);
+	screen._backBuffer1.vLine(r.left + 2, r.top + images[0]._height, r.bottom - images[2]._height, INFO_BOTTOM);
+
+	// Draw the right side of the info box
+	screen._backBuffer1.vLine(r.right - 3, r.top + images[0]._height, r.bottom - images[2]._height, INFO_TOP);
+	screen._backBuffer1.vLine(r.right - 2, r.top + images[0]._height, r.bottom - images[2]._height, INFO_MIDDLE);
+	screen._backBuffer1.vLine(r.right - 1, r.top + images[0]._height, r.bottom - images[2]._height, INFO_BOTTOM);
+
+	// Draw the sides of the separator bar above the scroll bar
+	int yp = r.top + screen.fontHeight() + 7;
+	screen._backBuffer1.transBlitFrom(images[4], Common::Point(r.left, yp - 1));
+	screen._backBuffer1.transBlitFrom(images[5], Common::Point(r.right - images[5]._width, yp - 1));
+
+	// Draw the bar above the scroll bar
+	screen._backBuffer1.hLine(r.left + images[4]._width, yp, r.right - images[5]._width, INFO_TOP);
+	screen._backBuffer1.hLine(r.left + images[4]._width, yp + 1, r.right - images[5]._width, INFO_MIDDLE);
+	screen._backBuffer1.hLine(r.left + images[4]._width, yp + 2, r.right - images[5]._width, INFO_BOTTOM);
+
+	if (mode != 2) {
+		// Draw the Bars separating the Journal Commands
+		int xp = r.right / 3;
+		for (int idx = 0; idx < 2; ++idx) {
+			screen._backBuffer1.transBlitFrom(images[6], Common::Point(xp - 2, r.top + 1));
+			screen._backBuffer1.transBlitFrom(images[7], Common::Point(xp - 2, yp - 1));
+
+			screen._backBuffer1.hLine(xp - 1, r.top + 4, yp - 2, INFO_TOP);
+			screen._backBuffer1.hLine(xp, r.top + 4, yp - 2, INFO_MIDDLE);
+			screen._backBuffer1.hLine(xp + 1, r.top + 4, yp - 2, INFO_BOTTOM);
+			xp = r.right / 3 * 2;
+		}
+	}
+
+	int savedSelector = _oldSelector;
+	_oldSelector = 100;
+
+	switch (mode) {
+	case 0: 
+		highlightJournalControls(false);
+		break;
+	case 1:
+		highlightSearchControls(false);
+		break;
+	default:
+		break;
+	}
+	
+	_oldSelector = savedSelector;
+}
+
+void TattooJournal::highlightJournalControls(bool slamIt) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	Common::Point mousePos = events.mousePos();
+	Common::Rect r(JOURNAL_BAR_WIDTH, BUTTON_SIZE + screen.fontHeight() + 13);
+	r.moveTo((SHERLOCK_SCREEN_WIDTH - r.width()) / 2, SHERLOCK_SCREEN_HEIGHT - r.height());
+	
+	if ((events._pressed || events._released) && _selector == JH_THUMBNAIL) {
+		if (events._released)
+			_selector = JH_NONE;
+	} else {
+		// Calculate the Scroll Position Bar
+		int numPages = (_maxPage + LINES_PER_PAGE - 1) / LINES_PER_PAGE;
+		int barWidth = (r.width() - BUTTON_SIZE * 2 - 6) / numPages;
+		barWidth = CLIP(barWidth, BUTTON_SIZE, r.width() - BUTTON_SIZE * 2 - 6);
+
+		int barX = (numPages <= 1) ? r.left + 3 + BUTTON_SIZE : (r.width() - BUTTON_SIZE * 2 - 6 - barWidth)
+			* FIXED_INT_MULTIPLIER / (numPages - 1) * (_page - 1) / FIXED_INT_MULTIPLIER + r.left + 3 + BUTTON_SIZE;
+
+		// See if the mouse is over any of the Journal Controls
+		Common::Rect bounds(r.left, r.top, r.right - 3, r.top + screen.fontHeight() + 7);
+		_selector = JH_NONE;
+		if (bounds.contains(mousePos))
+			_selector = (mousePos.x - r.left) / (r.width() / 3);
+	
+		else if (events._pressed && mousePos.y >= (r.top + screen.fontHeight() + 10)
+				&& mousePos.y < (r.top + screen.fontHeight() + 10 + BUTTON_SIZE)) {
+			if (mousePos.x >= r.left && mousePos.x < (r.left + BUTTON_SIZE))
+				// Press on the Scroll Left button
+				_selector = JH_SCROLL_LEFT;
+			else if (mousePos.x >= (r.left + BUTTON_SIZE + 3) && mousePos.x < barX)
+				// Press on area to the left of the thumb, for scrolling back 10 pages
+				_selector = JH_PAGE_LEFT;
+			else if (mousePos.x >= (barX + barWidth) && mousePos.x < (r.right - BUTTON_SIZE - 3))
+				// Press on area to the right of the thumb, for scrolling forward 10 pages
+				_selector = JH_PAGE_RIGHT;
+			else if (mousePos.x >= (r.right - BUTTON_SIZE) && mousePos.x < r.right)
+				// Press of the Scroll Right button
+				_selector = JH_SCROLL_RIGHT;
+			else if (mousePos.x >= barX && mousePos.x < (barX + barWidth))
+				// Mouse on thumbnail
+				_selector = JH_THUMBNAIL;
+		}
+	}
+
+	// See if the Search was selected, but is not available
+	if (_journal.empty() && (_selector == JH_SEARCH || _selector == JH_PRINT))
+		_selector = JH_NONE;
+
+	if (_selector == JH_PAGE_LEFT && _oldSelector == JH_PAGE_RIGHT)
+		_selector = JH_PAGE_RIGHT;
+	else if (_selector == JH_PAGE_RIGHT && _oldSelector == JH_PAGE_LEFT)
+		_selector = JH_PAGE_LEFT;
+
+	// See if they're pointing at a different control
+	if (_selector != _oldSelector) {
+		// Print the Journal commands
+		int xp = r.left + r.width() / 6;
+		byte color = (_selector == JH_CLOSE) ? COMMAND_HIGHLIGHTED : INFO_TOP;
+
+		screen.gPrint(Common::Point(xp - screen.stringWidth(FIXED(CloseJournal)) / 2, r.top + 5),
+			color, "%s", FIXED(CloseJournal));
+		xp += r.width() / 3;
+
+		if (!_journal.empty())
+			color = (_selector == JH_SEARCH) ? COMMAND_HIGHLIGHTED : INFO_TOP;
+		else
+			color = INFO_BOTTOM;
+		screen.gPrint(Common::Point(xp - screen.stringWidth(FIXED(SearchJournal)) / 2, r.top + 5),
+			color, "%s", FIXED(SearchJournal));
+		xp += r.width() / 3;
+
+		color = INFO_BOTTOM;
+		screen.gPrint(Common::Point(xp - screen.stringWidth(FIXED(SaveJournal)) / 2, r.top + 5), 
+			color, "%s", FIXED(SaveJournal));
+
+		// Draw the horizontal scrollbar
+		drawScrollBar();
+
+		if (slamIt)
+			screen.slamRect(r);
+
+		_oldSelector = _selector;
+	}
+}
+
+void TattooJournal::highlightSearchControls(bool slamIt) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	Common::Point mousePos = events.mousePos();
+	Common::Rect r(JOURNAL_BAR_WIDTH, (screen.fontHeight() + 4) * 2 + 9);
+	r.moveTo((SHERLOCK_SCREEN_WIDTH - r.width()) / 2, (SHERLOCK_SCREEN_HEIGHT - r.height()) / 2);
+	const char *SEARCH_COMMANDS[3] = { FIXED(AbortSearch), FIXED(SearchBackwards), FIXED(SearchForwards) };
+
+	// See if the mouse is over any of the Journal Controls
+	_selector = JH_NONE;
+	if (Common::Rect(r.left + 3, r.top + 3, r.right - 3, r.top + 7 + screen.fontHeight()).contains(mousePos))
+		_selector = (mousePos.x - r.left) / (r.width() / 3);
+
+	// See if they're pointing at a different control
+	if (_selector != _oldSelector) {
+		// Print the search commands
+		int xp = r.left + r.width() / 6;
+
+		for (int idx = 0; idx < 3; ++idx) {
+			byte color = (_selector == idx) ? COMMAND_HIGHLIGHTED : INFO_TOP;
+			screen.gPrint(Common::Point(xp - screen.stringWidth(SEARCH_COMMANDS[idx]) / 2,
+				r.top + 5), color, "%s", SEARCH_COMMANDS[idx]);
+			xp += r.width() / 3;
+		}
+
+		if (slamIt)
+			screen.slamRect(r);
+
+		_oldSelector = _selector;
+	}
+}
+
+void TattooJournal::drawScrollBar() {
+	Screen &screen = *_vm->_screen;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	bool raised;
+	byte color;
+
+	Common::Rect r(JOURNAL_BAR_WIDTH, BUTTON_SIZE + screen.fontHeight() + 13);
+	r.moveTo((SHERLOCK_SCREEN_WIDTH - r.width()) / 2, SHERLOCK_SCREEN_HEIGHT - r.height());
+
+	// Calculate the Scroll Position Bar
+	int numPages = (_maxPage + LINES_PER_PAGE - 1) / LINES_PER_PAGE;
+	int barWidth = (r.width() - BUTTON_SIZE * 2 - 6) / numPages;
+	barWidth = CLIP(barWidth, BUTTON_SIZE, r.width() - BUTTON_SIZE * 2 - 6);
+	int barX;
+	if (numPages <= 1) {
+		barX = r.left + 3 + BUTTON_SIZE;
+	} else {
+		barX = (r.width() - BUTTON_SIZE * 2 - 6 - barWidth) * FIXED_INT_MULTIPLIER / (numPages - 1) *
+			(_page - 1) / FIXED_INT_MULTIPLIER + r.left + 3 + BUTTON_SIZE;
+		if (barX + BUTTON_SIZE > r.left + r.width() - BUTTON_SIZE - 3)
+			barX = r.right - BUTTON_SIZE * 2 - 3;
+	}
+
+	// Draw the scroll bar here
+	// Draw the Scroll Left button
+	raised = _selector != JH_SCROLL_LEFT;
+	screen._backBuffer1.fillRect(Common::Rect(r.left, r.top + screen.fontHeight() + 12, r.left + BUTTON_SIZE,
+		r.top + screen.fontHeight() + BUTTON_SIZE + 9), INFO_MIDDLE);
+	ui.drawDialogRect(screen._backBuffer1, Common::Rect(r.left + 3, r.top + screen.fontHeight() + 10, r.left + 3 + BUTTON_SIZE, 
+		r.top + screen.fontHeight() + 10 + BUTTON_SIZE), raised);
+
+	color = (_page > 1) ? INFO_BOTTOM + 2 : INFO_BOTTOM;
+	screen._backBuffer1.vLine(r.left + 1 + BUTTON_SIZE / 2, r.top + screen.fontHeight() + 10 + BUTTON_SIZE / 2,
+		r.top + screen.fontHeight() + 10 + BUTTON_SIZE / 2, color);
+	screen._backBuffer1.vLine(r.left + 2 + BUTTON_SIZE / 2, r.top + screen.fontHeight() + 9 + BUTTON_SIZE / 2,
+		r.top + screen.fontHeight() + 11 + BUTTON_SIZE / 2, color);
+	screen._backBuffer1.vLine(r.left + 3 + BUTTON_SIZE / 2, r.top + screen.fontHeight() + 8 + BUTTON_SIZE / 2,
+		r.top + screen.fontHeight() + 12 + BUTTON_SIZE / 2, color);
+	screen._backBuffer1.vLine(r.left + 4 + BUTTON_SIZE / 2, r.top + screen.fontHeight() + 7 + BUTTON_SIZE / 2,
+		r.top + screen.fontHeight() + 13 + BUTTON_SIZE / 2, color);
+
+	// Draw the Scroll Right button
+	raised = _selector != JH_SCROLL_RIGHT;
+	screen._backBuffer1.fillRect(Common::Rect(r.right - BUTTON_SIZE - 1, r.top + screen.fontHeight() + 12, 
+		r.right - 5, r.top + screen.fontHeight() + BUTTON_SIZE + 9), INFO_MIDDLE);
+	ui.drawDialogRect(screen._backBuffer1, Common::Rect(r.right - BUTTON_SIZE - 3, r.top + screen.fontHeight() + 10, r.right - 3,
+		r.top + screen.fontHeight() + BUTTON_SIZE + 9), raised);
+
+	color = _down ? INFO_BOTTOM + 2 : INFO_BOTTOM;
+	screen._backBuffer1.vLine(r.right - 1 - BUTTON_SIZE + BUTTON_SIZE / 2, r.top + screen.fontHeight() + 10 + BUTTON_SIZE / 2, 
+		r.top + screen.fontHeight() + 10 + BUTTON_SIZE / 2, color);
+	screen._backBuffer1.vLine(r.right - 2 - BUTTON_SIZE + BUTTON_SIZE / 2, r.top + screen.fontHeight() + 9 + BUTTON_SIZE / 2, 
+		r.top + screen.fontHeight() + 11 + BUTTON_SIZE / 2, color);
+	screen._backBuffer1.vLine(r.right - 3 - BUTTON_SIZE + BUTTON_SIZE / 2, r.top + screen.fontHeight() + 8 + BUTTON_SIZE / 2,
+		r.top + screen.fontHeight() + 12 + BUTTON_SIZE / 2, color);
+	screen._backBuffer1.vLine(r.right - 4 - BUTTON_SIZE + BUTTON_SIZE / 2, r.top + screen.fontHeight() + 7 + BUTTON_SIZE / 2,
+		r.top + screen.fontHeight() + 13 + BUTTON_SIZE / 2, color);
+
+	// Draw the scroll bar
+	screen._backBuffer1.fillRect(Common::Rect(barX + 2, r.top + screen.fontHeight() + 12, barX + barWidth - 3,
+		r.top + screen.fontHeight() + BUTTON_SIZE + 9), INFO_MIDDLE);
+	ui.drawDialogRect(screen._backBuffer1, Common::Rect(barX, r.top + screen.fontHeight() + 10, barX + barWidth,
+		r.top + screen.fontHeight() + 10 + BUTTON_SIZE), true);
+}
+
+void TattooJournal::disableControls() {
+	Screen &screen = *_vm->_screen;
+	Common::Rect r(JOURNAL_BAR_WIDTH, BUTTON_SIZE + screen.fontHeight() + 13);
+	r.moveTo((SHERLOCK_SCREEN_WIDTH - r.width()) / 2, SHERLOCK_SCREEN_HEIGHT - r.height());
+	const char *JOURNAL_COMMANDS[3] = { FIXED(CloseJournal), FIXED(SearchJournal), FIXED(SaveJournal) };
+
+	// Print the Journal commands
+	int xp = r.left + r.width() / 6;
+	for (int idx = 0; idx < 2; ++idx) {
+		screen.gPrint(Common::Point(xp - screen.stringWidth(JOURNAL_COMMANDS[idx]) / 2, r.top + 5),
+			INFO_BOTTOM, "%s", JOURNAL_COMMANDS[idx]);
+
+		xp += r.width() / 3;
+	}
+
+	screen.slamRect(r);
+}
+
+int TattooJournal::getFindName(bool printError) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	int result = 0;
+	int done = 0;
+	Common::String name;
+	int cursorX, cursorY;
+	bool blinkFlag = false;
+	int blinkCountdown = 1;
+	enum SearchButtons { SB_CANCEL = 0, SB_BACKWARDS = 1, SB_FORWARDS = 2 };
+
+	Common::Rect r(JOURNAL_BAR_WIDTH, (screen.fontHeight() + 4) * 2 + 9);
+	r.moveTo((SHERLOCK_SCREEN_WIDTH - r.width()) / 2, (SHERLOCK_SCREEN_HEIGHT - r.height()) / 2);
+
+	// Set the cursors Y position
+	cursorY = r.top + screen.fontHeight() + 12;
+
+	drawControls(1);
+	disableControls();
+	
+	// Backup the area under the text entry
+	Surface bgSurface(r.width() - 6, screen.fontHeight());
+	bgSurface.blitFrom(screen._backBuffer1, Common::Point(0, 0), Common::Rect(r.left + 3, cursorY, 
+		r.right - 3, cursorY + screen.fontHeight()));
+
+	if (printError) {
+		screen.gPrint(Common::Point(r.left + (r.width() - screen.stringWidth(FIXED(TextNotFound))) / 2, cursorY), 
+			INFO_TOP, "%s", FIXED(TextNotFound));
+	} else {
+		// If there was a name already entered, copy it to name and display it
+		if (!_find.empty()) {
+			screen.gPrint(Common::Point(r.left + screen.widestChar() + 3, cursorY), COMMAND_HIGHLIGHTED, "%s", _find.c_str());
+			name = _find;
+		}
+	}
+
+	screen.slamRect(r);
+
+	if (printError) {
+		// Pause to allow error to be shown
+		int timer = 0;
+
+		do {
+			events.pollEvents();
+			events.setButtonState();
+
+			++timer;
+			events.wait(2);
+		} while (!_vm->shouldQuit() && !events.kbHit() && !events._released && !events._rightReleased && timer < 40);
+
+		events.clearEvents();
+
+		// Restore the text background
+		screen._backBuffer1.blitFrom(bgSurface, Common::Point(r.left, cursorY));
+
+		// If there was a name already entered, copy it to name and display it
+		if (!_find.empty()) {
+			screen.gPrint(Common::Point(r.left + screen.widestChar() + 3, cursorY), COMMAND_HIGHLIGHTED, "%s", _find.c_str());
+			name = _find;
+		}
+
+		screen.slamArea(r.left + 3, cursorY, r.width() - 6, screen.fontHeight());
+	}
+
+	// Set the cursors X position
+	cursorX = r.left + screen.widestChar() + 3 + screen.stringWidth(name);
+
+	do {
+		events._released = events._rightReleased = false;
+
+		while (!events.kbHit() && !events._released && !events._rightReleased) {
+			if (talk._talkToAbort)
+				return 0;
+
+			// See if a key or a mouse button is pressed
+			events.pollEventsAndWait();
+			events.setButtonState();
+
+			// Handle blinking cursor
+			if (--blinkCountdown == 0) {
+				blinkCountdown = 3;
+				blinkFlag = !blinkFlag;
+				if (blinkFlag) {
+					// Draw cursor
+					screen._backBuffer1.fillRect(Common::Rect(cursorX, cursorY, cursorX + 7, cursorY + 8), COMMAND_HIGHLIGHTED);
+					screen.slamArea(cursorX, cursorY, 8, 9);
+				}
+				else {
+					// Erase cursor by restoring background and writing current text
+					screen._backBuffer1.blitFrom(bgSurface, Common::Point(r.left + 3, cursorY));
+					screen.gPrint(Common::Point(r.left + screen.widestChar() + 3, cursorY), COMMAND_HIGHLIGHTED, "%s", name.c_str());
+					screen.slamArea(r.left + 3, cursorY, r.width() - 3, screen.fontHeight());
+				}
+			}
+
+			highlightSearchControls(true);
+
+			events.wait(2);
+			if (_vm->shouldQuit())
+				return 0;
+		}
+
+		if (events.kbHit()) {
+			Common::KeyState keyState = events.getKey();
+			Common::Point mousePos = events.mousePos();
+
+			if (keyState.keycode == Common::KEYCODE_BACKSPACE && !name.empty()) {
+				cursorX -= screen.charWidth(name.lastChar());
+				name.deleteLastChar();
+			}
+
+			if (keyState.keycode == Common::KEYCODE_RETURN)
+				done = 1;
+
+			else if (keyState.keycode == Common::KEYCODE_ESCAPE)
+				done = -1;
+
+			if (keyState.keycode == Common::KEYCODE_TAB) {
+				r = Common::Rect(JOURNAL_BAR_WIDTH, BUTTON_SIZE + screen.fontHeight() + 13);
+				r.moveTo((SHERLOCK_SCREEN_WIDTH - r.width()) / 2, (SHERLOCK_SCREEN_HEIGHT - r.height()) / 2);
+
+				// See if the mouse is over any of the journal controls
+				_selector = JH_NONE;
+				if (Common::Rect(r.left + 3, r.top + 3, r.right - 3, r.top + screen.fontHeight() + 4).contains(mousePos))
+					_selector = (mousePos.x - r.left) / (r.width() / 3);
+
+				// If the mouse is not over any of the options, move the mouse so that it points to the first option
+				if (_selector == JH_NONE) {
+					events.warpMouse(Common::Point(r.left + r.width() / 3, r.top + screen.fontHeight() + 2));
+				} else {
+					if (keyState.keycode & Common::KBD_SHIFT) {
+						if (_selector == JH_CLOSE)
+							_selector = JH_PRINT;
+						else
+							--_selector;
+					} else {
+						if (_selector == JH_PRINT)
+							_selector = JH_CLOSE;
+						else
+							++_selector;
+					}
+
+					events.warpMouse(Common::Point(r.left + (r.width() / 3) * (_selector + 1) - 10, mousePos.y));
+				}
+			}
+
+			if (keyState.ascii >= ' ' && keyState.ascii != '@' && name.size() < 50) {
+				if ((cursorX + screen.charWidth(keyState.ascii)) < (r.right - screen.widestChar() * 3)) {
+					char c = toupper(keyState.ascii);
+					cursorX += screen.charWidth(c);
+					name += c;
+				}
+			}
+
+			// Redraw the text
+			screen._backBuffer1.blitFrom(bgSurface, Common::Point(r.left + 3, cursorY));
+			screen.gPrint(Common::Point(r.left + screen.widestChar() + 3, cursorY), COMMAND_HIGHLIGHTED,
+				"%s", name.c_str());
+			screen.slamArea(r.left + 3, cursorY, r.right - 3, screen.fontHeight());
+		}
+
+		if (events._released || events._rightReleased) {
+			switch (_selector) {
+			case (int)SB_CANCEL:
+				done = -1;
+				break;
+			case (int)SB_BACKWARDS:
+				done = 2;
+				break;
+			case (int)SB_FORWARDS:
+				done = 1;
+				break;
+			default:
+				break;
+			}
+		}
+	} while (!done);
+
+	if (done != -1) {
+		// Forwards or backwards search, so save the entered name
+		_find = name;
+		result = done;
+	} else {
+		result = 0;
+	}
+
+	drawFrame();
+	drawJournal(0, 0);
+	screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+	return result;
+}
+
+void TattooJournal::record(int converseNum, int statementNum, bool replyOnly) {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+
+	// Only record activity in the Journal if the player is Holmes (i.e. we're paast the prologoue)
+	if (_vm->readFlags(FLAG_PLAYER_IS_HOLMES) && !vm._runningProlog)
+		Journal::record(converseNum, statementNum, replyOnly);
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_journal.h b/engines/sherlock/tattoo/tattoo_journal.h
new file mode 100644
index 0000000000..96c1c6cab4
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_journal.h
@@ -0,0 +1,114 @@
+/* ScummVM - Graphic Adventure Engine
+*
+* ScummVM is the legal property of its developers, whose names
+* are too numerous to list here. Please refer to the COPYRIGHT
+* file distributed with this source distribution.
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*
+*/
+
+#ifndef SHERLOCK_TATTOO_JOURNAL_H
+#define SHERLOCK_TATTOO_JOURNAL_H
+
+#include "sherlock/journal.h"
+#include "sherlock/image_file.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+enum JournalHighlight {
+	JH_NONE = -1, JH_CLOSE = 0, JH_SEARCH = 1, JH_PRINT = 2,
+	JH_SCROLL_LEFT = 3, JH_PAGE_LEFT = 4, JH_PAGE_RIGHT = 5, JH_SCROLL_RIGHT = 6, JH_THUMBNAIL = 7
+};
+
+class TattooJournal : public Journal {
+private:
+	ImageFile *_journalImages;
+	int _selector, _oldSelector;
+	bool _wait;
+	bool _exitJournal;
+	uint32 _scrollingTimer;
+	int _savedIndex, _savedSub, _savedPage;
+
+	/**
+	 * Load the list of journal locations
+	 */
+	void loadLocations();
+
+	/**
+	 * Displays the controls used by the journal
+	 * @param mode	0: Normal journal buttons, 1: Search interface
+	 */
+	void drawControls(int mode);
+
+	/**
+	 * Draw the journal controls used by the journal
+	 */
+	void highlightJournalControls(bool slamIt);
+
+	/**
+	 * Draw the journal controls used in search mode
+	 */
+	void highlightSearchControls(bool slamIt);
+
+	void drawScrollBar();
+
+	/**
+	 * Check for and handle any pending keyboard events
+	 */
+	void handleKeyboardEvents();
+
+	/**
+	 * Handle mouse presses on interface buttons
+	 */
+	void handleButtons();
+
+	/**
+	 * Disable the journal controls
+	 */
+	void disableControls();
+
+	/**
+	 * Get in a name to search through the journal for
+	 */
+	int getFindName(bool printError);
+public:
+	TattooJournal(SherlockEngine *vm);
+	virtual ~TattooJournal() {}
+
+	/**
+	 * Show the journal
+	 */
+	void show();
+public:
+	/**
+	 * Draw the journal background, frame, and interface buttons
+	 */
+	virtual void drawFrame();
+
+	/**
+	 * Records statements that are said, in the order which they are said. The player
+	 * can then read the journal to review them
+	 */
+	virtual void record(int converseNum, int statementNum, bool replyOnly = false);
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/tattoo_map.cpp b/engines/sherlock/tattoo/tattoo_map.cpp
new file mode 100644
index 0000000000..4c7e8c8fef
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_map.cpp
@@ -0,0 +1,439 @@
+/* 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 "sherlock/tattoo/tattoo_map.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+#define MAP_NAME_COLOR 131
+#define CLOSEUP_STEPS 30
+#define SCROLL_SPEED 16
+
+/*-------------------------------------------------------------------------*/
+
+void MapEntry::clear() {
+	_iconNum = -1;
+	_description = "";
+}
+
+/*-------------------------------------------------------------------------*/
+
+TattooMap::TattooMap(SherlockEngine *vm) : Map(vm), _mapTooltip(vm) {
+	_iconImages = nullptr;
+	_bgFound = _oldBgFound = 0;
+
+	loadData();
+}
+
+int TattooMap::show() {
+	Debugger &debugger = *_vm->_debugger;
+	Events &events = *_vm->_events;
+	Music &music = *_vm->_music;
+	Resources &res = *_vm->_res;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	int result = 0;
+
+	// Check if we need to keep track of how many times player has been to the map
+	for (uint idx = 0; idx < scene._sceneTripCounters.size(); ++idx) {
+		SceneTripEntry &entry = scene._sceneTripCounters[idx];
+
+		if (entry._sceneNumber == OVERHEAD_MAP || entry._sceneNumber == OVERHEAD_MAP2) {
+			if (--entry._numTimes == 0) {
+				_vm->setFlagsDirect(entry._flag);
+				scene._sceneTripCounters.remove_at(idx);
+			}
+		}
+	}
+
+	if (music._musicOn) {
+		// See if Holmes or Watson is the active character	
+		Common::String song;
+		if (_vm->readFlags(FLAG_PLAYER_IS_HOLMES))
+			// Player is Holmes
+			song = "Cue9";
+		else if (_vm->readFlags(FLAG_ALT_MAP_MUSIC))
+			song = "Cue8";
+		else
+			song = "Cue7";
+
+		if (music.loadSong(song)) {
+			music.startSong();
+		}
+	}
+
+	screen.initPaletteFade(1364485);
+	
+	// Load the custom mouse cursors for the map
+	ImageFile cursors("omouse.vgs");
+	events.setCursor(cursors[0]._frame);
+	events.warpMouse();
+
+	// Load the data for the map
+	_iconImages = new ImageFile("mapicons.vgs");
+	loadData();
+
+	// Load the palette
+	Common::SeekableReadStream *stream = res.load("map.pal");
+	stream->read(screen._cMap, PALETTE_SIZE);
+	screen.translatePalette(screen._cMap);
+	delete stream;
+
+	// Load the map image and draw it to the back buffer
+	ImageFile *map = new ImageFile("map.vgs");
+	screen._backBuffer1.create(SHERLOCK_SCREEN_WIDTH * 2, SHERLOCK_SCREEN_HEIGHT * 2);
+	screen._backBuffer1.blitFrom((*map)[0], Common::Point(0, 0));
+	delete map;
+
+	screen.clear();
+	screen.setPalette(screen._cMap);
+	drawMapIcons();
+
+	// Copy the map drawn in the back buffer to the secondary back buffer
+	screen._backBuffer2.create(SHERLOCK_SCREEN_WIDTH * 2, SHERLOCK_SCREEN_HEIGHT * 2);
+	screen._backBuffer2.blitFrom(screen._backBuffer1);
+
+	// Display the built map to the screen
+	screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+	// Set initial scroll position
+	_targetScroll = _bigPos;
+	screen._currentScroll = Common::Point(-1, -1);
+
+	do {
+		// Allow for event processing and get the current mouse position
+		events.pollEventsAndWait();
+		events.setButtonState();
+		Common::Point mousePos = events.screenMousePos();
+
+		if (debugger._showAllLocations == LOC_REFRESH) {
+			drawMapIcons();
+			screen.slamArea(screen._currentScroll.x, screen._currentScroll.y, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_WIDTH);
+		}
+
+		music.checkSongProgress();
+		checkMapNames(true);
+
+		if (mousePos.x < (SHERLOCK_SCREEN_WIDTH / 6))
+			_targetScroll.x -= 2 * SCROLL_SPEED * (SHERLOCK_SCREEN_WIDTH / 6 - mousePos.x) / (SHERLOCK_SCREEN_WIDTH / 6);
+		if (mousePos.x > (SHERLOCK_SCREEN_WIDTH * 5 / 6))
+			_targetScroll.x += 2 * SCROLL_SPEED * (mousePos.x - (SHERLOCK_SCREEN_WIDTH * 5 / 6)) / (SHERLOCK_SCREEN_WIDTH / 6);
+		if (mousePos.y < (SHERLOCK_SCREEN_HEIGHT / 6))
+			_targetScroll.y -= 2 * SCROLL_SPEED * (SHERLOCK_SCREEN_HEIGHT / 6 - mousePos.y) / (SHERLOCK_SCREEN_HEIGHT / 6);
+		if (mousePos.y > (SHERLOCK_SCREEN_HEIGHT * 5 / 6))
+			_targetScroll.y += 2 * SCROLL_SPEED * (mousePos.y - SHERLOCK_SCREEN_HEIGHT * 5 / 6) / (SHERLOCK_SCREEN_HEIGHT / 6);
+
+		if (_targetScroll.x < 0)
+			_targetScroll.x = 0;
+		if ((_targetScroll.x + SHERLOCK_SCREEN_WIDTH) > screen._backBuffer1.w())
+			_targetScroll.x = screen._backBuffer1.w() - SHERLOCK_SCREEN_WIDTH;
+		if (_targetScroll.y < 0)
+			_targetScroll.y = 0;
+		if ((_targetScroll.y + SHERLOCK_SCREEN_HEIGHT) > screen._backBuffer1.h())
+			_targetScroll.y = screen._backBuffer1.h() - SHERLOCK_SCREEN_HEIGHT;
+
+		// Check the keyboard
+		if (events.kbHit()) {
+			Common::KeyState keyState = events.getKey();
+
+			switch (keyState.keycode) {
+			case Common::KEYCODE_HOME:
+				_targetScroll.x = 0;
+				_targetScroll.y = 0;
+				break;
+
+			case Common::KEYCODE_END:
+				_targetScroll.x = screen._backBuffer1.w() - SHERLOCK_SCREEN_WIDTH;
+				_targetScroll.y = screen._backBuffer1.h() - SHERLOCK_SCREEN_HEIGHT;
+				break;
+
+			case Common::KEYCODE_PAGEUP:
+				_targetScroll.y -= SHERLOCK_SCREEN_HEIGHT;
+				if (_targetScroll.y < 0)
+					_targetScroll.y = 0;
+				break;
+
+			case Common::KEYCODE_PAGEDOWN:
+				_targetScroll.y += SHERLOCK_SCREEN_HEIGHT;
+				if (_targetScroll.y > (screen._backBuffer1.h() - SHERLOCK_SCREEN_HEIGHT))
+					_targetScroll.y = screen._backBuffer1.h() - SHERLOCK_SCREEN_HEIGHT;
+				break;
+
+			case Common::KEYCODE_SPACE:
+				events._pressed = false;
+				events._oldButtons = 0;
+				events._released = true;
+				break;
+
+			default:
+				break;
+			}
+		}
+
+		// Handle any scrolling of the map
+		if (screen._currentScroll != _targetScroll) {
+			// If there is a Text description being displayed, restore the area under it
+			_mapTooltip.erase();
+
+			screen._currentScroll = _targetScroll;
+
+			checkMapNames(false);
+			screen.slamArea(_targetScroll.x, _targetScroll.y, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+		}
+
+		// Handling if a location has been clicked on
+		if (events._released && _bgFound != -1) {
+			// If there is a Text description being displayed, restore the area under it
+			_mapTooltip.erase();
+
+			// Save the current scroll position on the map
+			_bigPos = screen._currentScroll;
+
+			showCloseUp(_bgFound);
+			result = _bgFound + 1;
+		}
+	} while (!result && !_vm->shouldQuit());
+
+	music.stopMusic();
+	events.clearEvents();
+	_mapTooltip.banishWindow();
+
+	// Reset the back buffers back to standard size
+	screen._backBuffer1.create(SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+	screen._backBuffer2.create(SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+
+	return result;
+}
+
+void TattooMap::loadData() {
+	Resources &res = *_vm->_res;
+	char c;
+
+	Common::SeekableReadStream *stream = res.load("map.txt");
+
+	_data.resize(100);
+	for (uint idx = 0; idx < _data.size(); ++idx)
+		_data[idx].clear();
+
+	do
+	{
+		// Find the start of the number
+		do {
+			c = stream->readByte();
+			if (stream->pos() >= stream->size())
+				break;
+		} while (c < '0' || c > '9');
+		if (stream->pos() >= stream->size())
+			break;
+
+		// Get the scene number
+		Common::String locStr;
+		locStr += c;
+		while ((c = stream->readByte()) != '.')
+			locStr += c;
+		MapEntry &mapEntry = _data[atoi(locStr.c_str()) - 1];
+
+		// Get the location name
+		while (stream->readByte() != '"')
+			;
+
+		while ((c = stream->readByte()) != '"')
+			mapEntry._description += c;
+
+		// Find the ( specifying the (X,Y) position of the Icon
+		while (stream->readByte() != '(')
+			;
+
+		// Get the X Position of the icon
+		Common::String numStr;
+		while ((c = stream->readByte()) != ',')
+			numStr += c;
+		mapEntry.x = atoi(numStr.c_str());
+
+		// Get the Y position of the icon
+		numStr = "";
+		while ((c = stream->readByte()) != ')')
+			numStr += c;
+		mapEntry.y = atoi(numStr.c_str());
+
+		// Find and get the location's icon number
+		while (stream->readByte() != '#')
+			;
+
+		Common::String iconStr;
+		while (stream->pos() < stream->size() && (c = stream->readByte()) != '\r')
+			iconStr += c;
+
+		mapEntry._iconNum = atoi(iconStr.c_str()) - 1;
+	} while (stream->pos() < stream->size());
+
+	delete stream;
+}
+
+void TattooMap::drawMapIcons() {
+	Debugger &debugger = *_vm->_debugger;
+	Screen &screen = *_vm->_screen;
+	
+	for (uint idx = 0; idx < _data.size(); ++idx) {
+		if (debugger._showAllLocations != LOC_DISABLED)
+			_vm->setFlagsDirect(idx + 1);
+
+		if (_data[idx]._iconNum != -1 && _vm->readFlags(idx + 1)) {
+			MapEntry &mapEntry = _data[idx];
+			ImageFrame &img = (*_iconImages)[mapEntry._iconNum];
+			screen._backBuffer1.transBlitFrom(img._frame, Common::Point(mapEntry.x - img._width / 2,
+				mapEntry.y - img._height / 2));
+		}
+	}
+
+	if (debugger._showAllLocations == LOC_REFRESH)
+		debugger._showAllLocations = LOC_ALL;
+}
+
+void TattooMap::checkMapNames(bool slamIt) {
+	Events &events = *_vm->_events;
+	Common::Point mapPos = events.mousePos();
+
+	// See if the mouse is pointing at any of the map locations
+	_bgFound = -1;
+
+	for (uint idx = 0; idx < _data.size(); ++idx) {
+		if (_data[idx]._iconNum != -1 && _vm->readFlags(idx + 1)) {
+			MapEntry &mapEntry = _data[idx];
+			ImageFrame &img = (*_iconImages)[mapEntry._iconNum];
+			Common::Rect r(mapEntry.x - img._width / 2, mapEntry.y - img._height / 2,
+				mapEntry.x + img._width / 2, mapEntry.y + img._height / 2);
+
+			if (r.contains(mapPos)) {
+				_bgFound = idx;
+				break;
+			}
+		}
+	}
+
+	// Handle updating the tooltip
+	if (_bgFound != _oldBgFound) {
+		if (_bgFound == -1) {
+			_mapTooltip.setText("");
+		} else {
+			const Common::String &desc = _data[_bgFound]._description;
+			_mapTooltip.setText(desc);
+		}
+	
+		_oldBgFound = _bgFound;
+	}
+
+	_mapTooltip.handleEvents();
+	if (slamIt)
+		_mapTooltip.draw();
+}
+
+void TattooMap::restoreArea(const Common::Rect &bounds) {
+	Screen &screen = *_vm->_screen;
+
+	Common::Rect r = bounds;
+	r.clip(Common::Rect(0, 0, screen._backBuffer1.w(), screen._backBuffer1.h()));
+
+	if (!r.isEmpty())
+		screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(r.left, r.top), r);
+}
+
+void TattooMap::showCloseUp(int closeUpNum) {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+
+	// Hide the cursor
+	events.hideCursor();
+
+	// Get the closeup images
+	Common::String fname = Common::String::format("res%02d.vgs", closeUpNum + 1);
+	ImageFile pic(fname);
+
+	Point32 closeUp(_data[closeUpNum].x * 100, _data[closeUpNum].y * 100);
+	Point32 delta((SHERLOCK_SCREEN_WIDTH / 2 - closeUp.x / 100) * 100 / CLOSEUP_STEPS,
+		(SHERLOCK_SCREEN_HEIGHT / 2 - closeUp.y / 100) * 100 / CLOSEUP_STEPS);
+	Common::Rect oldBounds(closeUp.x / 100, closeUp.y / 100, closeUp.x / 100 + 1, closeUp.y / 100 + 1);
+	int size = 64;
+	int n = 256;
+	int deltaVal = 512;
+	bool minimize = false;
+	int scaleVal, newSize;
+
+	do {
+		scaleVal = n;
+		newSize = pic[0].sDrawXSize(n);
+
+		if (newSize > size) {
+			if (minimize)
+				deltaVal /= 2;
+			n += deltaVal;
+		} else {
+			minimize = true;
+			deltaVal /= 2;
+			n -= deltaVal;
+			if (n < 1)
+				n = 1;
+		}
+	} while (deltaVal && size != newSize);
+
+	int deltaScale = (SCALE_THRESHOLD - scaleVal) / CLOSEUP_STEPS;
+
+	for (int step = 0; step < CLOSEUP_STEPS; ++step) {
+		Common::Point picSize(pic[0].sDrawXSize(scaleVal), pic[0].sDrawYSize(scaleVal));
+		Common::Point pt(screen._currentScroll.x + closeUp.x / 100 - picSize.x / 2,
+			screen._currentScroll.y + closeUp.y / 100 - picSize.y / 2);
+
+		restoreArea(oldBounds);
+		screen._backBuffer1.transBlitFrom(pic[0], pt, false, 0, scaleVal);
+
+		screen.slamRect(oldBounds);
+		screen.slamArea(pt.x, pt.y, picSize.x, picSize.y);
+
+		oldBounds = Common::Rect(pt.x, pt.y, pt.x + picSize.x + 1, pt.y + picSize.y + 1);
+		closeUp += delta;
+		scaleVal += deltaScale;
+
+		events.wait(1);
+	}
+
+	// Handle final drawing of closeup
+	Common::Rect r(screen._currentScroll.x + SHERLOCK_SCREEN_WIDTH / 2 - pic[0]._width / 2,
+		screen._currentScroll.y + SHERLOCK_SCREEN_HEIGHT / 2 - pic[0]._height / 2,
+		screen._currentScroll.x + SHERLOCK_SCREEN_WIDTH / 2 - pic[0]._width / 2 + pic[0]._width,
+		screen._currentScroll.y + SHERLOCK_SCREEN_HEIGHT / 2 - pic[0]._height / 2 + pic[0]._height);
+
+	restoreArea(oldBounds);
+	screen._backBuffer1.transBlitFrom(pic[0], Common::Point(r.left, r.top));
+	screen.slamRect(oldBounds);
+	screen.slamRect(r);
+
+	events.wait(60);
+	events.showCursor();
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_map.h b/engines/sherlock/tattoo/tattoo_map.h
new file mode 100644
index 0000000000..1c7173bdb0
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_map.h
@@ -0,0 +1,93 @@
+/* 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 SHERLOCK_TATTOO_MAP_H
+#define SHERLOCK_TATTOO_MAP_H
+
+#include "common/scummsys.h"
+#include "sherlock/map.h"
+#include "sherlock/resources.h"
+#include "sherlock/surface.h"
+#include "sherlock/tattoo/widget_tooltip.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+struct MapEntry : Common::Point {
+	int _iconNum;
+	Common::String _description;
+
+	MapEntry() : Common::Point(), _iconNum(-1) {}
+	MapEntry(int posX, int posY, int iconNum) : Common::Point(posX, posY), _iconNum(iconNum) {}
+	void clear();
+};
+
+class TattooMap : public Map {
+private:
+	Common::Array<MapEntry> _data;
+	ImageFile *_iconImages;
+	int _bgFound, _oldBgFound;
+	WidgetMapTooltip _mapTooltip;
+	Common::Point _targetScroll;
+	
+	/**
+	 * Load data  needed for the map
+	 */
+	void loadData();
+
+	/**
+	 * Draws all available location icons onto the back buffer
+	 */
+	void drawMapIcons();
+
+	/**
+	 * Draws the location names of whatever the mouse moves over on the map
+	 */
+	void checkMapNames(bool slamIt);
+
+	/**
+	 * Restores an area of the map background
+	 */
+	void restoreArea(const Common::Rect &bounds);
+
+	/**
+	 * This will load a specified close up and zoom it up to the middle of the screen
+	 */
+	void showCloseUp(int closeUpNum);
+public:
+	TattooMap(SherlockEngine *vm);
+	virtual ~TattooMap() {}
+
+	/**
+	 * Show the map
+	 */
+	virtual int show();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/tattoo_people.cpp b/engines/sherlock/tattoo/tattoo_people.cpp
new file mode 100644
index 0000000000..0af8deff9f
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_people.cpp
@@ -0,0 +1,1502 @@
+/* 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 "sherlock/tattoo/tattoo_people.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_talk.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+#define FACING_PLAYER 16
+#define NUM_ADJUSTED_WALKS 21
+#define CHARACTERS_INDEX 256
+
+struct AdjustWalk {
+	char _vgsName[9];
+	int _xAdjust;
+	int _flipXAdjust;
+	int _yAdjust;
+} ;
+
+static const AdjustWalk ADJUST_WALKS[NUM_ADJUSTED_WALKS] = {
+	{ "TUPRIGHT", -7, -19, 6 },
+	{ "TRIGHT", 8, -14, 0 },
+	{ "TDOWNRG", 14, -12, 0 },
+	{ "TWUPRIGH", 12, 4, 2 },
+	{ "TWRIGHT", 31, -14, 0 },
+	{ "TWDOWNRG", 6, -24, 0 },
+	{ "HTUPRIGH", 2, -20, 0 },
+	{ "HTRIGHT", 28, -20, 0 },
+	{ "HTDOWNRG", 8, -2, 0 },
+	{ "GTUPRIGH", 4, -12, 0 },
+	{ "GTRIGHT", 12, -16, 0 },
+	{ "GTDOWNRG", 10, -18, 0 },
+	{ "JTUPRIGH", 8, -10, 0 },
+	{ "JTRIGHT", 22, -6, 0 },
+	{ "JTDOWNRG", 4, -20, 0 },
+	{ "CTUPRIGH", 10, 0, 0 },
+	{ "CTRIGHT", 26, -22, 0 },
+	{ "CTDOWNRI", 16, 4, 0 },
+	{ "ITUPRIGH", 0, 0, 0 },
+	{ "ITRIGHT", 20, 0, 0 },
+	{ "ITDOWNRG", 8, 0, 0 }
+};
+
+static const int WALK_SPEED_X[99] = {
+	90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 98, 90, 90, 90, 90, 90, 91, 90, 90,
+	90, 90,100, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90,100, 90,
+	90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90,103, 90, 90, 90, 90, 90, 90, 90,
+	90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
+	90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90
+};
+
+static const int WALK_SPEED_Y[99] = {
+	28, 28, 28, 28, 28, 28, 28, 28, 28, 32, 32, 32, 28, 28, 28, 28, 28, 26, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	32, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 31, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28
+};
+
+static const int WALK_SPEED_DIAG_X[99] = {
+	50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+	50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+	50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+	50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 90, 50, 50, 50, 50, 50, 50, 50, 50, 50,
+	50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50
+};
+
+/*----------------------------------------------------------------*/
+
+SavedNPCPath::SavedNPCPath() {
+	Common::fill(&_path[0], &_path[MAX_NPC_PATH], 0);
+	_npcIndex = 0;
+	_npcPause = 0;
+	_npcFacing = 0;
+	_lookHolmes = false;
+}
+
+SavedNPCPath::SavedNPCPath(byte path[MAX_NPC_PATH], int npcIndex, int npcPause, const Point32 &position,
+	int npcFacing, bool lookHolmes) : _npcIndex(npcIndex), _npcPause(npcPause), _position(position),
+		_npcFacing(npcFacing), _lookHolmes(lookHolmes) {
+	Common::copy(&path[0], &path[MAX_NPC_PATH], &_path[0]);
+}
+
+/*----------------------------------------------------------------*/
+
+TattooPerson::TattooPerson() : Person() {
+	Common::fill(&_npcPath[0], &_npcPath[MAX_NPC_PATH], 0);
+	_tempX = _tempScaleVal = 0;
+	_npcIndex = 0;
+	_npcMoved = false;
+	_npcFacing = -1;
+	_resetNPCPath = true;
+	_savedNpcSequence = 0;
+	_savedNpcFrame = 0;
+	_updateNPCPath = true;
+	_npcPause = 0;
+	_lookHolmes = false;
+}
+
+TattooPerson::~TattooPerson() {
+	delete _altImages;
+}
+
+void TattooPerson::freeAltGraphics() {
+	delete _altImages;
+	_altImages = nullptr;
+	_altSeq = 0;
+}
+
+void TattooPerson::adjustSprite() {
+	People &people = *_vm->_people;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	if (_type == INVALID)
+		return;
+
+	if (_type == CHARACTER && _status) {
+		// Sprite waiting to move, so restart walk
+		_walkCount = _status;
+		_status = 0;
+
+		_walkDest = _walkTo.front();
+		setWalking();
+	} else if (_type == CHARACTER && _walkCount) {
+		if (_walkCount > 10) {
+			_walkDest = _nextDest;
+			setWalking();
+		}
+
+		_position += _delta;
+		if (_walkCount)
+			--_walkCount;
+
+		if (!_walkCount) {
+			// If there are remaining points to walk, move to the next one
+			if (!_walkTo.empty()) {
+				_walkDest = _walkTo.pop();
+				setWalking();
+			} else {
+				gotoStand();
+			}
+		}
+	}
+
+	if (_type != CHARACTER) {
+		if (_position.y > SHERLOCK_SCREEN_HEIGHT)
+			_position.y = SHERLOCK_SCREEN_HEIGHT;
+
+		if (_position.y < UPPER_LIMIT)
+			_position.y = UPPER_LIMIT;
+
+		if (_position.x < LEFT_LIMIT)
+			_position.x = LEFT_LIMIT;
+
+		if (_position.x > RIGHT_LIMIT)
+			_position.x = RIGHT_LIMIT;
+	}
+
+	int frameNum = _frameNumber;
+	if (frameNum == -1)
+		frameNum = 0;
+	int idx = _walkSequences[_sequenceNumber][frameNum];
+	if (idx > _maxFrames)
+		idx = 1;
+
+	// Set the image frame
+	if (_altSeq)
+		_imageFrame = &(*_altImages)[idx - 1];
+	else
+		_imageFrame = &(*_images)[idx - 1];
+
+	// See if the player has come to a stop after clicking on an Arrow zone to leave the scene.
+	// If so, this will set up the exit information for the scene transition
+	if (!_walkCount && ui._exitZone != -1 && scene._walkedInScene && scene._goToScene == -1 &&
+			!_description.compareToIgnoreCase(people[HOLMES]._description)) { 
+		Exit &exit = scene._exits[ui._exitZone];
+		scene._goToScene = exit._scene;
+
+		if (exit._newPosition.x != 0) {
+			people._savedPos = exit._newPosition;
+
+			if (people._savedPos._facing > 100 && people._savedPos.x < 1)
+				people._savedPos.x = 100;
+		}
+	}
+}
+
+void TattooPerson::gotoStand() {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+
+	// If the misc field is set, then we're running a special talk sequence, so don't interrupt it.
+	if (_misc)
+		return;
+
+	_walkTo.clear();
+	_walkCount = 0;
+	int oldFacing = _sequenceNumber;
+
+	// If the person was talking or listening, just return it to the standing sequence 
+	// in the direction they were pointing
+	if (_sequenceNumber >= TALK_UPRIGHT && _sequenceNumber <= LISTEN_UPLEFT) {
+		switch (_sequenceNumber) {
+		case TALK_UPRIGHT:
+		case LISTEN_UPRIGHT:
+			_sequenceNumber = STOP_UPRIGHT;
+			break;
+		case TALK_RIGHT:
+		case LISTEN_RIGHT:
+			_sequenceNumber = STOP_RIGHT;
+			break;
+		case TALK_DOWNRIGHT:
+		case LISTEN_DOWNRIGHT:
+			_sequenceNumber = STOP_DOWNRIGHT;
+			break;
+		case TALK_DOWNLEFT:
+		case LISTEN_DOWNLEFT:
+			_sequenceNumber = STOP_DOWNLEFT;
+			break;
+		case TALK_LEFT:
+		case LISTEN_LEFT:
+			_sequenceNumber = STOP_LEFT;
+			break;
+		case TALK_UPLEFT:
+		case LISTEN_UPLEFT:
+			_sequenceNumber = STOP_UPLEFT;
+			break;
+		default:
+			break;
+		}
+
+		if (_seqTo) {
+			// Reset to previous value
+			_walkSequences[oldFacing]._sequences[_frameNumber] = _seqTo;
+			_seqTo = 0;
+		}
+
+		// Set the Frame number to the last frame so we don't move
+		_frameNumber = 0;
+
+		checkWalkGraphics();
+
+		_oldWalkSequence = -1;
+		people._allowWalkAbort = true;
+		return;
+	}
+
+	// If the sprite that is stopping is an NPC and he is supposed to face a certain direction 
+	// when he stops, set that direction here
+	int npc = -1;
+	for (int idx = 1; idx < MAX_CHARACTERS; ++idx) {
+		if (_imageFrame == people[idx]._imageFrame)
+			npc = idx;
+	}
+
+	if (npc != -1 && people[npc]._npcFacing != -1) {
+		if (people[npc]._npcFacing == FACING_PLAYER) {
+			// See where Holmes is with respect to the NPC (x coords)
+			if (people[HOLMES]._position.x < people[npc]._position.x)
+				people[npc]._npcFacing = STOP_LEFT;
+			else
+				people[npc]._npcFacing = STOP_RIGHT;
+
+			// See where Holmes is with respect to the NPC (y coords)
+			if (people[HOLMES]._position.y < people[npc]._position.y - (10 * FIXED_INT_MULTIPLIER)) {
+				// Holmes is above the NPC so reset the facing to the diagonal ups
+				if (people[npc]._npcFacing == STOP_RIGHT)
+					people[npc]._npcFacing = STOP_UPRIGHT;
+				else
+					people[npc]._npcFacing = STOP_UPLEFT;
+			} else {
+				if (people[HOLMES]._position.y > people[npc]._position.y + (10 * FIXED_INT_MULTIPLIER)) {
+					// Holmes is below the NPC so reset the facing to the diagonal downs
+					if (people[npc]._npcFacing == STOP_RIGHT)
+						people[npc]._npcFacing = STOP_DOWNRIGHT;
+					else
+						people[npc]._npcFacing = STOP_DOWNLEFT;
+				}
+			}
+		}
+
+		_sequenceNumber = people[npc]._npcFacing;
+	} else {
+		switch (_sequenceNumber) {
+		case WALK_UP: _sequenceNumber = STOP_UP;			break;
+		case WALK_UPRIGHT: _sequenceNumber = STOP_UPRIGHT;	break;
+		case WALK_RIGHT: _sequenceNumber = STOP_RIGHT;		break;
+		case WALK_DOWNRIGHT: _sequenceNumber = STOP_DOWNRIGHT; break;
+		case WALK_DOWN: _sequenceNumber = STOP_DOWN;		break;
+		case WALK_DOWNLEFT: _sequenceNumber = STOP_DOWNLEFT;break;
+		case WALK_LEFT: _sequenceNumber = STOP_LEFT;		break;
+		case WALK_UPLEFT: _sequenceNumber = STOP_UPLEFT;	break;
+		}
+	}
+
+	// Only restart the frame number at 0 if the new sequence is different from the last sequence 
+	// so we don't let Holmes repeat standing.
+	if (_oldWalkSequence != -1) {
+		if (_seqTo) {
+			// Reset to previous value
+			_walkSequences[oldFacing]._sequences[_frameNumber] = _seqTo;
+			_seqTo = 0;
+		}
+
+		_frameNumber = 0;
+	}
+
+	checkWalkGraphics();
+
+	_oldWalkSequence = -1;
+	people._allowWalkAbort = true;
+}
+
+void TattooPerson::setWalking() {
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	int oldDirection, oldFrame;
+	Common::Point delta;
+	_nextDest = _walkDest;
+
+	// Flag that player has now walked in the scene
+	scene._walkedInScene = true;
+
+	// Stop any previous walking, since a new dest is being set
+	_walkCount = 0;
+	oldDirection = _sequenceNumber;
+	oldFrame = _frameNumber;
+
+	// Set speed to use horizontal and vertical movement
+	int scaleVal = scene.getScaleVal(_position);
+	Common::Point speed(MAX(WALK_SPEED_X[scene._currentScene - 1] * SCALE_THRESHOLD / scaleVal, 2),
+		MAX(WALK_SPEED_Y[scene._currentScene - 1] * SCALE_THRESHOLD / scaleVal, 2));
+	Common::Point diagSpeed(MAX(WALK_SPEED_DIAG_X[scene._currentScene - 1] * SCALE_THRESHOLD / scaleVal, 2),
+		MAX((WALK_SPEED_Y[scene._currentScene - 1] - 2) * SCALE_THRESHOLD / scaleVal, 2));
+
+	// If the player is already close to the given destination that no walking is needed, 
+	// move to the next  straight line segment in the overall walking route, if there is one
+	for (;;) {
+		if (_centerWalk || !_walkTo.empty()) {
+			// Since we want the player to be centered on the ultimate destination, and the player
+			// is drawn from the left side, move the cursor half the width of the player to center it
+			delta = Common::Point(_position.x / FIXED_INT_MULTIPLIER - _walkDest.x,
+				_position.y / FIXED_INT_MULTIPLIER - _walkDest.y);
+
+			int dir;
+			if (ABS(delta.x) > ABS(delta.y))
+				dir = (delta.x < 0) ? WALK_LEFT : WALK_RIGHT;
+			else
+				dir = (delta.y < 0) ? WALK_UP : WALK_DOWN;
+
+			scaleVal = scene.getScaleVal(Point32(_walkDest.x * FIXED_INT_MULTIPLIER,
+				_walkDest.y * FIXED_INT_MULTIPLIER));
+			_walkDest.x -= _stopFrames[dir]->sDrawXSize(scaleVal) / 2;
+		}
+
+		delta = Common::Point(
+			ABS(_position.x / FIXED_INT_MULTIPLIER - _walkDest.x),
+			ABS(_position.y / FIXED_INT_MULTIPLIER - _walkDest.y)
+			);
+
+		// If we're ready to move a sufficient distance, that's it. Otherwise,
+		// move onto the next portion of the walk path, if there is one
+		if ((delta.x > 3 || delta.y > 0) || _walkTo.empty())
+			break;
+
+		// Pop next walk segment off the walk route stack
+		_walkDest = _walkTo.pop();
+	}
+
+	// If a sufficient move is being done, then start the move
+	if (delta.x > 3 || delta.y) {
+		// See whether the major movement is horizontal or vertical
+		if (delta.x >= delta.y) {
+			// Set the initial frame sequence for the left and right, as well
+			// as setting the delta x depending on direction
+			if (_walkDest.x < (_position.x / FIXED_INT_MULTIPLIER)) {
+				_sequenceNumber = WALK_LEFT;
+				_delta.x = speed.x * -(FIXED_INT_MULTIPLIER / 10);
+			} else {
+				_sequenceNumber = WALK_RIGHT;
+				_delta.x = speed.x * (FIXED_INT_MULTIPLIER / 10);
+			}
+
+			// See if the x delta is too small to be divided by the speed, since
+			// this would cause a divide by zero error
+			if ((delta.x * 10) >= speed.x) {
+				// Det the delta y
+				_delta.y = (delta.y * FIXED_INT_MULTIPLIER) / ((delta.x * 10) / speed.x);
+				if (_walkDest.y < (_position.y / FIXED_INT_MULTIPLIER))
+					_delta.y = -_delta.y;
+
+				// Set how many times we should add the delta to the player's position
+				_walkCount = (delta.x * 10) / speed.x;
+			} else {
+				// The delta x was less than the speed (ie. we're really close to
+				// the destination). So set delta to 0 so the player won't move
+				_delta = Point32(0, 0);
+				_position = Point32(_walkDest.x * FIXED_INT_MULTIPLIER, _walkDest.y * FIXED_INT_MULTIPLIER);
+
+				_walkCount = 1;
+			}
+
+			// See if the sequence needs to be changed for diagonal walking
+			if (_delta.y > 1500) {
+				if (_sequenceNumber == WALK_LEFT || _sequenceNumber == WALK_RIGHT) {
+					_delta.x = _delta.x / speed.x * diagSpeed.x;
+					_delta.y = (delta.y * FIXED_INT_MULTIPLIER) / (delta.x * 10 / diagSpeed.x);
+
+					_walkCount = delta.x * 10 / diagSpeed.x;
+				}
+
+				switch (_sequenceNumber) {
+				case WALK_LEFT:
+					_sequenceNumber = WALK_DOWNLEFT;
+					break;
+				case WALK_RIGHT:
+					_sequenceNumber = WALK_DOWNRIGHT;
+					break;
+				}
+			} else if (_delta.y < -1500) {
+				if (_sequenceNumber == WALK_LEFT || _sequenceNumber == WALK_RIGHT) {
+					_delta.x = _delta.x / speed.x * diagSpeed.x;
+					_delta.y = -1 * (delta.y * FIXED_INT_MULTIPLIER) / (delta.x * 10 / diagSpeed.x);
+
+					_walkCount = (delta.x * 10) / diagSpeed.x;
+				}
+
+				switch (_sequenceNumber) {
+				case WALK_LEFT:
+					_sequenceNumber = WALK_UPLEFT;
+					break;
+				case WALK_RIGHT:
+					_sequenceNumber = WALK_UPRIGHT;
+					break;
+				}
+			}
+		} else {
+			// Major movement is vertical, so set the sequence for up and down,
+			// and set the delta Y depending on the direction
+			if (_walkDest.y < (_position.y / FIXED_INT_MULTIPLIER)) {
+				_sequenceNumber = WALK_UP;
+				_delta.y = speed.y * -(FIXED_INT_MULTIPLIER / 10);
+			} else {
+				speed.y = diagSpeed.y;
+				_sequenceNumber = WALK_DOWN;
+				_delta.y = speed.y * (FIXED_INT_MULTIPLIER / 10);
+			}
+
+			// Set the delta x
+			if (delta.y * 10 / speed.y)
+				_delta.x = (delta.x * FIXED_INT_MULTIPLIER) / (delta.y * 10 / speed.y);
+			else
+				_delta.x = (delta.x * FIXED_INT_MULTIPLIER) / delta.y;
+
+			if (_walkDest.x < _position.y / FIXED_INT_MULTIPLIER)
+				_delta.x = -_delta.x;
+
+			// Set how many times we should add the delta's to the players position
+			if (delta.y * 10 / speed.y)
+				_walkCount = delta.y * 10 / speed.y;
+			else
+				_walkCount = delta.y;
+		}
+	}
+
+	// See if the new walk sequence is the same as the old. If it's a new one,
+	// we need to reset the frame number to zero so its animation starts at
+	// its beginning. Otherwise, if it's the same sequence, we can leave it
+	// as is, so it keeps the animation going at wherever it was up to
+	if (_sequenceNumber != _oldWalkSequence) {
+		if (_seqTo) {
+			// Reset to previous value
+			_walkSequences[oldDirection]._sequences[_frameNumber] = _seqTo;
+			_seqTo = 0;
+		}
+		_frameNumber = 0;
+	}
+
+	checkWalkGraphics();
+	_oldWalkSequence = _sequenceNumber;
+
+	if (!_walkCount && _walkTo.empty())
+		gotoStand();
+
+	// If the sequence is the same as when we started, then Holmes was standing still and we're trying 
+	// to re-stand him, so reset Holmes' rame to the old frame number from before it was reset to 0
+	if (_sequenceNumber == oldDirection)
+		_frameNumber = oldFrame;
+}
+
+void TattooPerson::walkToCoords(const Point32 &destPos, int destDir) {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Events &events = *_vm->_events;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Talk &talk = *_vm->_talk;
+
+	CursorId oldCursor = events.getCursor();
+	events.setCursor(WAIT);
+
+	_walkDest = Common::Point(destPos.x / FIXED_INT_MULTIPLIER, destPos.y / FIXED_INT_MULTIPLIER);
+
+	bool isHolmes = this == &people[HOLMES];
+	if (isHolmes) {
+		people._allowWalkAbort = true;
+	} else {
+		// Clear the path Variables
+		_npcIndex = _npcPause = 0;
+		Common::fill(_npcPath, _npcPath + 100, 0);
+		_npcFacing = destDir;
+	}
+
+	_centerWalk = false;
+
+	// Only move the person if they're going an appreciable distance
+	if (ABS(_walkDest.x - (_position.x / FIXED_INT_MULTIPLIER)) > 8 || 
+			ABS(_walkDest.y - (_position.y / FIXED_INT_MULTIPLIER)) > 4) {
+		goAllTheWay();
+
+		do {
+			// Keep doing animations whilst walk is in progress
+			events.wait(1);
+			scene.doBgAnim();
+
+			if (events.kbHit()) {
+				Common::KeyState keyState = events.getKey();
+
+				if (keyState.keycode == Common::KEYCODE_ESCAPE && vm._runningProlog) {
+					vm.setFlags(-76);
+					vm.setFlags(396);
+					scene._goToScene = 1;
+					talk._talkToAbort = true;
+				}
+			}
+		} while (!_vm->shouldQuit() && _walkCount && !talk._talkToAbort);
+	}
+
+	_centerWalk = true;
+	if (!isHolmes)
+		_updateNPCPath = true;
+
+	if (!talk._talkToAbort) {
+		// put character exactly on right spot
+		_position = destPos;
+
+		if (_sequenceNumber != destDir) {
+			// Facing character to correct ending direction
+			_sequenceNumber = destDir;
+			gotoStand();
+		}
+
+		if (!isHolmes)
+			_updateNPCPath = false;
+
+		// Secondary walking wait loop
+		bool done = false;
+		while (!done && !_vm->shouldQuit()) {
+			events.wait(1);
+			scene.doBgAnim();
+
+			// See if we're past the initial goto stand sequence
+			for (int idx = 0; idx < _frameNumber; ++idx) {
+				if (_walkSequences[_sequenceNumber][idx] == 0) {
+					done = true;
+					break;
+				}
+			}
+
+			if (events.kbHit()) {
+				Common::KeyState keyState = events.getKey();
+
+				if (keyState.keycode == Common::KEYCODE_ESCAPE && vm._runningProlog) {
+					vm.setFlags(-76);
+					vm.setFlags(396);
+					scene._goToScene = 1;
+					talk._talkToAbort = true;
+				}
+			}
+		}
+
+		if (!isHolmes)
+			_updateNPCPath = true;
+
+		if (!talk._talkToAbort)
+			events.setCursor(oldCursor);
+	}
+}
+
+void TattooPerson::clearNPC() {
+	Common::fill(&_npcPath[0], &_npcPath[MAX_NPC_PATH], 0);
+	_npcIndex = 0;
+	_pathStack.clear();
+	_npcName = "";
+}
+
+void TattooPerson::updateNPC() {
+	People &people = *_vm->_people;
+	Talk &talk = *_vm->_talk;
+
+	// If the NPC isn't on, or it's in Talk or Listen Mode, then return without doing anything
+	if (_type != CHARACTER || _sequenceNumber >= TALK_UPRIGHT)
+		return;
+
+	// If the NPC is paused, just decrement his pause counter and exit
+	if (_npcPause) {
+		// Decrement counter
+		--_npcPause;
+
+		// Now see if we need to update the NPC's frame sequence so that he faces Holmes
+		if (_lookHolmes) {
+			// See where Holmes is with respect to the NPC (x coordinate)			
+			_npcFacing =  (people[HOLMES]._position.x < _position.x) ? STOP_LEFT : STOP_RIGHT;
+
+			// See where Holmes is with respect to the NPC (y coordinate)
+			if (people[HOLMES]._position.y < (_position.y - 10 * FIXED_INT_MULTIPLIER)) {
+				// Holmes is above the NPC so reset the facing to a diagonal up
+				_npcFacing = (_npcFacing == STOP_RIGHT) ? STOP_UPRIGHT : STOP_UPLEFT;
+			} else  if (people[HOLMES]._position.y > (_position.y + 10 * FIXED_INT_MULTIPLIER)) {
+				// Holmes is below the NPC so reset the facing to a diagonal down
+				_npcFacing = (_npcFacing == STOP_RIGHT) ? STOP_DOWNRIGHT : STOP_DOWNLEFT;
+			}
+
+			// See if we need to set the old_walk_sequence so the NPC will put his arms 
+			// up if he turns another way
+			if (_sequenceNumber != _npcFacing)
+				_oldWalkSequence = _sequenceNumber;
+
+			gotoStand();
+		}
+	} else {
+		// Reset the look flag so the NPC won't face Holmes anymore
+		_lookHolmes = false;
+
+		// See if the NPC is stopped or not. Don't do anything if he's moving
+		if (!_walkCount) {
+			// If there is no new command, reset the path back to the beginning
+			if (!_npcPath[_npcIndex])
+				_npcIndex = 0;
+
+			// The NPC is stopped and any pause he was doing is done. We can now see what 
+			// the next command in the NPC path is.
+
+			// Scan Past any NPC Path Labels since they do nothing except mark places for If's and Goto's
+			while (_npcPath[_npcIndex] == NPCPATH_PATH_LABEL)
+				_npcIndex += 2;
+
+			if (_npcPath[_npcIndex]) {
+				_npcFacing = -1;
+
+				switch (_npcPath[_npcIndex]) {
+				case NPCPATH_SET_DEST: {
+					// Set the NPC's new destination
+					int xp = (_npcPath[_npcIndex + 1] - 1) * 256 + _npcPath[_npcIndex + 2] - 1;
+					if (xp > 16384)
+						xp = -1 * (xp - 16384);
+					_walkDest.x = xp;
+					_walkDest.y = (_npcPath[_npcIndex + 3] - 1) * 256 + _npcPath[_npcIndex + 4] - 1;
+					_npcFacing = _npcPath[_npcIndex + 5] - 1;
+
+					goAllTheWay();
+					_npcIndex += 6;
+					break;
+				}
+
+				case NPCPATH_PAUSE:
+					// Set the NPC to pause where he is
+					_npcPause = (_npcPath[_npcIndex + 1] - 1) * 256 + _npcPath[_npcIndex + 2] - 1;
+					_npcIndex += 3;
+					break;
+
+				case NPCPATH_SET_TALK_FILE: {
+					// Set the NPC's Talk File to use if Holmes talks to them
+					++_npcIndex;
+
+					_npcName = "";
+					for (int idx = 0; idx < 8; ++idx) {
+						if (_npcPath[_npcIndex + idx] != '~')
+							_npcName += _npcPath[_npcIndex + idx];
+						else
+							break;
+					}
+
+					_npcIndex += 8;
+					break;
+				}
+
+				case NPCPATH_CALL_TALK_FILE: {
+					// Call a Talk File
+					++_npcIndex;
+
+					Common::String name;
+					for (int idx = 0; idx < 8; ++idx) {
+						if (_npcPath[_npcIndex + idx] != '~')
+							name += _npcPath[_npcIndex + idx];
+						else
+							break;
+					}
+
+					_npcIndex += 8;
+					talk.talkTo(name);
+					break;
+				}
+
+				case NPCPATH_TAKE_NOTES:
+					// Set the NPC to Pause where he is and set his frame sequences 
+					// so he takes notes while he's paused
+					_npcPause = (_npcPath[_npcIndex + 1] - 1) * 256 + _npcPath[_npcIndex + 2] - 1;
+					_npcIndex += 3;
+					break;
+
+				case NPCPATH_FACE_HOLMES:
+					// Set the NPC to Pause where he is and set his look flag so he will always face Holmes
+					// while he is paused
+					_npcPause = (_npcPath[_npcIndex + 1] - 1) * 256 + _npcPath[_npcIndex + 2] - 1;
+					_lookHolmes = true;
+					_npcIndex += 3;
+					break;
+
+				//case NPCPATH_PATH_LABEL:		// No implementation needed here
+
+				case NPCPATH_GOTO_LABEL: {
+					// Goto NPC Path Label
+					int label = _npcPath[_npcIndex + 1];
+					_npcIndex = 0;
+
+					// Scan through NPC path data to find the label
+					bool found = false;
+					while (!found) {
+						switch (_npcPath[_npcIndex]) {
+						case NPCPATH_SET_DEST:
+							_npcIndex += 6;
+							break;
+						case NPCPATH_PAUSE:
+						case NPCPATH_TAKE_NOTES:
+						case NPCPATH_FACE_HOLMES:
+							_npcIndex += 3;
+							break;
+						case NPCPATH_SET_TALK_FILE:
+						case NPCPATH_CALL_TALK_FILE:
+							_npcIndex += 8;
+							break;
+						case NPCPATH_PATH_LABEL:
+							if (_npcPath[_npcIndex + 1] == label)
+								found = true;
+							_npcIndex += 2;
+							break;
+						case NPCPATH_GOTO_LABEL:
+							_npcIndex += 2;
+							break;
+						case NPCPATH_IFFLAG_GOTO_LABEL:
+							_npcIndex += 4;
+							break;
+						}
+					}
+					break;
+				}
+
+				case NPCPATH_IFFLAG_GOTO_LABEL: {
+					// If FLAG then Goto Label
+					int flag = (_npcPath[_npcIndex + 1] - 1) * 256 + _npcPath[_npcIndex + 2] - 1 - (_npcPath[_npcIndex + 2] == 1 ? 1 : 0);
+
+					// Set the value the flag should be for the if statement to succeed
+					bool flagVal = flag < 16384;
+
+					int label = _npcPath[_npcIndex + 3];
+					_npcIndex += 4;
+
+					// If the flag is set Correctly, move the NPC Index to the given label
+					if (_vm->readFlags(flag & 16383) == flagVal) {
+						_npcIndex = 0;
+						bool found = false;
+						while (!found)
+						{
+							switch (_npcPath[_npcIndex])
+							{
+							case NPCPATH_SET_DEST:
+								_npcIndex += 6;
+								break;
+							case NPCPATH_PAUSE:
+							case NPCPATH_TAKE_NOTES:
+							case NPCPATH_FACE_HOLMES:
+								_npcIndex += 3;
+								break;
+							case NPCPATH_SET_TALK_FILE:
+							case NPCPATH_CALL_TALK_FILE:
+								_npcIndex += 8;
+								break;
+							case NPCPATH_PATH_LABEL:
+								if (_npcPath[_npcIndex + 1] == label)
+									found = true;
+								_npcIndex += 2;
+								break;
+							case NPCPATH_GOTO_LABEL:
+								_npcIndex += 2;
+								break;
+							case NPCPATH_IFFLAG_GOTO_LABEL:
+								_npcIndex += 4;
+								break;
+							}
+						}
+					}
+
+					break;
+				}
+
+				default:
+					break;
+				}
+			}
+		}
+	}
+}
+
+void TattooPerson::pushNPCPath() {
+	assert(_pathStack.size() < 2);
+	SavedNPCPath savedPath(_npcPath, _npcIndex, _npcPause, _position, _sequenceNumber, _lookHolmes);
+	_pathStack.push(savedPath);
+}
+
+void TattooPerson::pullNPCPath() {
+	// Pop the stack entry and restore the fields
+	SavedNPCPath path = _pathStack.pop();
+	Common::copy(&path._path[0], &path._path[MAX_NPC_PATH], &_npcPath[0]);
+	_npcIndex = path._npcIndex;
+	_npcPause = path._npcPause;
+
+	// Handle the first case if the NPC was paused
+	if (_npcPause) {
+		_npcFacing = path._npcFacing;
+		_lookHolmes = path._lookHolmes;
+
+		// See if the NPC has moved from where they originally were
+		if (path._position != _position) {
+			_walkDest = Point32(path._position.x / FIXED_INT_MULTIPLIER, path._position.y / FIXED_INT_MULTIPLIER);
+			goAllTheWay();
+			_npcPause = 0;
+			_npcIndex -= 3;
+		} else {
+			// See if we need to set the old walk sequence so the NPC will put his arms up if he turns another way
+			if (_npcFacing != _sequenceNumber)
+				_oldWalkSequence = _sequenceNumber;
+
+			gotoStand();
+		}
+	} else {
+		// Handle the second case if the NPC was in motion
+		_npcIndex -= 6;
+	}
+}
+
+Common::Point TattooPerson::getSourcePoint() const {
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	int scaleVal = scene.getScaleVal(_position);
+
+	return Common::Point(_position.x / FIXED_INT_MULTIPLIER + 
+		(_imageFrame ? _imageFrame->sDrawXSize(scaleVal) / 2 : 0), _position.y / FIXED_INT_MULTIPLIER);
+}
+
+void TattooPerson::setObjTalkSequence(int seq) {
+	assert(seq != -1 && _type == CHARACTER);
+
+	if (_seqTo) {
+		// reset to previous value
+		_walkSequences[_sequenceNumber]._sequences[_frameNumber] = _seqTo;
+		_seqTo = 0;
+	}
+
+	_sequenceNumber = _gotoSeq;
+	_frameNumber = 0;
+	checkWalkGraphics();
+}
+
+void TattooPerson::checkWalkGraphics() {
+	People &people = *_vm->_people;
+
+	if (_images == nullptr) {
+		freeAltGraphics();
+		return;
+	}
+
+	Common::String filename = Common::String::format("%s.vgs", _walkSequences[_sequenceNumber]._vgsName.c_str());
+
+	// Set the adjust depending on if we have to fine tune the x position of this particular graphic
+	_adjust.x = _adjust.y = 0;
+
+	for (int idx = 0; idx < NUM_ADJUSTED_WALKS; ++idx) {
+		if (!scumm_strnicmp(_walkSequences[_sequenceNumber]._vgsName.c_str(), ADJUST_WALKS[idx]._vgsName,
+			strlen(ADJUST_WALKS[idx]._vgsName))) {
+			if (_walkSequences[_sequenceNumber]._horizFlip)
+				_adjust.x = ADJUST_WALKS[idx]._flipXAdjust;
+			else
+				_adjust.x = ADJUST_WALKS[idx]._xAdjust;
+
+			_adjust.y = ADJUST_WALKS[idx]._yAdjust;
+			break;
+		}
+	}
+
+	// See if we're already using Alternate Graphics
+	if (_altSeq) {
+		// See if the VGS file called for is different than the alternate graphics already loaded
+		if (_walkSequences[_sequenceNumber]._vgsName.compareToIgnoreCase(_walkSequences[_altSeq - 1]._vgsName)) {
+			// Different AltGraphics, Free the old ones
+			freeAltGraphics();
+		}
+	}
+
+	// If there is no Alternate Sequence set, see if we need to load a new one
+	if (!_altSeq) {
+		int npcNum = -1;
+		// Find which NPC this is so we can check the name of the graphics loaded
+		for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+			if (this == &people[idx]) {
+				npcNum = idx;
+				break;
+			}
+		}
+
+		if (npcNum != -1) {
+			// See if the VGS file called for is different than the main graphics which are already loaded
+			if (filename.compareToIgnoreCase(people[npcNum]._walkVGSName) != 0) {
+				// See if this is one of the more used Walk Graphics stored in WALK.LIB
+				for (int idx = 0; idx < NUM_IN_WALK_LIB; ++idx) {
+					if (!scumm_stricmp(filename.c_str(), WALK_LIB_NAMES[idx])) {
+						people._useWalkLib = true;
+						break;
+					}
+				}
+
+				_altImages = new ImageFile(filename);
+				people._useWalkLib = false;
+
+				_altSeq = _sequenceNumber + 1;
+			}
+		}
+	}
+
+	// If this is a different seqeunce from the current sequence, reset the appropriate variables
+	if (_sequences != &_walkSequences[_sequenceNumber]._sequences[0]) {
+		_seqTo = _seqCounter = _seqCounter2 = _seqStack = _startSeq = 0;
+		_sequences = &_walkSequences[_sequenceNumber]._sequences[0];
+		_seqSize = _walkSequences[_sequenceNumber]._sequences.size();
+
+		// WORKAROUND: Occassionally when switching to a new walk sequence the existing frame number may be outside
+		// the allowed range for the new sequence. In such cases, reset the frame number
+		if (_frameNumber < 0 || _frameNumber >= (int)_seqSize || _walkSequences[_sequenceNumber][_frameNumber] == 0)
+			_frameNumber = 0;
+	}
+
+	setImageFrame();
+}
+
+void TattooPerson::synchronize(Serializer &s) {
+	if (s.isSaving()) {
+		SpriteType type = (_type == INVALID && _walkLoaded) ? HIDDEN_CHARACTER : _type;
+		s.syncAsSint16LE(type);
+	} else {
+		if (_walkCount)
+			gotoStand();
+
+		s.syncAsSint16LE(_type);
+	}
+
+	s.syncAsSint32LE(_position.x);
+	s.syncAsSint32LE(_position.y);
+	s.syncString(_walkVGSName);
+	s.syncString(_description);
+	s.syncString(_examine);
+
+	// NPC specific properties
+	s.syncBytes(&_npcPath[0], MAX_NPC_PATH);
+	s.syncString(_npcName);
+	s.syncAsSint32LE(_npcPause);
+	s.syncAsByte(_lookHolmes);
+	s.syncAsByte(_updateNPCPath);
+	if (s.isLoading())
+		_npcIndex = 0;
+
+	// Verbs
+	for (int idx = 0; idx < 2; ++idx)
+		_use[idx].synchronize(s);
+}
+
+void TattooPerson::walkHolmesToNPC() {
+	Events &events = *_vm->_events;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	TattooPerson &holmes = people[HOLMES];
+
+	// Save the character's details
+	pushNPCPath();
+
+	// If the NPC is moving, stop him at his current position
+	if (_walkCount) {
+		// Reset the facing so the NPC will stop facing the direction he was going,
+		// rather than the direction he was supposed to when he finished wlaking
+		_npcFacing = -1;
+		gotoStand();
+	}
+
+	int scaleVal = scene.getScaleVal(_position);
+	ImageFrame &imgFrame = (*holmes._images)[0];
+
+	// Clear the path variables
+	memset(_npcPath, 0, 100);
+	
+	// Set the NPC path so he pauses for 250 while looking at Holmes
+	_npcPath[0] = 6;
+	_npcPath[1] = 1;
+	_npcPath[2] = 251;
+	_npcIndex = 0;
+	_npcPause = 250;
+	_lookHolmes = true;
+
+	// See where Holmes is with respect to the NPC (x coords)
+	if (holmes._position.x < _position.x) {
+		holmes._walkDest.x = MAX(_position.x / FIXED_INT_MULTIPLIER - imgFrame.sDrawXSize(scaleVal), 0);
+	} else {
+		holmes._walkDest.x = MIN(_position.x / FIXED_INT_MULTIPLIER + imgFrame.sDrawXSize(scaleVal) * 2,
+			screen._backBuffer1.w() - 1);
+	}
+
+	// See where Holmes is with respect to the NPC (y coords)
+	if (holmes._position.y < (_position.y - imgFrame.sDrawXSize(scaleVal) * 500)) {
+		holmes._walkDest.y = MAX(_position.y / FIXED_INT_MULTIPLIER - imgFrame.sDrawXSize(scaleVal) / 2, 0);
+	} else {
+		if (holmes._position.y > (_position.y + imgFrame.sDrawXSize(scaleVal) * 500)) {
+			// Holmes is below the NPC
+			holmes._walkDest.y = MIN(_position.y / FIXED_INT_MULTIPLIER + imgFrame.sDrawXSize(scaleVal) / 2,
+				SHERLOCK_SCREEN_HEIGHT - 1);
+		} else {
+			// Holmes is roughly on the same Y as the NPC
+			holmes._walkDest.y = _position.y / FIXED_INT_MULTIPLIER;
+		}
+	}
+
+	events.setCursor(WAIT);
+
+	_walkDest.x += 10;
+	people._allowWalkAbort = true;
+	holmes.goAllTheWay();
+
+	// Do doBgAnim should be called over and over until walk is done
+	do {
+		events.wait(1);
+		scene.doBgAnim();
+	} while (holmes._walkCount);
+
+	if (!talk._talkToAbort) {
+		// Setup correct direction for Holmes to face
+		// See where Holmes is with respect to the NPC (x coords)
+		int facing = (holmes._position.x < _position.x) ? STOP_RIGHT : STOP_LEFT;
+
+		// See where Holmes is with respect to the NPC (y coords)
+		if (holmes._position.y < (_position.y - (10 * FIXED_INT_MULTIPLIER))) {
+			// Holmes is above the NPC. Reset the facing to the diagonal downs
+			facing = (facing == STOP_RIGHT) ? STOP_DOWNRIGHT : STOP_DOWNLEFT;
+		} else {
+			if (holmes._position.y > (_position.y + 10 * FIXED_INT_MULTIPLIER)) {
+				// Holmes is below the NPC. Reset the facing to the diagonal ups
+				facing = (facing == STOP_RIGHT) ? STOP_UPRIGHT : STOP_UPLEFT;
+			}
+		}
+
+		holmes._sequenceNumber = facing;
+		holmes.gotoStand();
+
+		events.setCursor(ARROW);
+	}
+}
+
+void TattooPerson::walkBothToCoords(const PositionFacing &holmesDest, const PositionFacing &npcDest) {
+	Events &events = *_vm->_events;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Talk &talk = *_vm->_talk;
+	TattooPerson &holmes = people[HOLMES];
+	bool holmesStopped = false, npcStopped = false;
+
+	// Save the current cursor and change to the wait cursor
+	CursorId oldCursor = events.getCursor();
+	events.setCursor(WAIT);
+
+	holmes._centerWalk = false;
+	_centerWalk = false;
+
+	// Start Holmes walking to his dest
+	holmes._walkDest = Common::Point(holmesDest.x / FIXED_INT_MULTIPLIER + 10, holmesDest.y / FIXED_INT_MULTIPLIER);
+	people._allowWalkAbort = true;
+	holmes.goAllTheWay();
+
+	// Start the NPC walking to their dest
+	_walkDest = Common::Point(npcDest.x / FIXED_INT_MULTIPLIER + 10, npcDest.y / FIXED_INT_MULTIPLIER);
+	goAllTheWay();
+
+	// Clear the path variables
+	_npcIndex = _npcPause = 0;
+	Common::fill(&_npcPath[0], &_npcPath[100], 0);
+	_npcFacing = npcDest._facing;
+
+	// Now loop until both stop walking
+	do {
+		events.pollEvents();
+		scene.doBgAnim();
+
+		if (!holmes._walkCount && !holmesStopped) {
+			// Holmes finished walking
+			holmesStopped = true;
+
+			// Ensure Holmes is on the exact destination spot
+			holmes._position = holmesDest;
+			holmes._sequenceNumber = holmesDest._facing;
+			holmes.gotoStand();
+		}
+
+		if (!_walkCount && !npcStopped) {
+			// NPC finished walking
+			npcStopped = true;
+
+			// Ensure NPC is on the exact destination spot
+			_position = npcDest;
+			_sequenceNumber = npcDest._facing;
+			gotoStand();
+		}
+
+	} while (!_vm->shouldQuit() && (holmes._walkCount || _walkCount));
+
+	holmes._centerWalk = true;
+	_centerWalk = true;
+
+	// Do one last frame draw so that the lsat person to stop will be drawn in their final position
+	scene.doBgAnim();
+
+	_updateNPCPath = true;
+
+	if (!talk._talkToAbort)
+		// Restore original mouse cursor
+		events.setCursor(oldCursor);
+}
+
+void TattooPerson::centerScreenOnPerson() {
+	Screen &screen = *_vm->_screen;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	ui._targetScroll.x = CLIP(_position.x / FIXED_INT_MULTIPLIER - SHERLOCK_SCREEN_WIDTH / 2,
+		0, screen._backBuffer1.w() - SHERLOCK_SCREEN_WIDTH);
+	screen._currentScroll = ui._targetScroll;
+
+	// Reset the default look position to the center of the screen
+	ui._lookPos = screen._currentScroll + Common::Point(SHERLOCK_SCREEN_WIDTH / 2, SHERLOCK_SCREEN_HEIGHT / 2);
+}
+
+/*----------------------------------------------------------------*/
+
+TattooPeople::TattooPeople(SherlockEngine *vm) : People(vm) {
+	for (int idx = 0; idx < 6; ++idx)
+		_data.push_back(new TattooPerson());
+}
+
+void TattooPeople::setListenSequence(int speaker, int sequenceNum) {
+	Scene &scene = *_vm->_scene;
+
+	// If no speaker is specified, then nothing needs to be done
+	if (speaker == -1)
+		return;
+
+	int objNum = findSpeaker(speaker);
+	if (objNum < CHARACTERS_INDEX && objNum != -1) {
+		// See if the Object has to wait for an Abort Talk Code
+		Object &obj = scene._bgShapes[objNum];
+		if (obj.hasAborts())
+			obj._gotoSeq = sequenceNum;
+		else
+			obj.setObjTalkSequence(sequenceNum);
+	} else if (objNum != -1) {
+		objNum -= CHARACTERS_INDEX;
+		TattooPerson &person = (*this)[objNum];
+
+		int newDir = person._sequenceNumber;
+		switch (person._sequenceNumber) {
+		case WALK_UP:
+		case STOP_UP:
+		case WALK_UPRIGHT:
+		case STOP_UPRIGHT:
+		case TALK_UPRIGHT:
+		case LISTEN_UPRIGHT:
+			newDir = LISTEN_UPRIGHT;
+			break;
+		case WALK_RIGHT:
+		case STOP_RIGHT:
+		case TALK_RIGHT:
+		case LISTEN_RIGHT:
+			newDir = LISTEN_RIGHT;
+			break;
+		case WALK_DOWNRIGHT:
+		case STOP_DOWNRIGHT:
+		case TALK_DOWNRIGHT:
+		case LISTEN_DOWNRIGHT:
+			newDir = LISTEN_DOWNRIGHT;
+			break;
+		case WALK_DOWN:
+		case STOP_DOWN:
+		case WALK_DOWNLEFT:
+		case STOP_DOWNLEFT:
+		case TALK_DOWNLEFT:
+		case LISTEN_DOWNLEFT:
+			newDir = LISTEN_DOWNLEFT;
+			break;
+		case WALK_LEFT:
+		case STOP_LEFT:
+		case TALK_LEFT:
+		case LISTEN_LEFT:
+			newDir = LISTEN_LEFT;
+			break;
+		case WALK_UPLEFT:
+		case STOP_UPLEFT:
+		case TALK_UPLEFT:
+		case LISTEN_UPLEFT:
+			newDir = LISTEN_UPLEFT;
+			break;
+
+		default:
+			break;
+		}
+
+		// See if the NPC's Seq has to wait for an Abort Talk Code
+		if (person.hasAborts()) {
+			person._gotoSeq = newDir;
+		}  else {
+			if (person._seqTo) {
+				// Reset to previous value
+				person._walkSequences[person._sequenceNumber]._sequences[person._frameNumber] = person._seqTo;
+				person._seqTo = 0;
+			}
+
+			person._sequenceNumber = newDir;
+			person._frameNumber = 0;
+			person.checkWalkGraphics();
+		}
+	}
+}
+
+void TattooPeople::setTalkSequence(int speaker, int sequenceNum) {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Scene &scene = *_vm->_scene;
+	TattooTalk &talk = *(TattooTalk *)_vm->_talk;
+
+	// If no speaker is specified, then nothing needs to be done
+	if (speaker == -1)
+		return;
+
+	int objNum = people.findSpeaker(speaker);
+	if (objNum != -1 && objNum < CHARACTERS_INDEX) {
+		Object &obj = scene._bgShapes[objNum];
+
+		// See if the Object has to wait for an Abort Talk Code
+		if (obj.hasAborts()) {
+			talk.pushSequenceEntry(&obj);
+			obj._gotoSeq = sequenceNum;
+		} else {
+			obj.setObjTalkSequence(sequenceNum);
+		}
+	} else if (objNum != -1) {
+		objNum -= CHARACTERS_INDEX;
+		TattooPerson &person = people[objNum];
+		int newDir = person._sequenceNumber;
+
+		switch (newDir) {
+		case WALK_UP:
+		case STOP_UP:
+		case WALK_UPRIGHT:
+		case STOP_UPRIGHT:
+		case TALK_UPRIGHT:
+		case LISTEN_UPRIGHT:
+			newDir = TALK_UPRIGHT;
+			break;
+		case WALK_RIGHT:
+		case STOP_RIGHT:
+		case TALK_RIGHT:
+		case LISTEN_RIGHT:
+			newDir = TALK_RIGHT;
+			break;
+		case WALK_DOWNRIGHT:
+		case STOP_DOWNRIGHT:
+		case TALK_DOWNRIGHT:
+		case LISTEN_DOWNRIGHT:
+			newDir = TALK_DOWNRIGHT;
+			break;
+		case WALK_DOWN:
+		case STOP_DOWN:
+		case WALK_DOWNLEFT:
+		case STOP_DOWNLEFT:
+		case TALK_DOWNLEFT:
+		case LISTEN_DOWNLEFT:
+			newDir = TALK_DOWNLEFT;
+			break;
+		case WALK_LEFT:
+		case STOP_LEFT:
+		case TALK_LEFT:
+		case LISTEN_LEFT:
+			newDir = TALK_LEFT;
+			break;
+		case WALK_UPLEFT:
+		case STOP_UPLEFT:
+		case TALK_UPLEFT:
+		case LISTEN_UPLEFT:
+			newDir = TALK_UPLEFT;
+			break;
+		default:
+			break;
+		}
+
+		// See if the NPC's sequence has to wait for an Abort Talk Code
+		if (person.hasAborts()) {
+			person._gotoSeq = newDir;
+		} else {
+			if (person._seqTo) {
+				// Reset to previous value
+				person._walkSequences[person._sequenceNumber]._sequences[person._frameNumber] = person._seqTo;
+				person._seqTo = 0;
+			}
+
+			person._sequenceNumber = newDir;
+			person._frameNumber = 0;
+			person.checkWalkGraphics();
+		}
+	}
+}
+
+
+int TattooPeople::findSpeaker(int speaker) {
+	int result = People::findSpeaker(speaker);
+	const char *portrait = _characters[speaker]._portrait;
+
+	// Fallback that Rose Tattoo uses if no speaker was found
+	if (result == -1) {
+		bool flag = _vm->readFlags(FLAG_PLAYER_IS_HOLMES);
+
+		if (_data[HOLMES]->_type == CHARACTER && ((speaker == HOLMES && flag) || (speaker == WATSON && !flag)))
+			// Return the offset index for the first character
+			return 0 + CHARACTERS_INDEX;
+
+		// Otherwise, scan through the list of the remaining characters to find a name match
+		for (uint idx = 1; idx < _data.size(); ++idx) {
+			TattooPerson &p = (*this)[idx];
+
+			if (p._type == CHARACTER) {
+				Common::String name(p._name.c_str(), p._name.c_str() + 4);
+
+				if (name.equalsIgnoreCase(portrait) && p._npcName[4] >= '0' && p._npcName[4] <= '9')
+					return idx + CHARACTERS_INDEX;
+			}
+		}
+	}
+
+	return result;
+}
+
+void TattooPeople::synchronize(Serializer &s) {
+	s.syncAsByte(_holmesOn);
+
+	for (uint idx = 0; idx < _data.size(); ++idx)
+		(*this)[idx].synchronize(s);
+
+	s.syncAsSint16LE(_holmesQuotient);
+
+	if (s.isLoading()) {
+		_savedPos.x = _data[HOLMES]->_position.x;
+		_savedPos.y = _data[HOLMES]->_position.y;
+		_savedPos._facing = _data[HOLMES]->_sequenceNumber;
+	}
+}
+
+bool TattooPeople::loadWalk() {
+	Resources &res = *_vm->_res;
+	bool result = false;
+
+	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+		Person &person = *_data[idx];
+
+		if (!person._walkLoaded && (person._type == CHARACTER || person._type == HIDDEN_CHARACTER)) {
+			if (person._type == HIDDEN_CHARACTER)
+				person._type = INVALID;
+
+			// See if this is one of the more used Walk Graphics stored in WALK.LIB
+			for (int libNum = 0; libNum < NUM_IN_WALK_LIB; ++libNum) {
+				if (!person._walkVGSName.compareToIgnoreCase(WALK_LIB_NAMES[libNum])) {
+					_useWalkLib = true;
+					break;
+				}
+			}
+
+			// Load the images for the character
+			person._images = new ImageFile(person._walkVGSName, false);
+			person._maxFrames = person._images->size();
+
+			// Load walk sequence data
+			Common::String fname = Common::String(person._walkVGSName.c_str(), strchr(person._walkVGSName.c_str(), '.'));
+			fname += ".SEQ";
+
+			// Load the walk sequence data
+			Common::SeekableReadStream *stream = res.load(fname, _useWalkLib ? "walk.lib" : "vgs.lib");
+				
+			person._walkSequences.resize(stream->readByte());
+
+			for (uint seqNum = 0; seqNum < person._walkSequences.size(); ++seqNum)
+				person._walkSequences[seqNum].load(*stream);
+
+			// Close the sequences resource
+			delete stream;
+			_useWalkLib = false;
+
+			person._sequences = &person._walkSequences[person._sequenceNumber]._sequences[0];
+			person._seqSize = person._walkSequences[person._sequenceNumber]._sequences.size();
+			person._frameNumber = 0;
+			person.setImageFrame();
+
+			// Set the stop Frames pointers
+			for (int dirNum = 0; dirNum < 8; ++dirNum) {
+				int count = 0;
+				while (person._walkSequences[dirNum + 8][count] != 0)
+					++count;
+				count += 2;
+				count = person._walkSequences[dirNum + 8][count] - 1;
+				person._stopFrames[dirNum] = &(*person._images)[count];
+			}
+
+			result = true;
+			person._walkLoaded = true;
+		} else if (person._type != CHARACTER) {
+			person._walkLoaded = false;
+		}
+	}
+
+	_forceWalkReload = false;
+	return result;
+}
+
+
+void TattooPeople::pullNPCPaths() {
+	for (int idx = 1; idx < MAX_CHARACTERS; ++idx) {
+		TattooPerson &p = (*this)[idx];
+		if (p._npcMoved) {
+			while (!p._pathStack.empty())
+				p.pullNPCPath();
+		}
+	}
+}
+
+const Common::Point TattooPeople::restrictToZone(int zoneId, const Common::Point &destPos) {
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Common::Rect &r = scene._zones[zoneId];
+
+	if (destPos.x < 0 || destPos.x > screen._backBuffer1.w())
+		return destPos;
+	else if (destPos.y < r.top && r.left < destPos.x && destPos.x < r.right)
+		return Common::Point(destPos.x, r.top);
+	else if (destPos.y > r.bottom && r.left < destPos.x && destPos.x < r.right)
+		return Common::Point(destPos.x, r.bottom);
+	else if (destPos.x < r.left && r.top < destPos.y && destPos.y < r.bottom)
+		return Common::Point(r.left, destPos.y);
+	else if (destPos.x > r.right && r.top < destPos.y && destPos.y < r.bottom)
+		return Common::Point(r.right, destPos.y);
+
+	// Find which corner of the zone the point is closet to
+	if (destPos.x <= r.left) {
+		return Common::Point(r.left, (destPos.y <= r.top) ? r.top : r.bottom);
+	} else {
+		return Common::Point(r.right, (destPos.y <= r.top) ? r.top : r.bottom);
+	}
+}
+
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_people.h b/engines/sherlock/tattoo/tattoo_people.h
new file mode 100644
index 0000000000..e0d53c67dd
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_people.h
@@ -0,0 +1,281 @@
+/* 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 SHERLOCK_TATTOO_PEOPLE_H
+#define SHERLOCK_TATTOO_PEOPLE_H
+
+#include "common/scummsys.h"
+#include "common/stack.h"
+#include "sherlock/people.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+// Animation sequence identifiers for characters
+enum TattooSequences {
+	// Walk Sequences Numbers for NPCs
+	WALK_UP			= 0,
+	WALK_UPRIGHT		= 1,
+	WALK_RIGHT		= 2,
+	WALK_DOWNRIGHT	= 3,
+	WALK_DOWN		= 4,
+	WALK_DOWNLEFT	= 5,
+	WALK_LEFT		= 6,
+	WALK_UPLEFT		= 7,
+
+	// Stop Sequences Numbers for NPCs
+	STOP_UP			= 8,
+	STOP_UPRIGHT		= 9,
+	STOP_RIGHT		= 10,
+	STOP_DOWNRIGHT	= 11,
+	STOP_DOWN		= 12,
+	STOP_DOWNLEFT	= 13,
+	STOP_LEFT		= 14,
+	STOP_UPLEFT		= 15,
+
+	// NPC Talk Sequence Numbers
+	TALK_UPRIGHT		= 16,
+	TALK_RIGHT		= 17,
+	TALK_DOWNRIGHT	= 18,
+	TALK_DOWNLEFT	= 19,
+	TALK_LEFT		= 20,
+	TALK_UPLEFT		= 21,
+
+	// NPC Listen Sequence Numbers
+	LISTEN_UPRIGHT	= 22,      
+	LISTEN_RIGHT		= 23,
+	LISTEN_DOWNRIGHT	= 24,
+	LISTEN_DOWNLEFT	= 25,
+	LISTEN_LEFT		= 26,
+	LISTEN_UPLEFT	= 27
+};
+
+enum NpcPath {
+	NPCPATH_SET_DEST		= 1,
+	NPCPATH_PAUSE			= 2,
+	NPCPATH_SET_TALK_FILE	= 3,
+	NPCPATH_CALL_TALK_FILE	= 4,
+	NPCPATH_TAKE_NOTES		= 5,
+	NPCPATH_FACE_HOLMES		= 6,
+	NPCPATH_PATH_LABEL		= 7,
+	NPCPATH_GOTO_LABEL		= 8,
+	NPCPATH_IFFLAG_GOTO_LABEL = 9
+};
+
+struct SavedNPCPath {
+	byte _path[MAX_NPC_PATH];
+	int _npcIndex;
+	int _npcPause;
+	Point32 _position;
+	int _npcFacing;
+	bool _lookHolmes;
+
+	SavedNPCPath();
+	SavedNPCPath(byte path[MAX_NPC_PATH], int npcIndex, int npcPause, const Point32 &position,
+		int npcFacing, bool lookHolmes);
+};
+
+class TattooPerson: public Person {
+private:
+	Point32 _nextDest;
+private:
+	bool checkCollision() const;
+
+	/**
+	 * Free the alternate graphics used by NPCs
+	 */
+	void freeAltGraphics();
+protected:
+	/**
+	 * Get the source position for a character potentially affected by scaling
+	 */
+	virtual Common::Point getSourcePoint() const;
+public:
+	Common::Stack<SavedNPCPath> _pathStack;
+	int _npcIndex;
+	int _npcPause;
+	byte _npcPath[MAX_NPC_PATH];
+	bool _npcMoved;
+	int _npcFacing;
+	bool _resetNPCPath;
+	int _savedNpcSequence;
+	int _savedNpcFrame;
+	int _tempX;
+	int _tempScaleVal;
+	bool _updateNPCPath;
+	bool _lookHolmes;
+public:
+	TattooPerson();
+	virtual ~TattooPerson();
+
+	/**
+	 * Clear the NPC related data
+	 */
+	void clearNPC();
+
+	/**
+	 * Called from doBgAnim to move NPCs along any set paths. If an NPC is paused in his path,
+	 * he will remain paused until his pause timer runs out. If he is walking somewhere,
+	 * he will continue walking there until he reaches the dest position. When an NPC stops moving,
+	 * the next element of his path is processed.
+	 *
+	 * The path is an array of bytes with control codes followed by their parameters as needed.
+	 */
+	void updateNPC();
+
+	/**
+	 * Push the NPC's path data onto the path stack for when a talk file moves the NPC that
+	 * has some control codes.
+	 */
+	void pushNPCPath();
+
+	/**
+	 * Pull an NPC's path data that has been previously saved on the path stack for that character.
+	 * There are two possibilities for when the NPC was interrupted, and both are handled differently:
+	 * 1) The NPC was paused at a position
+	 * If the NPC didn't move, we can just restore his pause counter and exit. But if he did move,
+	 * he must return to that position, and the path index must be reset to the pause he was executing.
+	 * This means that the index must be decremented by 3
+	 * 2) The NPC was in route to a position
+	 * He must be set to walk to that position again. This is done by moving the path index
+	 * so that it points to the code that set the NPC walking there in the first place. 
+	 * The regular calls to updateNPC will handle the rest
+	 */
+	void pullNPCPath();
+
+	/**
+	 * Checks a sprite associated with an NPC to see if the frame sequence specified
+	 * in the sequence number uses alternate graphics, and if so if they need to be loaded
+	 */
+	void checkWalkGraphics();
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	void synchronize(Serializer &s);
+
+
+	/**
+	 * Walk Holmes to the NPC
+	 */
+	void walkHolmesToNPC();
+
+	/**
+	 * Walk both the specified character and Holmes to specified destination positions
+	 */
+	void walkBothToCoords(const PositionFacing &holmesDest, const PositionFacing &npcDest);
+
+	/**
+	 * This adjusts the sprites position, as well as its animation sequence:
+	 */
+	virtual void adjustSprite();
+
+	/**
+	 * Bring a moving character to a standing position
+	 */
+	virtual void gotoStand();
+
+	/**
+	 * Set the variables for moving a character from one poisition to another
+	 * in a straight line
+	 */
+	virtual void setWalking();
+
+	/**
+	 * Walk to the co-ordinates passed, and then face the given direction
+	 */
+	virtual void walkToCoords(const Point32 &destPos, int destDir);
+
+	/**
+	 * Adjusts the frame and sequence variables of a sprite that corresponds to the current speaker
+	 * so that it points to the beginning of the sequence number's talk sequence in the object's
+	 * sequence buffer
+	 * @param seq	Which sequence to use (if there's more than 1)
+	 * @remarks		1: First talk seq, 2: second talk seq, etc.
+	 */
+	virtual void setObjTalkSequence(int seq);
+
+	/**
+	 * Center the visible screen so that the person is in the center of the screen
+	 */
+	virtual void centerScreenOnPerson();
+};
+
+class TattooPeople : public People {
+public:
+	TattooPeople(SherlockEngine *vm);
+	virtual ~TattooPeople() {}
+
+	TattooPerson &operator[](PeopleId id) { return *(TattooPerson *)_data[id]; }
+	TattooPerson &operator[](int idx) { return *(TattooPerson *)_data[idx]; }
+
+	/**
+	 * Restore any saved NPC walk path data from any of the NPCs
+	 */
+	void pullNPCPaths();
+
+	/**
+	 * Finds the scene background object corresponding to a specified speaker
+	 */
+	virtual int findSpeaker(int speaker);
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	virtual void synchronize(Serializer &s);
+
+	/**
+	 * Change the sequence of the scene background object associated with the specified speaker.
+	 */
+	virtual void setTalkSequence(int speaker, int sequenceNum = 1);
+
+	/**
+	 * Load the walking images for Sherlock
+	 */
+	virtual bool loadWalk();
+
+	/**
+	 * Restrict passed point to zone using Sherlock's positioning rules
+	 */
+	virtual const Common::Point restrictToZone(int zoneId, const Common::Point &destPos);
+
+	/**
+	 * If the specified speaker is a background object, it will set it so that it uses 
+	 * the Listen Sequence (specified by the sequence number). If the current sequence 
+	 * has an Allow Talk Code in it, the _gotoSeq field will be set so that the object 
+	 * begins listening as soon as it hits the Allow Talk Code. If there is no Abort Code, 
+	 * the Listen Sequence will begin immediately.
+	 * @param speaker		Who is speaking
+	 * @param sequenceNum	Which listen sequence to use
+	 */
+	virtual void setListenSequence(int speaker, int sequenceNum = 1);
+};
+
+} // End of namespace Scalpel
+
+} // End of namespace Sherlock
+
+
+#endif
diff --git a/engines/sherlock/tattoo/tattoo_resources.cpp b/engines/sherlock/tattoo/tattoo_resources.cpp
new file mode 100644
index 0000000000..4b73356d58
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_resources.cpp
@@ -0,0 +1,131 @@
+/* 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 "sherlock/tattoo/tattoo_resources.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+const PeopleData PEOPLE_DATA[TATTOO_MAX_PEOPLE] = { 
+	{ "HOLM", kFixedText_People_SherlockHolmes },
+	{ "WATS", kFixedText_People_DrWatson },
+	{ "HUDS", kFixedText_People_MrsHudson },
+	{ "FORB", kFixedText_People_StanleyForbes },
+	{ "MYCR", kFixedText_People_MycroftHolmes },
+	{ "WIGG", kFixedText_People_Wiggins },
+	{ "BURN", kFixedText_People_PoliceConstableBurns },
+	{ "TRIM", kFixedText_People_AugustusTrimble },
+	{ "DALE", kFixedText_People_PoliceConstableDaley },
+	{ "MATR", kFixedText_People_Matron },
+	{ "GRAC", kFixedText_People_SisterGrace },
+	{ "MCCA", kFixedText_People_PrestonMcCabe },
+	{ "COLL", kFixedText_People_BobColleran },
+	{ "JONA", kFixedText_People_JonasRigby },
+	{ "ROAC", kFixedText_People_PoliceConstableRoach },
+	{ "DEWA", kFixedText_People_JamesDewar },
+	{ "JERE", kFixedText_People_SergeantJeremyDuncan },
+	{ "GREG", kFixedText_People_InspectorGregson },
+	{ "LEST", kFixedText_People_InspectorLestrade },
+	{ "NEED", kFixedText_People_JesseNeedhem },
+	{ "FLEM", kFixedText_People_ArthurFleming },
+	{ "PRAT", kFixedText_People_MrThomasPratt },
+	{ "TILL", kFixedText_People_MathildaTillieMason },
+	{ "RUSS", kFixedText_People_AdrianRussell },
+	{ "WHIT", kFixedText_People_EldridgeWhitney },
+	{ "HEPP", kFixedText_People_Hepplethwaite },
+	{ "HORA", kFixedText_People_HoraceSilverbridge },
+	{ "SHER", kFixedText_People_OldSherman },
+	{ "VERN", kFixedText_People_MaxwellVerner },
+	{ "REDD", kFixedText_People_MillicentRedding },
+	{ "VIRG", kFixedText_People_VirgilSilverbridge },
+	{ "GEOR", kFixedText_People_GeorgeOKeeffe },
+	{ "LAWT", kFixedText_People_LordDenysLawton },
+	{ "JENK", kFixedText_People_Jenkins },
+	{ "JOCK", kFixedText_People_JockMahoney },
+	{ "BART", kFixedText_People_Bartender },
+	{ "LADY", kFixedText_People_LadyCordeliaLockridge },
+	{ "PETT", kFixedText_People_Pettigrew },
+	{ "FANS", kFixedText_People_SirAveryFanshawe },
+	{ "HODG", kFixedText_People_Hodgkins },
+	{ "WILB", kFixedText_People_WilburBirdyHeywood },
+	{ "JACO", kFixedText_People_JacobFarthington },
+	{ "BLED", kFixedText_People_PhilipBledsoe },
+	{ "FOWL", kFixedText_People_SidneyFowler },
+	{ "PROF", kFixedText_People_ProfessorTheodoreTotman },
+	{ "ROSE", kFixedText_People_RoseHinchem },
+	{ "TALL", kFixedText_People_Tallboy },
+	{ "STIT", kFixedText_People_EthlebertStitchRumsey },
+	{ "FREE", kFixedText_People_CharlesFreedman },
+	{ "HEMM", kFixedText_People_NigelHemmings },
+	{ "CART", kFixedText_People_FairfaxCarter },
+	{ "WILH", kFixedText_People_WilhelmII },
+	{ "WACH", kFixedText_People_Wachthund },
+	{ "WILS", kFixedText_People_JonathanWilson },
+	{ "DAVE", kFixedText_People_DavidLloydJones },
+	{ "HARG", kFixedText_People_EdwardHargrove },
+	{ "MORI", kFixedText_People_Misteray },
+	{ "LASC", kFixedText_People_TheLascar },
+	{ "PARR", kFixedText_People_Parrot },
+	{ "SCAR", kFixedText_People_VincentScarrett },
+	{ "ALEX", kFixedText_People_Alexandra },
+	{ "QUEE", kFixedText_People_QueenVictoria },
+	{ "JOHN", kFixedText_People_JohnBrown },
+	{ "PAT1", kFixedText_People_APatient1 },
+	{ "PAT2", kFixedText_People_APatient2 },
+	{ "PATR", kFixedText_People_Patron },
+	{ "QUEN", kFixedText_People_QueenVictoria },
+	{ "WITE", kFixedText_People_PatientInWhite },
+	{ "LUSH", kFixedText_People_Lush },
+	{ "DRNK", kFixedText_People_Drunk },
+	{ "PROS", kFixedText_People_Prostitute },
+	{ "MUDL", kFixedText_People_Mudlark },
+	{ "GRIN", kFixedText_People_Grinder },
+	{ "BOUN", kFixedText_People_Bouncer },
+	{ "RATC", kFixedText_People_AgnesRatchet },
+	{ "ALOY", kFixedText_People_AloysiusRatchet },
+	{ "REAL", kFixedText_People_RealEstateAgent },
+	{ "CAND", kFixedText_People_CandyClerk },
+	{ "BEAD", kFixedText_People_Beadle },
+	{ "PRUS", kFixedText_People_Prussian },
+	{ "ROWB", kFixedText_People_MrsRowbottom },
+	{ "MSLJ", kFixedText_People_MissLloydJones },
+	{ "TPAT", kFixedText_People_TavernPatron },
+	{ "USER", kFixedText_People_User },
+	{ "TOBY", kFixedText_People_Toby },
+	{ "STAT", kFixedText_People_Stationer },
+	{ "CLRK", kFixedText_People_LawClerk },
+	{ "CLER", kFixedText_People_MinistryClerk },
+	{ "BATH", kFixedText_People_Bather },
+	{ "MAID", kFixedText_People_Maid },
+	{ "LADF", kFixedText_People_LadyFanshawe },
+	{ "SIDN", kFixedText_People_SidneyRatchet },
+	{ "BOYO", kFixedText_People_Boy },
+	{ "PTR2", kFixedText_People_Patron2 },
+	{ "BRIT", kFixedText_People_ConstableBrit },
+	{ "DROV", kFixedText_People_WagonDriver }
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_resources.h b/engines/sherlock/tattoo/tattoo_resources.h
new file mode 100644
index 0000000000..85a78734b9
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_resources.h
@@ -0,0 +1,45 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_TATTOO_RESOURCES_H
+#define SHERLOCK_TATTOO_RESOURCES_H
+
+#include "common/scummsys.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+#define TATTOO_MAX_PEOPLE 96
+
+struct PeopleData {
+	const char *portrait;
+	int fixedTextId;
+};
+
+extern const PeopleData PEOPLE_DATA[TATTOO_MAX_PEOPLE];
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/tattoo_scene.cpp b/engines/sherlock/tattoo/tattoo_scene.cpp
new file mode 100644
index 0000000000..27f37665dc
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_scene.cpp
@@ -0,0 +1,865 @@
+/* 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 "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_people.h"
+#include "sherlock/tattoo/tattoo_talk.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/events.h"
+#include "sherlock/people.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+const int FS_TRANS[8] = {
+	STOP_UP, STOP_UPRIGHT, STOP_RIGHT, STOP_DOWNRIGHT, STOP_DOWN, STOP_DOWNLEFT, STOP_LEFT, STOP_UPLEFT
+};
+
+/*----------------------------------------------------------------*/
+
+struct ShapeEntry {
+	Object *_shape;
+	TattooPerson *_person;
+	bool _isAnimation;
+	int _yp;
+	int _ordering;
+
+	ShapeEntry(TattooPerson *person, int yp, int ordering) :
+		_shape(nullptr), _person(person), _yp(yp), _isAnimation(false), _ordering(ordering) {}
+	ShapeEntry(Object *shape, int yp, int ordering) :
+		_shape(shape), _person(nullptr), _yp(yp), _isAnimation(false), _ordering(ordering) {}
+	ShapeEntry(int yp, int ordering) : 
+		_shape(nullptr), _person(nullptr), _yp(yp), _isAnimation(true), _ordering(ordering) {}
+};
+typedef Common::List<ShapeEntry> ShapeList;
+
+static bool sortImagesY(const ShapeEntry &s1, const ShapeEntry &s2) {
+	// Objects are order by the calculated Y position first and then, when both are equal,
+	// by the order in which the entries were added
+	return s1._yp < s2._yp || (s1._yp == s2._yp && s1._ordering < s2._ordering);
+}
+
+/*----------------------------------------------------------------*/
+
+TattooScene::TattooScene(SherlockEngine *vm) : Scene(vm), _labWidget(vm) {
+	_labTableScene = false;
+}
+
+bool TattooScene::loadScene(const Common::String &filename) {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Events &events = *_vm->_events;
+	Music &music = *_vm->_music;
+	Talk &talk = *_vm->_talk;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	// If we're going to the first game scene after the intro sequence, flag it as finished
+	if (vm._runningProlog && _currentScene == STARTING_GAME_SCENE) {
+		vm._runningProlog = false;
+		events.showCursor();
+		talk._talkToAbort = false;
+	}
+
+	// Check if it's a scene we need to keep trakc track of how many times we've visited
+	for (int idx = (int)_sceneTripCounters.size() - 1; idx >= 0; --idx) {
+		if (_sceneTripCounters[idx]._sceneNumber == _currentScene) {
+			if (--_sceneTripCounters[idx]._numTimes == 0) {
+				_vm->setFlags(_sceneTripCounters[idx]._flag);
+				_sceneTripCounters.remove_at(idx);
+			}
+		}
+	}
+
+	// Handle loading music for the scene
+	if (talk._scriptMoreFlag != 1 && talk._scriptMoreFlag != 3)
+		music._nextSongName = Common::String::format("res%02d", _currentScene);
+
+	// Set the NPC paths for the scene
+	setNPCPath(WATSON);
+
+	// If it's a new song, then start it up
+	if (music._currentSongName.compareToIgnoreCase(music._nextSongName)) {
+		// WORKAROUND: Stop playing music after Diogenes fire scene in the intro, 
+		// since it overlaps slightly into the next scene
+		if (talk._scriptName == "prol80p" && _currentScene == 80) {
+			music.stopMusic();
+			events.wait(5);
+		}
+
+		if (music.loadSong(music._nextSongName)) {
+			if (music._musicOn)
+				music.startSong();
+		}
+	}
+
+	bool result = Scene::loadScene(filename);
+
+	if (_currentScene != STARTING_INTRO_SCENE) {
+		// Set the menu/ui mode and whether we're in a lab table close-up scene
+		_labTableScene = _currentScene > 91 && _currentScene < 100;
+		ui._menuMode = _labTableScene ? LAB_MODE : STD_MODE;
+
+		if (_labTableScene)
+			ui.addFixedWidget(&_labWidget);
+	}
+
+	return result;
+}
+
+void TattooScene::drawAllShapes() {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Screen &screen = *_vm->_screen;
+	ShapeList shapeList;
+	int ordering = 0;
+
+	// Draw all objects and animations that are set to behind
+	screen.setDisplayBounds(Common::Rect(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+
+	// Draw all active shapes which are behind the person
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &obj = _bgShapes[idx];
+
+		if (obj._type == ACTIVE_BG_SHAPE && obj._misc == BEHIND) {
+			if (obj._quickDraw && obj._scaleVal == SCALE_THRESHOLD)
+				screen._backBuffer1.blitFrom(*obj._imageFrame, obj._position);
+			else
+				screen._backBuffer1.transBlitFrom(*obj._imageFrame, obj._position, obj._flags & OBJ_FLIPPED, 0, obj._scaleVal);
+		}
+	}
+
+	// Draw the animation if it is behind the person
+	if (_activeCAnim.active() && _activeCAnim._zPlacement == BEHIND)
+		screen._backBuffer1.transBlitFrom(_activeCAnim._imageFrame, _activeCAnim._position,
+			(_activeCAnim._flags & 4) >> 1, 0, _activeCAnim._scaleVal);
+
+	screen.resetDisplayBounds();
+
+	// Queue drawing of all objects that are set to NORMAL.
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &obj = _bgShapes[idx];
+
+		if (obj._type == ACTIVE_BG_SHAPE && (obj._misc == NORMAL_BEHIND || obj._misc == NORMAL_FORWARD)) {
+			if (obj._scaleVal == SCALE_THRESHOLD)
+				shapeList.push_back(ShapeEntry(&obj, obj._position.y + obj._imageFrame->_offset.y +
+					obj._imageFrame->_height, ordering++));
+			else
+				shapeList.push_back(ShapeEntry(&obj, obj._position.y + obj._imageFrame->sDrawYOffset(obj._scaleVal) +
+					obj._imageFrame->sDrawYSize(obj._scaleVal), ordering++));
+		}
+	}
+
+	// Queue drawing the animation if it is NORMAL and can fall in front of, or behind the people
+	if (_activeCAnim.active() && (_activeCAnim._zPlacement == NORMAL_BEHIND || _activeCAnim._zPlacement == NORMAL_FORWARD)) {
+		if (_activeCAnim._scaleVal == SCALE_THRESHOLD)
+			shapeList.push_back(ShapeEntry(_activeCAnim._position.y + _activeCAnim._imageFrame._offset.y +
+				_activeCAnim._imageFrame._height, ordering++));
+		else
+			shapeList.push_back(ShapeEntry(_activeCAnim._position.y + _activeCAnim._imageFrame.sDrawYOffset(_activeCAnim._scaleVal) +
+				_activeCAnim._imageFrame.sDrawYSize(_activeCAnim._scaleVal), ordering++));
+	}
+
+	// Queue all active characters for drawing
+	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+		if (people[idx]._type == CHARACTER && people[idx]._walkLoaded)
+			shapeList.push_back(ShapeEntry(&people[idx], people[idx]._position.y / FIXED_INT_MULTIPLIER, ordering++));
+	}
+
+	// Sort the list
+	Common::sort(shapeList.begin(), shapeList.end(), sortImagesY);
+
+	// Draw the list of shapes in order
+	for (ShapeList::iterator i = shapeList.begin(); i != shapeList.end(); ++i) {
+		ShapeEntry &se = *i;
+
+		if (se._shape) {
+			// it's a bg shape
+			if (se._shape->_quickDraw && se._shape->_scaleVal == SCALE_THRESHOLD)
+				screen._backBuffer1.blitFrom(*se._shape->_imageFrame, se._shape->_position);
+			else
+				screen._backBuffer1.transBlitFrom(*se._shape->_imageFrame, se._shape->_position,
+					se._shape->_flags & OBJ_FLIPPED, 0, se._shape->_scaleVal);
+		} else if (se._isAnimation) {
+			// It's an active animation
+			screen._backBuffer1.transBlitFrom(_activeCAnim._imageFrame, _activeCAnim._position,
+				(_activeCAnim._flags & 4) >> 1, 0, _activeCAnim._scaleVal);
+		} else {
+			// Drawing person
+			TattooPerson &p = *se._person;
+
+			p._tempX = p._position.x / FIXED_INT_MULTIPLIER;
+			p._tempScaleVal = getScaleVal(p._position);
+			Common::Point adjust = p._adjust;
+
+			if (p._tempScaleVal == SCALE_THRESHOLD) {
+				p._tempX += adjust.x;
+				screen._backBuffer1.transBlitFrom(*p._imageFrame, Common::Point(p._tempX, p._position.y / FIXED_INT_MULTIPLIER
+					- p.frameHeight() - adjust.y), p._walkSequences[p._sequenceNumber]._horizFlip, 0, p._tempScaleVal);
+			} else {
+				if (adjust.x) {
+					if (!p._tempScaleVal)
+						++p._tempScaleVal;
+
+					if (p._tempScaleVal >= SCALE_THRESHOLD && adjust.x)
+						--adjust.x;
+
+					adjust.x = adjust.x * SCALE_THRESHOLD / p._tempScaleVal;
+
+					if (p._tempScaleVal >= SCALE_THRESHOLD)
+						++adjust.x;
+					p._tempX += adjust.x;
+				}
+
+				if (adjust.y) {
+					if (!p._tempScaleVal)
+						p._tempScaleVal++;
+
+					if (p._tempScaleVal >= SCALE_THRESHOLD && adjust.y)
+						--adjust.y;
+
+					adjust.y = adjust.y * SCALE_THRESHOLD / p._tempScaleVal;
+
+					if (p._tempScaleVal >= SCALE_THRESHOLD)
+						++adjust.y;
+				}
+
+				screen._backBuffer1.transBlitFrom(*p._imageFrame, Common::Point(p._tempX, p._position.y / FIXED_INT_MULTIPLIER
+					- p._imageFrame->sDrawYSize(p._tempScaleVal) - adjust.y), p._walkSequences[p._sequenceNumber]._horizFlip, 0, p._tempScaleVal);
+			}
+		}
+	}
+
+	// Draw all objects & canimations that are set to FORWARD.
+	// Draw all static and active shapes that are FORWARD
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &obj = _bgShapes[idx];
+
+		if (obj._type == ACTIVE_BG_SHAPE && obj._misc == FORWARD) {
+			if (obj._quickDraw && obj._scaleVal == SCALE_THRESHOLD)
+				screen._backBuffer1.blitFrom(*obj._imageFrame, obj._position);
+			else
+				screen._backBuffer1.transBlitFrom(*obj._imageFrame, obj._position, obj._flags & OBJ_FLIPPED, 0, obj._scaleVal);
+		}
+	}
+
+	// Draw the canimation if it is set as FORWARD
+	if (_activeCAnim.active() && _activeCAnim._zPlacement == FORWARD)
+		screen._backBuffer1.transBlitFrom(_activeCAnim._imageFrame, _activeCAnim._position, (_activeCAnim._flags & 4) >> 1, 0, _activeCAnim._scaleVal);
+
+	// Draw all NO_SHAPE shapes which have their flag bits clear
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &obj = _bgShapes[idx];
+		if (obj._type == NO_SHAPE && (obj._flags & 1) == 0)
+			screen._backBuffer1.fillRect(obj.getNoShapeBounds(), 15);
+	}
+}
+
+void TattooScene::paletteLoaded() {
+	Screen &screen = *_vm->_screen;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	ui.setupBGArea(screen._cMap);
+	ui.initScrollVars();
+}
+
+void TattooScene::checkBgShapes() {
+	// Call the base scene method to handle bg shapes
+	Scene::checkBgShapes();
+
+	// Check for any active playing animation
+	if (_activeCAnim.active() && _activeCAnim._zPlacement != REMOVE) {
+		switch (_activeCAnim._flags & 3) {
+		case 0:
+			_activeCAnim._zPlacement = BEHIND;
+			break;
+		case 1:
+			_activeCAnim._zPlacement = ((_activeCAnim._position.y + _activeCAnim._imageFrame._frame.h - 1)) ?
+				NORMAL_FORWARD : NORMAL_BEHIND;
+			break;
+		case 2:
+			_activeCAnim._zPlacement = FORWARD;
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+void TattooScene::freeScene() {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Scene::freeScene();
+
+	// Delete any scene overlays that were used by the scene
+	delete ui._mask;
+	delete ui._mask1;
+	ui._mask = ui._mask1 = nullptr;
+}
+
+void TattooScene::doBgAnimCheckCursor() {
+	Events &events = *_vm->_events;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+
+	// If we're in Look Mode, make sure the cursor is the magnifying glass
+	if (ui._menuMode == LOOK_MODE && events.getCursor() != MAGNIFY)
+		events.setCursor(MAGNIFY);
+
+	// See if the mouse is over any of the arrow zones, and if so, change the cursor to the correct
+	// arrow cursor indicating the direcetion of the exit
+	if (events.getCursor() == ARROW || events.getCursor() >= EXIT_ZONES_START) {
+		CursorId cursorId = ARROW;
+
+		if (ui._menuMode == STD_MODE && ui._arrowZone != -1 && _currentScene != 90) {
+			for (uint idx = 0; idx < _exits.size(); ++idx) {
+				Exit &exit = _exits[idx];
+				if (exit.contains(mousePos))
+					cursorId = (CursorId)(exit._image + EXIT_ZONES_START);
+			}
+		}
+
+		events.setCursor(cursorId);
+	} else {
+		events.animateCursorIfNeeded();
+	}
+}
+
+void TattooScene::doBgAnim() {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Events &events = *_vm->_events;
+	Music &music = *_vm->_music;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	TattooUserInterface &ui = *((TattooUserInterface *)_vm->_ui);
+
+	doBgAnimCheckCursor();
+	music.checkSongProgress();
+
+	talk._talkToAbort = false;
+
+	// Check the characters and sprites for updates
+	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+		if (people[idx]._type == CHARACTER)
+			people[idx].checkSprite();
+	}
+	
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		if (_bgShapes[idx]._type == ACTIVE_BG_SHAPE)
+			_bgShapes[idx].checkObject();
+	}
+
+	// If one of the objects has signalled a call to a talk file, to go to another scene, exit immediately
+	if (_goToScene != -1)
+		return;
+
+	// Erase any affected background areas
+	ui.doBgAnimEraseBackground();
+
+	doBgAnimUpdateBgObjectsAndAnim();
+
+	doBgAnimDrawSprites();
+
+	ui.drawInterface();
+
+	if (ui._creditsWidget.active())
+		ui._creditsWidget.blitCredits();
+
+	if (screen._flushScreen) {
+		screen.slamArea(screen._currentScroll.x, screen._currentScroll.y, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+		screen._flushScreen = false;
+	}
+
+	screen._flushScreen = false;
+	_doBgAnimDone = true;
+	ui._drawMenu = false;
+
+	// Handle drawing tooltips
+	if (ui._menuMode == STD_MODE || ui._menuMode == LAB_MODE)
+		ui._tooltipWidget.draw();
+	if (!ui._postRenderWidgets.empty()) {
+		for (WidgetList::iterator i = ui._postRenderWidgets.begin(); i != ui._postRenderWidgets.end(); ++i)
+			(*i)->draw();
+		ui._postRenderWidgets.clear();
+	}
+
+	if (!vm._fastMode)
+		events.wait(3);
+
+	for (int idx = 1; idx < MAX_CHARACTERS; ++idx) {
+		if (people[idx]._updateNPCPath)
+			people[idx].updateNPC();
+	}
+}
+
+void TattooScene::doBgAnimUpdateBgObjectsAndAnim() {
+	People &people = *_vm->_people;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &obj = _bgShapes[idx];
+		if (obj._type == ACTIVE_BG_SHAPE || obj._type == NO_SHAPE)
+			obj.adjustObject();
+	}
+
+	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+		if (people[idx]._type == CHARACTER)
+			people[idx].adjustSprite();
+	}
+
+	// Flag the bg shapes which need to be redrawn
+	checkBgShapes();
+	drawAllShapes();
+
+	ui.drawMaskArea(true);
+}
+
+void TattooScene::updateBackground() {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Screen &screen = *_vm->_screen;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	Scene::updateBackground();
+
+	ui.drawMaskArea(false);
+
+	screen._flushScreen = true;
+
+	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+		TattooPerson &p = people[idx];
+
+		if (p._type != INVALID) {
+			if (_goToScene == -1 || _cAnim.size() == 0) {
+				if (p._type == REMOVE) {
+					screen.slamArea(p._oldPosition.x, p._oldPosition.y, p._oldSize.x, p._oldSize.y);
+					p._type = INVALID;
+				} else {
+					if (p._tempScaleVal == SCALE_THRESHOLD) {
+						screen.flushImage(p._imageFrame, Common::Point(p._tempX, p._position.y / FIXED_INT_MULTIPLIER
+							- p._imageFrame->_width), &p._oldPosition.x, &p._oldPosition.y, &p._oldSize.x, &p._oldSize.y);
+					}  else {
+						int ts = p._imageFrame->sDrawYSize(p._tempScaleVal);
+						int ty = p._position.y / FIXED_INT_MULTIPLIER - ts;
+						screen.flushScaleImage(p._imageFrame, Common::Point(p._tempX, ty),
+							&p._oldPosition.x, &p._oldPosition.y, &p._oldSize.x, &p._oldSize.y, p._tempScaleVal);
+					}
+				}
+			}
+		}
+	}
+
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &obj = _bgShapes[idx];
+
+		if (obj._type == ACTIVE_BG_SHAPE || obj._type == REMOVE) {
+			if (_goToScene == -1) {
+				if (obj._scaleVal == SCALE_THRESHOLD)
+					screen.flushImage(obj._imageFrame, obj._position, &obj._oldPosition.x, &obj._oldPosition.y,
+						&obj._oldSize.x, &obj._oldSize.y);
+				else
+					screen.flushScaleImage(obj._imageFrame, obj._position, &obj._oldPosition.x, &obj._oldPosition.y,
+						&obj._oldSize.x, &obj._oldSize.y, obj._scaleVal);
+
+				if (obj._type == REMOVE)
+					obj._type = INVALID;
+			}
+		}
+	}
+
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &obj = _bgShapes[idx];
+
+		if (_goToScene == -1) {
+			if (obj._type == NO_SHAPE && (obj._flags & 1) == 0) {
+				screen.slamRect(obj.getNoShapeBounds());
+				screen.slamRect(obj.getOldBounds());
+			} else if (obj._type == HIDE_SHAPE) {
+				if (obj._scaleVal == SCALE_THRESHOLD)
+					screen.flushImage(obj._imageFrame, obj._position, &obj._oldPosition.x, &obj._oldPosition.y,
+						&obj._oldSize.x, &obj._oldSize.y);
+				else
+					screen.flushScaleImage(obj._imageFrame, obj._position, &obj._oldPosition.x, &obj._oldPosition.y,
+						&obj._oldSize.x, &obj._oldSize.y, obj._scaleVal);
+				obj._type = HIDDEN;
+			}
+		}
+	}
+
+	screen._flushScreen = false;
+}
+
+void TattooScene::doBgAnimDrawSprites() {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Screen &screen = *_vm->_screen;
+
+	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+		TattooPerson &person = people[idx];
+
+		if (person._type != INVALID) {
+			if (_goToScene == -1 || _cAnim.size() == 0) {
+				if (person._type == REMOVE) {
+					screen.slamRect(person.getOldBounds());
+					person._type = INVALID;
+				} else {
+					if (person._tempScaleVal == SCALE_THRESHOLD) {
+						screen.flushImage(person._imageFrame, Common::Point(person._tempX, person._position.y / FIXED_INT_MULTIPLIER
+							- person.frameHeight()), &person._oldPosition.x, &person._oldPosition.y, &person._oldSize.x, &person._oldSize.y);
+					}  else {
+						int ts = person._imageFrame->sDrawYSize(person._tempScaleVal);
+						int ty  = person._position.y / FIXED_INT_MULTIPLIER - ts;
+						screen.flushScaleImage(person._imageFrame, Common::Point(person._tempX, ty),
+							&person._oldPosition.x, &person._oldPosition.y, &person._oldSize.x, &person._oldSize.y, person._tempScaleVal);
+					}
+				}
+			}
+		}
+	}
+
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &obj = _bgShapes[idx];
+
+		if (obj._type == ACTIVE_BG_SHAPE || obj._type == REMOVE) {
+			if (_goToScene == -1) {
+				if (obj._scaleVal == SCALE_THRESHOLD)
+					screen.flushImage(obj._imageFrame, obj._position, &obj._oldPosition.x, &obj._oldPosition.y, 
+					&obj._oldSize.x, &obj._oldSize.y);
+				else
+					screen.flushScaleImage(obj._imageFrame, obj._position, &obj._oldPosition.x, &obj._oldPosition.y, 
+					&obj._oldSize.x, &obj._oldSize.y, obj._scaleVal);
+
+				if (obj._type == REMOVE)
+					obj._type = INVALID;
+			}
+		}
+	}
+
+	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
+		Object &obj = _bgShapes[idx];
+
+		if (_goToScene == -1) {
+			if (obj._type == NO_SHAPE && (obj._flags & 1) == 0) {
+				screen.slamRect(obj.getNoShapeBounds());
+				screen.slamRect(obj.getOldBounds());
+			} else if (obj._type == HIDE_SHAPE) {
+				if (obj._scaleVal == SCALE_THRESHOLD)
+					screen.flushImage(obj._imageFrame, obj._position, &obj._oldPosition.x, &obj._oldPosition.y,
+						&obj._oldSize.x, &obj._oldSize.y);
+				else
+					screen.flushScaleImage(obj._imageFrame, obj._position, &obj._oldPosition.x, &obj._oldPosition.y,
+						&obj._oldSize.x, &obj._oldSize.y, obj._scaleVal);
+				obj._type = HIDDEN;
+			}
+		}
+	}
+
+	if (_activeCAnim.active() || _activeCAnim._zPlacement == REMOVE) {
+		if (_activeCAnim._zPlacement != REMOVE) {
+			screen.flushImage(&_activeCAnim._imageFrame, _activeCAnim._position, _activeCAnim._oldBounds, _activeCAnim._scaleVal);
+		} else {
+			screen.slamRect(_activeCAnim._removeBounds);
+			_activeCAnim._removeBounds = Common::Rect(0, 0, 0, 0);
+			_activeCAnim._zPlacement = -1;		// Reset _zPlacement so we don't REMOVE again
+		}
+	}
+}
+
+int TattooScene::getScaleVal(const Point32 &pt) {
+	bool found = false;
+	int result = SCALE_THRESHOLD;
+	Common::Point pos(pt.x / FIXED_INT_MULTIPLIER, pt.y / FIXED_INT_MULTIPLIER);
+
+	for (uint idx = 0; idx < _scaleZones.size() && !found; ++idx) {
+		ScaleZone &sz = _scaleZones[idx];
+		if (sz.contains(pos)) {
+			int n = (sz._bottomNumber - sz._topNumber) * 100 / sz.height() * (pos.y - sz.top) / 100 + sz._topNumber;
+			result = 25600L / n;
+			// CHECKME: Shouldn't we set 'found' at this place?
+		}
+	}
+
+	// If it wasn't found, we may be off screen to the left or right, so find the scale zone 
+	// that would apply to the y val passed in disregarding the x
+	if (!found) {
+		for (uint idx = 0; idx < _scaleZones.size() && !found; ++idx) {
+			ScaleZone &sz = _scaleZones[idx];
+			if (pos.y >= sz.top && pos.y < sz.bottom) {
+				int n = (sz._bottomNumber - sz._topNumber) * 100 / sz.height() * (pos.y - sz.top) / 100 + sz._topNumber;
+				result = 25600L / n;
+			}
+		}
+	}
+
+	return result;
+}
+
+int TattooScene::startCAnim(int cAnimNum, int playRate) {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Events &events = *_vm->_events;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Resources &res = *_vm->_res;
+	Talk &talk = *_vm->_talk;
+	UserInterface &ui = *_vm->_ui;
+
+	// Exit immediately if the anim number is out of range, or the anim doesn't have a position specified
+	if (cAnimNum < 0 || cAnimNum >= (int)_cAnim.size() || _cAnim[cAnimNum]._position.x == -1)
+		// Return out of range error
+		return -1;
+
+	// Get the co-ordinates that the Player & NPC #1 must walk to and end on
+	CAnim &cAnim = _cAnim[cAnimNum];
+	PositionFacing goto1 = cAnim._goto[0];
+	PositionFacing goto2 = cAnim._goto[1];
+	PositionFacing teleport1 = cAnim._teleport[0];
+	PositionFacing teleport2 = cAnim._teleport[1];
+
+	// See if the Player must walk to a position before the animation starts
+	SpriteType savedPlayerType = people[HOLMES]._type;
+	if (goto1.x != -1 && people[HOLMES]._type == CHARACTER) {
+		if (people[HOLMES]._position != goto1)
+			people[HOLMES].walkToCoords(goto1, goto1._facing);
+	}
+
+	if (talk._talkToAbort)
+		return 1;
+
+	// See if NPC #1 must walk to a position before the animation starts
+	SpriteType savedNPCType = people[WATSON]._type;
+	if (goto2.x != -1 && people[WATSON]._type == CHARACTER) {
+		if (people[WATSON]._position != goto2)
+			people[WATSON].walkToCoords(goto2, goto2._facing);
+	}
+
+	if (talk._talkToAbort)
+		return 1;
+
+	// Turn the player (and NPC #1 if neccessary) off before running the canimation
+	if (teleport1.x != -1 && savedPlayerType == CHARACTER)
+		people[HOLMES]._type = REMOVE;
+
+	if (teleport2.x != -1 && savedNPCType == CHARACTER)
+		people[WATSON]._type = REMOVE;
+
+	if (ui._windowOpen)
+		ui.banishWindow();
+	
+	// Open up the room resource file and get the data for the animation
+	Common::SeekableReadStream *stream = res.load(_roomFilename);
+	stream->seek(44 + cAnimNum * 4);
+	stream->seek(stream->readUint32LE());
+	Common::SeekableReadStream *animStream = stream->readStream(cAnim._dataSize);
+	delete stream;
+
+	// Set up the active animation
+	_activeCAnim._position = cAnim._position;
+	_activeCAnim._oldBounds = Common::Rect(0, 0, 0, 0);
+	_activeCAnim._flags = cAnim._flags;
+	_activeCAnim._scaleVal = cAnim._scaleVal;
+	_activeCAnim._zPlacement = 0;
+
+	_activeCAnim.load(animStream, _compressed);
+
+	while (!_vm->shouldQuit()) {
+		// Get the next frame
+		if (!_activeCAnim.getNextFrame())
+			break;
+
+		// Draw the frame
+		doBgAnim();
+
+		// Check for Escape key being pressed to abort animation
+		events.pollEvents();
+		if (events.kbHit()) {
+			Common::KeyState keyState = events.getKey();
+
+			if (keyState.keycode == Common::KEYCODE_ESCAPE && vm._runningProlog) {
+				_vm->setFlags(-76);
+				_vm->setFlags(396);
+				_goToScene = STARTING_GAME_SCENE;
+				talk._talkToAbort = true;
+				_activeCAnim.close();
+				break;
+			}
+		}
+	}
+
+	// Turn the people back on
+	people[HOLMES]._type = savedPlayerType;
+	if (teleport2.x != -1)
+		people[WATSON]._type = savedNPCType;
+
+	// Teleport the Player to the ending coordinates if necessary
+	if (teleport1.x != -1 && savedPlayerType == CHARACTER) {
+		people[HOLMES]._position = teleport1;
+		people[HOLMES]._sequenceNumber = teleport1._facing;
+		people[HOLMES].gotoStand();
+	}
+
+	// Teleport Watson to the ending coordinates if necessary
+	if (teleport2.x != -1 && savedNPCType == CHARACTER) {
+		people[WATSON]._position = teleport2;
+		people[WATSON]._sequenceNumber = teleport2._facing;
+		people[WATSON].gotoStand();
+	}
+
+	// Flag the Canimation to be cleared
+	_activeCAnim._zPlacement = REMOVE;
+	_activeCAnim._removeBounds = _activeCAnim._oldBounds;
+	_vm->_ui->_bgFound = -1;
+
+	// Free up the animation
+	_activeCAnim.close();
+
+	return 1;
+}
+
+void TattooScene::setNPCPath(int npc) {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	SaveManager &saves = *_vm->_saves;
+	Talk &talk = *_vm->_talk;
+
+	// Don't do initial scene setup if a savegame has just been loaded
+	if (saves._justLoaded)
+		return;
+
+	people[npc].clearNPC();
+	people[npc]._npcName = Common::String::format("WATS%.2dA", _currentScene);
+
+	// If we're in the middle of a script that will continue once the scene is loaded,
+	// return without calling the path script
+	if (talk._scriptMoreFlag == 1 || talk._scriptMoreFlag == 3)
+		return;
+
+	// Turn off all the NPCs, since the talk script will turn them back on as needed
+	for (int idx = 1; idx < MAX_CHARACTERS; ++idx)
+		people[idx]._type = INVALID;
+
+	// Call the path script for the scene
+	Common::String pathFile = Common::String::format("PATH%.2dA", _currentScene);
+	talk.talkTo(pathFile);
+}
+
+int TattooScene::findBgShape(const Common::Point &pt) {
+	People &people = *_vm->_people;
+	UserInterface &ui = *_vm->_ui;
+
+	if (!_doBgAnimDone)
+		// New frame hasn't been drawn yet
+		return -1;
+
+	int result = -1;
+	for (int idx = (int)_bgShapes.size() - 1; idx >= 0 && result == -1; --idx) {
+		Object &o = _bgShapes[idx];
+
+		if (o._type != INVALID && o._type != NO_SHAPE && o._type != HIDDEN && 
+				(o._aType <= PERSON || (ui._menuMode == LAB_MODE && o._aType == SOLID))) {
+			if (o.getNewBounds().contains(pt))
+				result = idx;
+		} else if (o._type == NO_SHAPE) {
+			if (o.getNoShapeBounds().contains(pt))
+				result = idx;
+		}
+	}
+
+	// Now check for the mouse being over an NPC. If so, it overrides any found bg object
+	for (int idx = 1; idx < MAX_CHARACTERS; ++idx) {
+		Person &person = people[idx];
+
+		if (person._type == CHARACTER) {
+			int scaleVal = getScaleVal(person._position);
+			Common::Rect charRect;
+
+			if (scaleVal == SCALE_THRESHOLD)
+				charRect = Common::Rect(person.frameWidth(), person.frameHeight());
+			else
+				charRect = Common::Rect(person._imageFrame->sDrawXSize(scaleVal), person._imageFrame->sDrawYSize(scaleVal));
+			charRect.moveTo(person._position.x / FIXED_INT_MULTIPLIER, person._position.y / FIXED_INT_MULTIPLIER
+				- charRect.height());
+
+			if (charRect.contains(pt))
+				result = 1000 + idx;
+		}
+	}
+
+	return result;
+}
+
+void TattooScene::synchronize(Serializer &s) {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Scene::synchronize(s);
+
+	if (s.isLoading()) {
+		// In case we were showing the intro prologue or the ending credits, stop them
+		vm._runningProlog = false;
+		ui._creditsWidget.close();
+	}
+}
+
+int TattooScene::closestZone(const Common::Point &pt) {
+	int zone = -1;
+	int dist = 9999;
+
+	for (uint idx = 0; idx < _zones.size(); ++idx) {
+		Common::Rect &r = _zones[idx];
+
+		// Check the distance from the point to the center of the zone
+		int d = ABS(r.left + (r.width() / 2) - pt.x) + ABS(r.top + (r.height() / 2) - pt.y);
+		if (d < dist) {
+			dist = d;
+			zone = idx;
+		}
+
+		// Check the distance from the point to the upper left of the zone
+		d = ABS((int)(r.left - pt.x)) + ABS((int)(r.top - pt.y));
+		if (d < dist)
+		{
+			dist = d;
+			zone = idx;
+		}
+
+		// Check the distance from the point to the upper right of the zone
+		d = ABS(r.left + r.width() - pt.x) + ABS(r.top - pt.y);
+		if (d < dist) {
+			dist = d;
+			zone = idx;
+		}
+
+		// Check the distance from the point to the lower left of the zone
+		d = ABS(r.left - pt.x) + ABS(r.top + r.height() - pt.y);
+		if (d < dist) {
+			dist = d;
+			zone = idx;
+		}
+
+		// Check the distance from the point to the lower right of the zone
+		d = ABS(r.left + r.width() - pt.x) + ABS(r.top + r.height() - pt.y);
+		if (d < dist) {
+			dist = d;
+			zone = idx;
+		}
+	}
+
+	return zone;
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_scene.h b/engines/sherlock/tattoo/tattoo_scene.h
new file mode 100644
index 0000000000..678330077c
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_scene.h
@@ -0,0 +1,157 @@
+/* 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 SHERLOCK_TATTOO_SCENE_H
+#define SHERLOCK_TATTOO_SCENE_H
+
+#include "common/scummsys.h"
+#include "sherlock/scene.h"
+#include "sherlock/tattoo/widget_lab.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+extern const int FS_TRANS[8];
+
+enum {
+	STARTING_GAME_SCENE = 1, WEARY_PUNT = 52, TRAIN_RIDE = 69, STARTING_INTRO_SCENE = 91, OVERHEAD_MAP2 = 90, OVERHEAD_MAP = 100
+};
+
+struct SceneTripEntry {
+	int _flag;
+	int _sceneNumber;
+	int _numTimes;
+
+	SceneTripEntry() : _flag(0), _sceneNumber(0), _numTimes(0) {}
+	SceneTripEntry(int flag, int sceneNumber, int numTimes) : _flag(flag),
+		_sceneNumber(sceneNumber), _numTimes(numTimes) {}
+};
+
+class TattooScene : public Scene {
+private:
+	WidgetLab _labWidget;
+
+	void doBgAnimCheckCursor();
+
+	/**
+	 * Update the background objects and canimations as part of doBgAnim
+	 */
+	void doBgAnimUpdateBgObjectsAndAnim();
+
+	void doBgAnimDrawSprites();
+
+	/**
+	 * Resets the NPC path information when entering a new scene.
+	 * @remarks		The default talk file for the given NPC is set to WATS##A, where ## is
+	 *		the scene number being entered
+	 */
+	void setNPCPath(int npc);
+protected:
+	/**
+	 * Loads the data associated for a given scene. The room resource file's format is:
+	 * BGHEADER: Holds an index for the rest of the file
+	 * STRUCTS:  The objects for the scene
+	 * IMAGES:   The graphic information for the structures
+	 *
+	 * The _misc field of the structures contains the number of the graphic image
+	 * that it should point to after loading; _misc is then set to 0.
+	 */
+	virtual bool loadScene(const Common::String &filename);
+
+	/**
+	 * Checks all the background shapes. If a background shape is animating,
+	 * it will flag it as needing to be drawn. If a non-animating shape is
+	 * colliding with another shape, it will also flag it as needing drawing
+	 */
+	virtual void checkBgShapes();
+
+	/**
+	 * Draw all the shapes, people and NPCs in the correct order
+	 */
+	virtual void drawAllShapes();
+
+	/**
+	 * Called by loadScene when the palette is loaded for Rose Tattoo
+	 */
+	virtual void paletteLoaded();
+
+	/**
+	 * Synchronize the data for a savegame
+	 */
+	virtual void synchronize(Serializer &s);
+
+	/**
+	 * Returns the index of the closest zone to a given point.
+	 */
+	virtual int closestZone(const Common::Point &pt);
+public:
+	StreamingImageFile _activeCAnim;
+	Common::Array<SceneTripEntry> _sceneTripCounters;
+	bool _labTableScene;
+public:
+	TattooScene(SherlockEngine *vm);
+
+	/**
+	 * Returns the scale value for the passed co-ordinates. This is taken from the scene's
+	 * scale zones, interpolating inbetween the top and bottom values of the zones as needed
+	 */
+	int getScaleVal(const Point32 &pt);
+
+	/**
+	 * Fres all the graphics and other dynamically allocated data for the scene
+	 */
+	virtual void freeScene();
+
+	/**
+	 * Draw all objects and characters.
+	 */
+	virtual void doBgAnim();
+
+	/**
+	 * Update the screen back buffer with all of the scene objects which need
+	 * to be drawn
+	 */
+	virtual void updateBackground();
+
+	/**
+	 * Attempt to start a canimation sequence. It will load the requisite graphics, and
+	 * then copy the canim object into the _canimShapes array to start the animation.
+	 *
+	 * @param cAnimNum		The canim object within the current scene
+	 * @param playRate		Play rate. 0 is invalid; 1=normal speed, 2=1/2 speed, etc.
+	 *		A negative playRate can also be specified to play the animation in reverse
+	 */
+	virtual int startCAnim(int cAnimNum, int playRate = 1);
+
+	/**
+	 * Attempts to find a background shape within the passed bounds. If found,
+	 * it will return the shape number, or -1 on failure.
+	 */
+	virtual int findBgShape(const Common::Point &pt);
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/tattoo_talk.cpp b/engines/sherlock/tattoo/tattoo_talk.cpp
new file mode 100644
index 0000000000..a5ada7b63e
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_talk.cpp
@@ -0,0 +1,1017 @@
+/* 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 "sherlock/tattoo/tattoo_talk.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_people.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/screen.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+static const uint8 DIRECTION_CONVERSION[] = {
+	WALK_RIGHT, WALK_DOWN, WALK_LEFT, WALK_UP, STOP_RIGHT, STOP_DOWN, STOP_LEFT, STOP_UP,
+	WALK_UPRIGHT, WALK_DOWNRIGHT, WALK_UPLEFT, WALK_DOWNLEFT, STOP_UPRIGHT, STOP_UPLEFT, 
+	STOP_DOWNRIGHT, STOP_DOWNLEFT
+};
+
+const byte TATTOO_OPCODES[] = {
+	170,	// OP_SWITCH_SPEAKER
+	171,	// OP_RUN_CANIMATION
+	0,	// OP_ASSIGN_PORTRAIT_LOCATION
+	173,	// OP_PAUSE
+	0,	// OP_REMOVE_PORTRAIT
+	0,	// OP_CLEAR_WINDOW
+	176,	// OP_ADJUST_OBJ_SEQUENCE
+	177,	// OP_WALK_HOlMES_TO_COORDS
+	178,	// OP_PAUSE_WITHOUT_CONTROL
+	179,	// OP_BANISH_WINDOW
+	0,		// OP_SUMMON_WINDOW
+	181,	// OP_SET_FLAG
+	0,		// OP_SFX_COMMAND
+	183,	// OP_TOGGLE_OBJECT
+	184,	// OP_STEALTH_MODE_ACTIVE
+	0,		// OP_IF_STATEMENT
+	0,		// OP_ELSE_STATEMENT
+	0,		// OP_END_IF_STATEMENT
+	188,	// OP_STEALTH_MODE_DEACTIVATE
+	189,	// OP_TURN_HOLMES_OFF
+	190,	// OP_TURN_HOLMES_ON
+	191,	// OP_GOTO_SCENE
+	0,		// OP_PLAY_PROLOGUE
+	193,	// OP_ADD_ITEM_TO_INVENTORY
+	194,	// OP_SET_OBJECT
+	172,	// OP_CALL_TALK_FILE
+	0,		// OP_MOVE_MOUSE
+	0,		// OP_DISPLAY_INFO_LINE
+	0,		// OP_CLEAR_INFO_LINE
+	199,	// OP_WALK_TO_CANIMATION
+	200,	// OP_REMOVE_ITEM_FROM_INVENTORY
+	201,	// OP_ENABLE_END_KEY
+	202,	// OP_DISABLE_END_KEY
+	203,	// OP_END_TEXT_WINDOW
+	174,	// OP_MOUSE_ON_OFF
+	175,	// OP_SET_WALK_CONTROL
+	180,	// OP_SET_TALK_SEQUENCE
+	182,	// OP_PLAY_SONG
+	187,	// OP_WALK_HOLMES_AND_NPC_TO_CANIM
+	192,	// OP_SET_NPC_PATH_DEST
+	195,	// OP_NEXT_SONG
+	196,	// OP_SET_NPC_PATH_PAUSE
+	197,	// OP_PASSWORD
+	198,	// OP_SET_SCENE_ENTRY_FLAG
+	185,	// OP_WALK_NPC_TO_CANIM
+	186,	// OP_WALK_NPC_TO_COORDS
+	204,	// OP_WALK_HOLMES_AND_NPC_TO_COORDS
+	205,	// OP_SET_NPC_TALK_FILE
+	206,	// OP_TURN_NPC_OFF
+	207,	// OP_TURN_NPC_ON
+	208,	// OP_NPC_DESC_ON_OFF
+	209,	// OP_NPC_PATH_PAUSE_TAKING_NOTES
+	210,	// OP_NPC_PATH_PAUSE_LOOKING_HOLMES
+	211,	// OP_ENABLE_TALK_INTERRUPTS
+	212,	// OP_DISABLE_TALK_INTERRUPTS
+	213,	// OP_SET_NPC_INFO_LINE
+	214,	// OP_SET_NPC_POSITION
+	215,	// OP_NPC_PATH_LABEL
+	216,	// OP_PATH_GOTO_LABEL
+	217,	// OP_PATH_IF_FLAG_GOTO_LABEL
+	218,	// OP_NPC_WALK_GRAPHICS
+	220,	// OP_NPC_VERB
+	221,	// OP_NPC_VERB_CANIM
+	222,	// OP_NPC_VERB_SCRIPT
+	224,	// OP_RESTORE_PEOPLE_SEQUENCE
+	226,	// OP_NPC_VERB_TARGET
+	227,	// OP_TURN_SOUNDS_OFF
+	225		// OP_NULL
+};
+
+/*----------------------------------------------------------------*/
+
+TattooTalk::TattooTalk(SherlockEngine *vm) : Talk(vm), _talkWidget(vm), _passwordWidget(vm) {
+	static OpcodeMethod OPCODE_METHODS[] = {
+		(OpcodeMethod)&TattooTalk::cmdSwitchSpeaker,
+
+		(OpcodeMethod)&TattooTalk::cmdRunCAnimation,
+		(OpcodeMethod)&TattooTalk::cmdCallTalkFile,
+		(OpcodeMethod)&TattooTalk::cmdPause,
+		(OpcodeMethod)&TattooTalk::cmdMouseOnOff,
+		(OpcodeMethod)&TattooTalk::cmdSetWalkControl,
+		(OpcodeMethod)&TattooTalk::cmdAdjustObjectSequence,
+		(OpcodeMethod)&TattooTalk::cmdWalkHolmesToCoords,
+		(OpcodeMethod)&TattooTalk::cmdPauseWithoutControl,
+		(OpcodeMethod)&TattooTalk::cmdBanishWindow,
+		(OpcodeMethod)&TattooTalk::cmdSetTalkSequence,
+
+		(OpcodeMethod)&TattooTalk::cmdSetFlag,
+		(OpcodeMethod)&TattooTalk::cmdPlaySong,
+		(OpcodeMethod)&TattooTalk::cmdToggleObject,
+		(OpcodeMethod)&TattooTalk::cmdStealthModeActivate,
+		(OpcodeMethod)&TattooTalk::cmdWalkNPCToCAnimation,
+		(OpcodeMethod)&TattooTalk::cmdWalkNPCToCoords,
+		(OpcodeMethod)&TattooTalk::cmdWalkHomesAndNPCToCoords,
+		(OpcodeMethod)&TattooTalk::cmdStealthModeDeactivate,
+		(OpcodeMethod)&TattooTalk::cmdHolmesOff,
+		(OpcodeMethod)&TattooTalk::cmdHolmesOn,
+
+		(OpcodeMethod)&TattooTalk::cmdGotoScene,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCPathDest,
+		(OpcodeMethod)&TattooTalk::cmdAddItemToInventory,
+		(OpcodeMethod)&TattooTalk::cmdSetObject,
+		(OpcodeMethod)&TattooTalk::cmdNextSong,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCPathPause,
+		(OpcodeMethod)&TattooTalk::cmdPassword,
+		(OpcodeMethod)&TattooTalk::cmdSetSceneEntryFlag,
+		(OpcodeMethod)&TattooTalk::cmdWalkToCAnimation,
+		(OpcodeMethod)&TattooTalk::cmdRemoveItemFromInventory,
+
+		(OpcodeMethod)&TattooTalk::cmdEnableEndKey,
+		(OpcodeMethod)&TattooTalk::cmdDisableEndKey,
+		(OpcodeMethod)&TattooTalk::cmdEndTextWindow,
+		(OpcodeMethod)&TattooTalk::cmdWalkHomesAndNPCToCoords,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCTalkFile,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCOff,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCOn,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCDescOnOff,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCPathPauseTakingNotes,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCPathPauseLookingHolmes,
+
+		(OpcodeMethod)&TattooTalk::cmdTalkInterruptsEnable,
+		(OpcodeMethod)&TattooTalk::cmdTalkInterruptsDisable,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCInfoLine,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCPosition,
+		(OpcodeMethod)&TattooTalk::cmdNPCLabelSet,
+		(OpcodeMethod)&TattooTalk::cmdNPCLabelGoto,
+		(OpcodeMethod)&TattooTalk::cmdNPCLabelIfFlagGoto,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCWalkGraphics,
+		nullptr,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCVerb,
+
+		(OpcodeMethod)&TattooTalk::cmdSetNPCVerbCAnimation,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCVerbScript,
+		nullptr,
+		(OpcodeMethod)&TattooTalk::cmdRestorePeopleSequence,
+		nullptr,
+		(OpcodeMethod)&TattooTalk::cmdSetNPCVerbTarget,
+		(OpcodeMethod)&TattooTalk::cmdTurnSoundsOff
+	};
+
+	_opcodes = TATTOO_OPCODES;
+	_opcodeTable = OPCODE_METHODS;
+}
+
+void TattooTalk::talkTo(const Common::String filename) {
+	Events &events = *_vm->_events;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	// WORKAROUND: Keep wait cursor active until very end of the cutscene of the monkey
+	// stealing the cap, which is finished by calling the 30cuend script
+	if (filename == "wilb29a")
+		events.incWaitCounter();
+
+	Talk::talkTo(filename);
+
+	if (filename == "wilb29a")
+		ui._menuMode = TALK_MODE;
+	if (filename == "30cuend") {
+		events.decWaitCounter();
+		events.setCursor(ARROW);
+	}
+}
+
+void TattooTalk::talkInterface(const byte *&str) {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Sound &sound = *_vm->_sound;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	const byte *s = str;
+
+	// Move to past the end of the text string
+	_wait = 1;
+	_charCount = 0;
+	while ((*str < TATTOO_OPCODES[0] || *str == TATTOO_OPCODES[OP_NULL]) && *str) {
+		++_charCount;
+		++str;
+	}
+
+	// If speech is on, and text windows (subtitles) are off, then don't show the text window
+	if (!vm._textWindowsOn && sound._speechOn && _speaker != -1)
+		return;
+
+	// Display the text window
+	ui.banishWindow();
+	ui._textWidget.load(Common::String((const char *)s, (const char *)str), _speaker);
+	ui._textWidget.summonWindow();
+}
+
+void TattooTalk::nothingToSay() {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	ui.putMessage("%s", FIXED(NothingToSay));
+}
+
+void TattooTalk::showTalk() {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	people.setListenSequence(_talkTo, 129);
+
+	_talkWidget.load();
+	_talkWidget.summonWindow();
+	_talkWidget.refresh();
+
+	if (ui._menuMode != MESSAGE_MODE)
+		ui._menuMode = TALK_MODE;
+}
+
+OpcodeReturn TattooTalk::cmdSwitchSpeaker(const byte *&str) {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Screen &screen = *_vm->_screen;
+	UserInterface &ui = *_vm->_ui;
+
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	ui.clearWindow();
+	
+	_yp = screen.fontHeight() + 11;
+	_charCount = _line = 0;
+
+	people.setListenSequence(_speaker, 129);
+	_speaker = *++str - 1;
+	++str;
+
+	people.setTalkSequence(_speaker, 1);
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdMouseOnOff(const byte *&str) { 
+	Events &events = *_vm->_events;
+	bool mouseOn = *++str == 2;
+	if (mouseOn)
+		events.showCursor();
+	else
+		events.hideCursor();
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdWalkHolmesToCoords(const byte *&str) {
+	People &people = *_vm->_people;
+	++str;
+
+	int xp = (str[0] - 1) * 256 + str[1] - 1;
+	if (xp > 16384)
+		// Negative X
+		xp = -1 * (xp - 16384);
+	int yp = (str[2] - 1) * 256 + str[3] - 1;
+	
+	people[HOLMES].walkToCoords(Point32(xp * FIXED_INT_MULTIPLIER, yp * FIXED_INT_MULTIPLIER),
+		DIRECTION_CONVERSION[str[4] - 1]);
+
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	str += 4;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdGotoScene(const byte *&str) {
+	Map &map = *_vm->_map;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Scene &scene = *_vm->_scene;
+	scene._goToScene = str[1] - 1;
+
+	if (scene._goToScene != OVERHEAD_MAP) {
+		// Not going to the map overview
+		map._oldCharPoint = scene._goToScene;
+
+		// Run a canimation?
+		if (str[2] > 100) {
+			people._savedPos = PositionFacing(160, 100, str[2]);
+		} else {
+			int posX = (str[3] - 1) * 256 + str[4] - 1;
+			if (posX > 16384)
+				posX = -1 * (posX - 16384);
+			int posY = (str[5] - 1) * 256 + str[6] - 1;
+			people._savedPos = PositionFacing(posX, posY, str[2] - 1);
+		}
+
+		_scriptMoreFlag = 1;
+	}
+
+	str += 7;
+	if (scene._goToScene != OVERHEAD_MAP)
+		_scriptSaveIndex = str - _scriptStart;
+
+	_endStr = true;
+	_wait = 0;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdNextSong(const byte *&str) {
+	Music &music = *_vm->_music;
+
+	// Get the name of the next song to play
+	++str;
+	music._nextSongName = "";
+	for (int idx = 0; idx < 8 && str[idx] != '~'; ++idx)
+		music._nextSongName += str[idx];
+	str += 7;
+
+	// WORKAROUND: Original game set wrong music name at the end of the introduction sequence
+	if (_scriptName == "prol80p" && music._nextSongName == "default")
+		music._nextSongName = "01cue90";
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdNPCLabelGoto(const byte *&str) {
+	int npcNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	
+	if (person._resetNPCPath) {
+		person._npcIndex = person._npcPause = 0;
+		person._resetNPCPath = false;
+		memset(person._npcPath, 0, 100);
+	}
+
+	person._npcPath[person._npcIndex] = 8;
+	person._npcPath[person._npcIndex + 1] = str[1];
+	person._npcIndex += 2;
+	str++;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdNPCLabelIfFlagGoto(const byte *&str) {
+	int npcNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	
+	if (person._resetNPCPath) {
+		person._npcIndex = person._npcPause = 0;
+		person._resetNPCPath = false;
+		memset(person._npcPath, 0, 100);
+	}
+
+	person._npcPath[person._npcIndex] = 9;
+	for (int i = 1; i <= 3; i++)
+		person._npcPath[person._npcIndex + i] = str[i];
+
+	person._npcIndex += 4;
+	str += 3;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdNPCLabelSet(const byte *&str) {
+	int npcNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	
+	if (person._resetNPCPath) {
+		person._npcIndex = person._npcPause = 0;
+		person._resetNPCPath = false;
+		memset(person._npcPath, 0, 100);
+	}
+
+	person._npcPath[person._npcIndex] = 7;
+	person._npcPath[person._npcIndex + 1] = str[1];
+	person._npcIndex += 2;
+	str++;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdPassword(const byte *&str) {
+	_vm->_ui->clearWindow();
+	_passwordWidget.show();
+	return RET_EXIT;
+}
+
+OpcodeReturn TattooTalk::cmdPlaySong(const byte *&str) { 
+	Music &music = *_vm->_music;
+	Common::String currentSong = music._currentSongName;
+
+	// Get the name of the song to play
+	music._currentSongName = "";
+	str++;
+	for (int idx = 0; idx < 8 && str[idx] != '~'; ++idx)
+		music._currentSongName += str[idx];
+	str += 7;
+
+	// Play the song
+	music.loadSong(music._currentSongName);
+
+	// Copy the old song name to _nextSongName so that when the new song is finished, the old song will restart
+	music._nextSongName = currentSong;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdRestorePeopleSequence(const byte *&str) {
+	int npcNum = *++str - 1;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	person._misc = 0;
+
+	if (person._seqTo) {
+		person._walkSequences[person._sequenceNumber]._sequences[person._frameNumber] = person._seqTo;
+		person._seqTo = 0;
+	}
+	person._sequenceNumber = person._savedNpcSequence;
+	person._frameNumber = person._savedNpcFrame;
+	person.checkWalkGraphics();
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCDescOnOff(const byte *&str) {
+	int npcNum = *++str;
+	++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Person &person = people[npcNum];
+
+	// Copy over the NPC examine text until we reach a stop marker, which is
+	// the same as a start marker, or we reach the end of the file
+	person._examine = "";
+	while (*str && *str != _opcodes[OP_NPC_DESC_ON_OFF])
+		person._examine += *str++;
+
+	// Move past any leftover text till we reach a stop marker
+	while (*str && *str != _opcodes[OP_NPC_DESC_ON_OFF])
+		str++;
+
+	if (!*str)
+		// Reached end of file, so decrement pointer so outer loop will terminate on NULL
+		--str;
+	else
+		// Move past the ending OP_NPC_DEST_ON_OFF opcode
+		++str;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCInfoLine(const byte *&str) {
+	int npcNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+
+	person._description = "";
+	int len = *++str;
+	for (int idx = 0; idx < len; ++idx)
+		person._description += str[idx + 1];
+
+	str += len;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCOff(const byte *&str) {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	int npcNum = *++str;
+	people[npcNum]._type = REMOVE;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCOn(const byte *&str) { 
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	int npcNum = *++str;
+	people[npcNum]._type = CHARACTER;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCPathDest(const byte *&str) {
+	int npcNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	
+	if (person._resetNPCPath) {
+		person._npcIndex = person._npcPause = 0;
+		person._resetNPCPath = false;
+		memset(person._npcPath, 0, 100);
+	}
+
+	person._npcPath[person._npcIndex] = 1;
+	for (int i = 1; i <= 4; i++)
+		person._npcPath[person._npcIndex + i] = str[i];
+	person._npcPath[person._npcIndex + 5] = DIRECTION_CONVERSION[str[5] - 1] + 1;
+
+	person._npcIndex += 6;
+	str += 5;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCPathPause(const byte *&str) {
+	int npcNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	
+	if (person._resetNPCPath) {
+		person._npcIndex = person._npcPause = 0;
+		person._resetNPCPath = false;
+		memset(person._npcPath, 0, 100);
+	}
+
+	person._npcPath[person._npcIndex] = 2;
+	for (int i = 1; i <= 2; i++)
+		person._npcPath[person._npcIndex + i] = str[i];
+
+	person._npcIndex += 3;
+	str += 2;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCPathPauseTakingNotes(const byte *&str) {
+	int npcNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	
+	if (person._resetNPCPath) {
+		person._npcIndex = person._npcPause = 0;
+		person._resetNPCPath = false;
+		memset(person._npcPath, 0, 100);
+	}
+
+	person._npcPath[person._npcIndex] = 5;
+	for (int i = 1; i <= 2; i++)
+		person._npcPath[person._npcIndex + i] = str[i];
+
+	person._npcIndex += 3;
+	str += 2;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCPathPauseLookingHolmes(const byte *&str) {
+	int npcNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	
+	if (person._resetNPCPath) {
+		person._npcIndex = person._npcPause = 0;
+		person._resetNPCPath = false;
+		memset(person._npcPath, 0, 100);
+	}
+
+	person._npcPath[person._npcIndex] = 6;
+	for (int i = 1; i <= 2; i++)
+		person._npcPath[person._npcIndex + i] = str[i];
+
+	person._npcIndex += 3;
+	str += 2;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCPosition(const byte *&str) {
+	int npcNum = *++str - 1;
+	++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	int posX = (str[0] - 1) * 256 + str[1] - 1;
+	if (posX > 16384)
+		posX = -1 * (posX - 16384);
+	int posY = (str[2] - 1) * 256 + str[3] - 1;
+	
+	person._position = Point32(posX * FIXED_INT_MULTIPLIER, posY * FIXED_INT_MULTIPLIER);
+	if (person._seqTo && person._walkLoaded) {
+		person._walkSequences[person._sequenceNumber]._sequences[person._frameNumber] = person._seqTo;
+		person._seqTo = 0;
+	}
+
+	assert(str[4] - 1 < 16);
+	person._sequenceNumber = DIRECTION_CONVERSION[str[4] - 1];
+	person._frameNumber = 0;
+
+	if (person._walkLoaded)
+		person.checkWalkGraphics();
+
+	if (person._walkLoaded && person._type == CHARACTER &&
+		person._sequenceNumber >= STOP_UP && person._sequenceNumber <= STOP_UPLEFT) {
+		bool done = false;
+		do {
+			person.checkSprite();
+			for (int x = 0; x < person._frameNumber; x++) {
+				if (person._walkSequences[person._sequenceNumber]._sequences[x] == 0) {
+					done = true;
+					break;
+				}
+			}
+		} while (!done);
+	}
+
+	str += 4;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCTalkFile(const byte *&str) {
+	int npcNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	
+	if (person._resetNPCPath) {
+		person._npcIndex = person._npcPause = 0;
+		person._resetNPCPath = false;
+		memset(person._npcPath, 0, 100);
+	}
+
+	person._npcPath[person._npcIndex] = NPCPATH_SET_TALK_FILE;
+	for (int i = 1; i <= 8; i++)
+		person._npcPath[person._npcIndex + i] = str[i];
+
+	person._npcIndex += 9;
+	str += 8;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCVerb(const byte *&str) {
+	int npcNum = *++str;
+	int verbNum = *++str - 1;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Common::String &verb = people[npcNum]._use[verbNum]._verb;
+
+	// Get the verb name
+	verb = "";
+	for (int idx = 0; idx < 12 && str[idx + 1] != '~'; ++idx)
+		verb += str[idx + 1];
+
+	// Strip off any trailing whitespace
+	while (verb.hasSuffix(" "))
+		verb.deleteLastChar();
+
+	str += 12;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCVerbCAnimation(const byte *&str) {
+	int npcNum = *++str;
+	int verbNum = *++str - 1;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	UseType &useType = people[npcNum]._use[verbNum];
+
+	useType._cAnimNum = (str[1] - 1) & 127;
+	useType._cAnimSpeed = 1 + 128 * (str[1] >= 128);
+	str++;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCVerbScript(const byte *&str) {
+	int npcNum = *++str;
+	int verbNum = *++str - 1;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	UseType &useType = people[npcNum]._use[verbNum];
+	
+	Common::String &name = useType._names[0];
+	name = "*C";
+
+	for (int idx = 0; idx < 8 && str[idx + 1] != '~'; ++idx)
+		name += str[idx + 1];
+
+	useType._cAnimNum = 99;
+	useType._cAnimSpeed = 1;
+	str += 8;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCVerbTarget(const byte *&str) {
+	int npcNum = *++str;
+	int verbNum = *++str - 1;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Common::String &target = people[npcNum]._use[verbNum]._target;
+
+	target = "";
+	for (int idx = 0; idx < 12 && str[idx + 1] != '~'; ++idx)
+		target += str[idx + 1];
+
+	while (target.hasSuffix(" "))
+		target.deleteLastChar();
+
+	str += 12;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetNPCWalkGraphics(const byte *&str) {
+	int npcNum = *++str - 1;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Person &person = people[npcNum];
+
+	// Build up walk library name for the given NPC
+	person._walkVGSName = "";
+	for (int idx = 0; idx < 8 && str[idx + 1] != '~'; ++idx)
+		person._walkVGSName += str[idx + 1];
+
+	person._walkVGSName += ".VGS";
+	people._forceWalkReload = true;
+	str += 8;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetSceneEntryFlag(const byte *&str) {
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	++str;
+	int flag = (str[0] - 1) * 256 + str[1] - 1 - (str[1] == 1);
+
+	int flag1 = flag & 16383;
+	if (flag > 16383)
+		flag1 *= -1;
+
+	str += 2;
+
+	// Make sure that this instance is not already being tracked
+	bool found = false;
+	for (uint idx = 0; idx < scene._sceneTripCounters.size() && !found; ++idx) {
+		SceneTripEntry &entry = scene._sceneTripCounters[idx];
+		if (entry._flag == flag1 && entry._sceneNumber == str[0] - 1)
+			found = true;
+	}
+
+	// Only add it if it's not being tracked already
+	if (!found)
+		scene._sceneTripCounters.push_back(SceneTripEntry(flag1, str[0] - 1, str[1] - 1));
+
+	++str;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetTalkSequence(const byte *&str) {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	int speaker = str[1] - 1;
+	int sequenceNumber = str[2];
+
+	if (sequenceNumber < 128)
+		people.setTalkSequence(speaker, sequenceNumber);
+	else
+		people.setListenSequence(speaker, sequenceNumber);
+	
+	str += 2;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdSetWalkControl(const byte *&str) {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	++str;
+	people._walkControl = str[0] - 1;
+	
+	return RET_SUCCESS;
+}
+
+// Dummy opcode
+OpcodeReturn TattooTalk::cmdTalkInterruptsDisable(const byte *&str) { error("Dummy opcode cmdTalkInterruptsDisable called"); }
+
+// Dummy opcode
+OpcodeReturn TattooTalk::cmdTalkInterruptsEnable(const byte *&str) { error("Dummy opcode cmdTalkInterruptsEnable called"); }
+
+OpcodeReturn TattooTalk::cmdTurnSoundsOff(const byte *&str) { error("TODO: script opcode (cmdTurnSoundsOff)"); }
+
+OpcodeReturn TattooTalk::cmdWalkHolmesAndNPCToCAnimation(const byte *&str) {
+	int npcNum = *++str;
+	int cAnimNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	Scene &scene = *_vm->_scene;
+	CAnim &anim = scene._cAnim[cAnimNum];
+
+	if (person._pathStack.empty())
+		person.pushNPCPath();
+	person._npcMoved = true;
+
+	person.walkToCoords(anim._goto[1], anim._goto[1]._facing);
+
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdWalkNPCToCAnimation(const byte *&str) {
+	int npcNum = *++str;
+	int cAnimNum = *++str;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+	Scene &scene = *_vm->_scene;
+	CAnim &anim = scene._cAnim[cAnimNum];
+
+	if (person._pathStack.empty())
+		person.pushNPCPath();
+	person._npcMoved = true;
+
+	person.walkToCoords(anim._goto[1], anim._goto[1]._facing);
+
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdWalkNPCToCoords(const byte *&str) {
+	int npcNum = *++str;
+	str++;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+
+	if (person._pathStack.empty())
+		person.pushNPCPath();
+	person._npcMoved = true;
+
+	int xp = (str[0] - 1) * 256 + str[1] - 1;
+	if (xp > 16384)
+		xp = -1 * (xp - 16384);
+	int yp = (str[2] - 1) * 256 + str[3] - 1;
+
+	person.walkToCoords(Point32(xp * FIXED_INT_MULTIPLIER, yp * FIXED_INT_MULTIPLIER),
+		DIRECTION_CONVERSION[str[4] - 1]);
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	str += 4;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdWalkHomesAndNPCToCoords(const byte *&str) {
+	int npcNum = *++str;
+	str++;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooPerson &person = people[npcNum];
+
+	if (person._pathStack.empty())
+		person.pushNPCPath();
+	person._npcMoved = true;
+
+	// Get destination position and facing for Holmes
+	int xp = (str[0] - 1) * 256 + str[1] - 1;
+	if (xp > 16384)
+		xp = -1 * (xp - 16384);
+	int yp = (str[2] - 1) * 256 + str[3] - 1;
+	PositionFacing holmesDest(xp * FIXED_INT_MULTIPLIER, yp * FIXED_INT_MULTIPLIER, DIRECTION_CONVERSION[str[4] - 1]);
+
+	// Get destination position and facing for specified NPC
+	xp = (str[5] - 1) * 256 + str[6] - 1;
+	if (xp > 16384)
+		xp = -1 * (xp - 16384);
+	yp = (str[7] - 1) * 256 + str[8] - 1;
+	PositionFacing npcDest(xp * FIXED_INT_MULTIPLIER, yp * FIXED_INT_MULTIPLIER, DIRECTION_CONVERSION[str[9] - 1]);
+
+	person.walkBothToCoords(holmesDest, npcDest);
+
+	if (_talkToAbort)
+		return RET_EXIT;
+
+	str += 9;
+	return RET_SUCCESS;
+}
+
+OpcodeReturn TattooTalk::cmdCallTalkFile(const byte *&str) {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Common::String tempString;
+
+	int npc = *++str;
+	assert(npc >= 1 && npc < MAX_CHARACTERS);
+	TattooPerson &person = people[npc];
+
+	if (person._resetNPCPath) {
+		person._npcIndex = person._npcPause = 0;
+		person._resetNPCPath = false;
+		Common::fill(&person._npcPath[0], &person._npcPath[100], 0);
+	}
+
+	// Set the path control code and copy the filename
+	person._npcPath[person._npcIndex] = 4;
+	for (int idx = 1; idx <= 8; ++idx)
+		person._npcPath[person._npcIndex + idx] = str[idx];
+
+	person._npcIndex += 9;
+	str += 8;
+
+	return RET_SUCCESS;
+}
+
+void TattooTalk::pushSequenceEntry(Object *obj) {
+	// Check if the shape is already on the stack
+	for (uint idx = 0; idx < TALK_SEQUENCE_STACK_SIZE; ++idx) {
+		if (_sequenceStack[idx]._obj == obj)
+			return;
+	}
+
+	// Find a free slot and save the details in it
+	for (uint idx = 0; idx < TALK_SEQUENCE_STACK_SIZE; ++idx) {
+		SequenceEntry &seq = _sequenceStack[idx];
+		if (seq._obj == nullptr) {
+			seq._obj = obj;
+			seq._frameNumber = obj->_frameNumber;
+			seq._sequenceNumber = obj->_sequenceNumber;
+			seq._seqStack = obj->_seqStack;
+			seq._seqTo = obj->_seqTo;
+			seq._seqCounter = obj->_seqCounter;
+			seq._seqCounter2 = obj->_seqCounter2;
+			return;
+		}
+	}
+
+	error("Ran out of talk sequence stack space");
+}
+
+void TattooTalk::pullSequence(int slot) {
+	People &people = *_vm->_people;
+
+	for (int idx = 0; idx < TALK_SEQUENCE_STACK_SIZE; ++idx) {
+		SequenceEntry &seq = _sequenceStack[idx];
+		if (slot != -1 && idx != slot)
+			continue;
+
+		// Check for an entry in this slot
+		if (seq._obj) {
+			Object &o = *seq._obj;
+			
+			// See if we're not supposed to restore it until an Allow Talk Interrupt
+			if (slot == -1 && seq._obj->hasAborts()) {
+				seq._obj->_gotoSeq = -1;
+				seq._obj->_restoreSlot = idx;
+			} else {
+				// Restore the object's sequence information immediately
+				o._frameNumber = seq._frameNumber;
+				o._sequenceNumber = seq._sequenceNumber;
+				o._seqStack = seq._seqStack;
+				o._seqTo = seq._seqTo;
+				o._seqCounter = seq._seqCounter;
+				o._seqCounter2 = seq._seqCounter2;
+				o._gotoSeq = 0;
+				o._talkSeq = 0;
+
+				// Flag the slot as free again
+				seq._obj = nullptr;
+			}
+		}
+	}
+
+	// Handle restoring any character positioning
+	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+		Person &person = people[idx];
+
+		if (person._type == CHARACTER && !person._walkSequences.empty() && person._sequenceNumber >= TALK_UPRIGHT
+				&& person._sequenceNumber <= LISTEN_UPLEFT) {
+			person.gotoStand();
+
+			bool done = false;
+			do {
+				person.checkSprite();
+				for (int frameNum = 0; frameNum < person._frameNumber; ++frameNum) {
+					if (person._walkSequences[person._sequenceNumber]._sequences[frameNum] == 0)
+						done = true;
+				}
+			} while (!done);
+		}
+	}
+}
+
+bool TattooTalk::isSequencesEmpty() const {
+	for (int idx = 0; idx < TALK_SEQUENCE_STACK_SIZE; ++idx) {
+		if (_sequenceStack[idx]._obj)
+			return false;
+	}
+
+	return true;
+}
+
+void TattooTalk::clearSequences() {
+	for (int idx = 0; idx < TALK_SEQUENCE_STACK_SIZE; ++idx) {
+		_sequenceStack[idx]._obj = nullptr;
+	}
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_talk.h b/engines/sherlock/tattoo/tattoo_talk.h
new file mode 100644
index 0000000000..9b010513dc
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_talk.h
@@ -0,0 +1,143 @@
+/* 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 SHERLOCK_TATTOO_TALK_H
+#define SHERLOCK_TATTOO_TALK_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/rect.h"
+#include "common/serializer.h"
+#include "common/stream.h"
+#include "common/stack.h"
+#include "sherlock/talk.h"
+#include "sherlock/tattoo/widget_password.h"
+#include "sherlock/tattoo/widget_talk.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+#define TALK_SEQUENCE_STACK_SIZE 20
+
+class WidgetTalk;
+
+class TattooTalk : public Talk {
+	friend class WidgetTalk;
+private:
+	WidgetTalk _talkWidget;
+	WidgetPassword _passwordWidget;
+	SequenceEntry _sequenceStack[TALK_SEQUENCE_STACK_SIZE];
+
+	OpcodeReturn cmdCallTalkFile(const byte *&str);
+	OpcodeReturn cmdSwitchSpeaker(const byte *&str);
+	OpcodeReturn cmdMouseOnOff(const byte *&str);
+	OpcodeReturn cmdGotoScene(const byte *&str);
+	OpcodeReturn cmdWalkHolmesToCoords(const byte *&str);
+	OpcodeReturn cmdNextSong(const byte *&str);
+	OpcodeReturn cmdPassword(const byte *&str);
+	OpcodeReturn cmdPlaySong(const byte *&str);
+	OpcodeReturn cmdRestorePeopleSequence(const byte *&str);
+	OpcodeReturn cmdSetNPCDescOnOff(const byte *&str);
+	OpcodeReturn cmdSetNPCInfoLine(const byte *&str);
+	OpcodeReturn cmdNPCLabelGoto(const byte *&str);
+	OpcodeReturn cmdNPCLabelIfFlagGoto(const byte *&str);
+	OpcodeReturn cmdNPCLabelSet(const byte *&str);
+	OpcodeReturn cmdSetNPCOff(const byte *&str);
+	OpcodeReturn cmdSetNPCOn(const byte *&str);
+	OpcodeReturn cmdSetNPCPathDest(const byte *&str);
+	OpcodeReturn cmdSetNPCPathPause(const byte *&str);
+	OpcodeReturn cmdSetNPCPathPauseTakingNotes(const byte *&str);
+	OpcodeReturn cmdSetNPCPathPauseLookingHolmes(const byte *&str);
+	OpcodeReturn cmdSetNPCPosition(const byte *&str);
+	OpcodeReturn cmdSetNPCTalkFile(const byte *&str);
+	OpcodeReturn cmdSetNPCVerb(const byte *&str);
+	OpcodeReturn cmdSetNPCVerbCAnimation(const byte *&str);
+	OpcodeReturn cmdSetNPCVerbScript(const byte *&str);
+	OpcodeReturn cmdSetNPCVerbTarget(const byte *&str);
+	OpcodeReturn cmdSetNPCWalkGraphics(const byte *&str);
+	OpcodeReturn cmdSetSceneEntryFlag(const byte *&str);
+	OpcodeReturn cmdSetTalkSequence(const byte *&str);
+	OpcodeReturn cmdSetWalkControl(const byte *&str);
+	OpcodeReturn cmdTalkInterruptsDisable(const byte *&str);
+	OpcodeReturn cmdTalkInterruptsEnable(const byte *&str);
+	OpcodeReturn cmdTurnSoundsOff(const byte *&str);
+	OpcodeReturn cmdWalkHolmesAndNPCToCAnimation(const byte *&str);
+	OpcodeReturn cmdWalkNPCToCAnimation(const byte *&str);
+	OpcodeReturn cmdWalkNPCToCoords(const byte *&str);
+	OpcodeReturn cmdWalkHomesAndNPCToCoords(const byte *&str);
+protected:
+	/**
+	 * Display the talk interface window
+	 */
+	virtual void talkInterface(const byte *&str);
+
+	/**
+	 * Called when a character being spoken to has no talk options to display
+	 */
+	virtual void nothingToSay();
+
+	/**
+	 * Show the talk display
+	 */
+	virtual void showTalk();
+public:
+	TattooTalk(SherlockEngine *vm);
+	virtual ~TattooTalk() {}
+	
+	/**
+	 * Called whenever a conversation or item script needs to be run. For standard conversations,
+	 * it opens up a description window similar to how 'talk' does, but shows a 'reply' directly
+	 * instead of waiting for a statement option.
+	 * @remarks		It seems that at some point, all item scripts were set up to use this as well.
+	 *	In their case, the conversation display is simply suppressed, and control is passed on to
+	 *	doScript to implement whatever action is required.
+	 */
+	virtual void talkTo(const Common::String filename);
+
+	/**
+	 * Push the details of a passed object onto the saved sequences stack
+	 */
+	virtual void pushSequenceEntry(Object *obj);
+
+	/**
+	 * Pulls a background object sequence from the sequence stack and restore's the
+	 * object's sequence
+	 */
+	virtual void pullSequence(int slot = -1);
+
+	/**
+	 * Returns true if the script stack is empty
+	 */
+	virtual bool isSequencesEmpty() const;
+
+	/**
+	 * Clears the stack of pending object sequences associated with speakers in the scene
+	 */
+	virtual void clearSequences();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/tattoo_user_interface.cpp b/engines/sherlock/tattoo/tattoo_user_interface.cpp
new file mode 100644
index 0000000000..ee028f89c2
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_user_interface.cpp
@@ -0,0 +1,968 @@
+/* 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 "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_journal.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+bool WidgetList::contains(const WidgetBase *item) const {
+	for (const_iterator i = begin(); i != end(); ++i) {
+		if ((*i) == item)
+			return true;
+	}
+
+	return false;
+}
+
+/*-------------------------------------------------------------------------*/
+
+TattooUserInterface::TattooUserInterface(SherlockEngine *vm): UserInterface(vm),
+		_inventoryWidget(vm), _messageWidget(vm), _textWidget(vm), _tooltipWidget(vm), 
+		_verbsWidget(vm), _creditsWidget(vm), _optionsWidget(vm), _quitWidget(vm) {
+	Common::fill(&_lookupTable[0], &_lookupTable[PALETTE_COUNT], 0);
+	Common::fill(&_lookupTable1[0], &_lookupTable1[PALETTE_COUNT], 0);
+	_scrollSize = 0;
+	_scrollSpeed = 16;
+	_drawMenu = false;
+	_bgShape = nullptr;
+	_personFound = false;
+	_lockoutTimer = 0;
+	_exitZone = -1;
+	_scriptZone = -1;
+	_arrowZone = _oldArrowZone = -1;
+	_activeObj = -1;
+	_cAnimFramePause = 0;
+	_scrollHighlight = SH_NONE;
+	_mask = _mask1 = nullptr;
+	_maskCounter = 0;
+
+	_interfaceImages = new ImageFile("intrface.vgs");
+}
+
+TattooUserInterface::~TattooUserInterface() {
+	delete _interfaceImages;
+	delete _mask;
+	delete _mask1;
+}
+
+void TattooUserInterface::initScrollVars() {
+	Screen &screen = *_vm->_screen;
+	_scrollSize = screen._backBuffer1.w() - SHERLOCK_SCREEN_WIDTH;
+	_targetScroll = Common::Point(0, 0);
+	screen._currentScroll = Common::Point(0, 0);
+}
+
+void TattooUserInterface::lookAtObject() {
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Sound &sound = *_vm->_sound;
+	Talk &talk = *_vm->_talk;
+	Common::Point mousePos = events.mousePos();
+	Common::String desc;
+
+	_lookPos = mousePos;
+	_menuMode = LOOK_MODE;
+
+	if (_personFound) {
+		desc = people[_bgFound - 1000]._examine;
+	} else {
+		// Check if there is a Look animation
+		if (_bgShape->_lookcAnim != 0) {
+			int cAnimSpeed = _bgShape->_lookcAnim & 0xe0;
+			cAnimSpeed >>= 5;
+			++cAnimSpeed;
+
+			_cAnimFramePause = _bgShape->_lookFrames;
+			desc = _bgShape->_examine;
+
+			int cNum = (_bgShape->_lookcAnim & 0x1f) - 1;
+			scene.startCAnim(cNum);
+		} else if (_bgShape->_lookPosition.y != 0) {
+			// Need to walk to object before looking at it
+			people[HOLMES].walkToCoords(_bgShape->_lookPosition, _bgShape->_lookPosition._facing);
+		}
+
+		if (!talk._talkToAbort) {
+			desc = _bgShape->_examine;
+
+			if (_bgShape->_lookFlag)
+				_vm->setFlags(_bgShape->_lookFlag);
+
+			// Find the Sound File to Play if there is one
+			if (!desc.hasPrefix("_")) {
+				for (uint idx = 0; idx < scene._objSoundList.size(); ++idx) {
+					// Get the object name up to the equals
+					const char *p = strchr(scene._objSoundList[idx].c_str(), '=');
+
+					// Form the name and remove any trailing spaces
+					Common::String name(scene._objSoundList[idx].c_str(), p);
+					while (name.hasSuffix(" "))
+						name.deleteLastChar();
+
+					// See if this Object Sound List entry matches the object's name
+					if (!_bgShape->_name.compareToIgnoreCase(name)) {					
+						// Move forward to get the sound filename
+						while ((*p == ' ') || (*p == '='))
+							++p;
+
+						// If it's not "NONE", play the speech File
+						Common::String soundName(p);
+						if (soundName.compareToIgnoreCase("NONE")) {
+							soundName.toLowercase();
+							if (!soundName.contains('.'))
+								soundName += ".wav";
+
+							sound.playSound(soundName, WAIT_RETURN_IMMEDIATELY);
+						}
+
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	// Only show the desciption if the object has one, and if no talk file interrupted while walking to it
+	if (!talk._talkToAbort && !desc.empty()) {
+		if (_cAnimFramePause == 0)
+			printObjectDesc(desc, true);
+		else
+			// The description was already printed by an animation
+			_cAnimFramePause = 0;
+	} else if (desc.empty()) {
+		// There was no description to display, so reset back to STD_MODE
+		_menuMode = STD_MODE;
+	}
+}
+
+void TattooUserInterface::printObjectDesc(const Common::String &str, bool firstTime) {
+	Events &events = *_vm->_events;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Talk &talk = *_vm->_talk;
+
+	if (str.hasPrefix("_")) {
+		// The passed string specifies a talk file
+		_lookScriptFlag = true;
+		events.setCursor(MAGNIFY);
+		int savedSelector = _selector;
+
+		if (!_invLookFlag)
+			_windowOpen = false;
+
+		talk.talkTo(str.c_str() + 1);
+		_lookScriptFlag = false;
+
+		if (talk._talkToAbort) {
+			events.setCursor(ARROW);
+			return;
+		}
+
+		// See if we're looking at an inventory item
+		if (_invLookFlag) {
+			_selector = _oldSelector = savedSelector;
+			doInventory(0);
+			_invLookFlag = false;
+
+		} else {
+			// Nope
+			events.setCursor(ARROW);
+			_key = -1;
+			_menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+			events._pressed = events._released = events._rightReleased = false;
+			events._oldButtons = 0;
+		}
+	} else {
+		events._pressed = events._released = events._rightReleased = false;
+
+		// Show text dialog
+		_textWidget.load(str);
+		_textWidget.summonWindow();
+
+		if (firstTime)
+			_selector = _oldSelector = -1;
+
+		_drawMenu = _windowOpen = true;
+	}
+}
+
+void TattooUserInterface::doJournal() {
+	TattooJournal &journal = *(TattooJournal *)_vm->_journal;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	byte lookupTable[PALETTE_COUNT], lookupTable1[PALETTE_COUNT];
+
+	Common::copy(&_lookupTable[0], &_lookupTable[PALETTE_COUNT], &lookupTable[0]);
+	Common::copy(&_lookupTable1[0], &_lookupTable1[PALETTE_COUNT], &lookupTable1[0]);
+	_menuMode = JOURNAL_MODE;
+	journal.show();
+
+	_menuMode = STD_MODE;
+	_windowOpen = false;
+	_key = -1;
+
+	// Restore the the old screen palette and greyscale lookup table
+	screen.clear();
+	screen.setPalette(screen._cMap);
+	Common::copy(&lookupTable[0], &lookupTable[PALETTE_COUNT], &_lookupTable[0]);
+	Common::copy(&lookupTable1[0], &lookupTable1[PALETTE_COUNT], &_lookupTable1[0]);
+
+	// Restore the scene
+	screen._backBuffer1.blitFrom(screen._backBuffer2);
+	scene.updateBackground();
+	screen.slamArea(screen._currentScroll.x, screen._currentScroll.y, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
+}
+
+void TattooUserInterface::reset() {
+	UserInterface::reset();
+	_lookPos = Common::Point(SHERLOCK_SCREEN_WIDTH / 2, SHERLOCK_SCREEN_HEIGHT / 2);
+	_tooltipWidget.setText("");
+	_widgets.clear();
+	_fixedWidgets.clear();
+}
+
+void TattooUserInterface::handleInput() {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Events &events = *_vm->_events;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Common::Point mousePos = events.mousePos();
+
+	_keyState.keycode = Common::KEYCODE_INVALID;
+
+	// Check for credits starting
+	if (_vm->readFlags(3000) && !_creditsWidget.active())
+		_creditsWidget.initCredits();
+
+	// Check the mouse positioning
+	if (events.isCursorVisible())
+		_bgFound = scene.findBgShape(mousePos);
+	_personFound = _bgFound >= 1000;
+	_bgShape = (_bgFound != -1 && _bgFound < 1000) ? &scene._bgShapes[_bgFound] : nullptr;
+
+	if (_lockoutTimer)
+		--_lockoutTimer;
+	
+	// Key handling
+	if (events.kbHit()) {
+		_keyState = events.getKey();
+
+		if (_keyState.keycode == Common::KEYCODE_ESCAPE && vm._runningProlog && !_lockoutTimer) {
+			vm.setFlags(-76);
+			vm.setFlags(396);
+			scene._goToScene = STARTING_GAME_SCENE;
+		} else if (_menuMode == STD_MODE) {
+			if (_keyState.keycode == Common::KEYCODE_s && vm._allowFastMode) {
+				events.toggleSpeed();
+
+			} else if (_keyState.keycode == Common::KEYCODE_l && _bgFound != -1) {
+				// Beging used for testing that Look dialogs work
+				lookAtObject();
+			}
+		}
+	}
+
+	if (!events.isCursorVisible())
+		_keyState.keycode = Common::KEYCODE_INVALID;
+
+	// If there's any active widgets/windows, let the most recently open one do event processing
+	if (!_widgets.empty())
+		_widgets.back()->handleEvents();
+	else if (!_fixedWidgets.empty())
+		_fixedWidgets.back()->handleEvents();
+
+	// Handle input depending on what mode we're in
+	switch (_menuMode) {
+	case STD_MODE:
+		doStandardControl();
+		break;
+	case LOOK_MODE:
+		doLookControl();
+		break;
+	default:
+		break;
+	}
+}
+
+void TattooUserInterface::drawInterface(int bufferNum) {
+	Screen &screen = *_vm->_screen;
+
+	// Draw any active on-screen widgets
+	for (Common::List<WidgetBase *>::iterator i = _fixedWidgets.begin(); i != _fixedWidgets.end(); ++i)
+		(*i)->draw();
+	for (Common::List<WidgetBase *>::iterator i = _widgets.begin(); i != _widgets.end(); ++i)
+		(*i)->draw();
+
+	// Handle drawing credits
+	// TODO: See if credits are only shown on a single screen. If so, _fixedWidgets could be used
+	if (_creditsWidget.active())
+		_creditsWidget.drawCredits();
+
+	// Bring the widgets to the screen
+	if (_mask != nullptr)
+		screen._flushScreen = true;
+}
+
+void TattooUserInterface::doBgAnimRestoreUI() {
+	TattooScene &scene = *((TattooScene *)_vm->_scene);
+	Screen &screen = *_vm->_screen;
+
+	// If there are any on-screen widgets, then erase them
+	for (Common::List<WidgetBase *>::iterator i = _widgets.begin(); i != _widgets.end(); ++i)
+		(*i)->erase();
+	for (Common::List<WidgetBase *>::iterator i = _fixedWidgets.begin(); i != _fixedWidgets.end(); ++i)
+		(*i)->erase();
+
+	// If there is a Text Tag being display, restore the area underneath it
+	_tooltipWidget.erase();
+
+	// If a canimation is active, restore the graphics underneath it
+	if (scene._activeCAnim.active())
+		screen.restoreBackground(scene._activeCAnim._oldBounds);
+
+	// If a canimation just ended, remove its graphics from the backbuffer
+	if (scene._activeCAnim._removeBounds.width() > 0)
+		screen.restoreBackground(scene._activeCAnim._removeBounds);
+}
+
+void TattooUserInterface::doScroll() {
+	Screen &screen = *_vm->_screen;
+
+	// If we're already at the target scroll position, nothing needs to be done
+	if (_targetScroll.x == screen._currentScroll.x)
+		return;
+
+	screen._flushScreen = true;
+	if (_targetScroll.x > screen._currentScroll.x) {
+		screen._currentScroll.x += _scrollSpeed;
+		if (screen._currentScroll.x > _targetScroll.x)
+			screen._currentScroll.x = _targetScroll.x;
+	} else if (_targetScroll.x < screen._currentScroll.x) {
+		screen._currentScroll.x -= _scrollSpeed;
+		if (screen._currentScroll.x < _targetScroll.x)
+			screen._currentScroll.x = _targetScroll.x;
+	}
+
+	// Reset the default look position to the center of the new screen area
+	_lookPos = screen._currentScroll + Common::Point(SHERLOCK_SCREEN_WIDTH / 2, SHERLOCK_SCREEN_HEIGHT / 2);
+}
+
+void TattooUserInterface::doStandardControl() {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	SaveManager &saves = *_vm->_saves;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Talk &talk = *_vm->_talk;
+	Common::Point mousePos = events.mousePos();
+
+	// Don't do any input processing whilst the prolog is running
+	if (vm._runningProlog)
+		return;
+
+	// When the end credits are active, any press will open the ScummVM global main menu
+	if (_creditsWidget.active()) {
+		if (_keyState.keycode || events._released || events._rightReleased) {
+			vm._canLoadSave = true;
+			vm.openMainMenuDialog();
+			vm._canLoadSave = false;
+		}
+
+		return;
+	}
+
+	// Display the names of any Objects the cursor is pointing at
+	displayObjectNames();
+
+	switch (_keyState.keycode) {
+	case Common::KEYCODE_F5:
+		// Save game
+		events.warpMouse();
+		saveGame();
+		return;
+
+	case Common::KEYCODE_F7:
+		// Load game
+		events.warpMouse();
+		loadGame();
+		return;
+
+	case Common::KEYCODE_F1:
+		// Display journal
+		if (vm.readFlags(FLAG_PLAYER_IS_HOLMES)) {
+			freeMenu();
+			doJournal();
+			
+			// See if we're in a Lab Table Room
+			_menuMode = (scene._labTableScene) ? LAB_MODE : STD_MODE;
+			return;
+		}
+		break;
+
+	case Common::KEYCODE_TAB:
+	case Common::KEYCODE_F3:
+		// Display inventory
+		freeMenu();
+		doInventory(3);
+		return;
+
+	case Common::KEYCODE_F4:
+		// Display options
+		events.warpMouse();
+		_optionsWidget.load();
+		return;
+
+	case Common::KEYCODE_F10:
+		// Quit menu
+		freeMenu();
+		events.warpMouse();
+		doQuitMenu();
+		return;
+
+	default:
+		break;
+	}
+
+	// See if a mouse button was released
+	if (events._released || events._rightReleased) {
+		// See if the mouse was released in an exit (Arrow) zone. Unless it's also pointing at an object
+		// within the zone, in which case the object gets precedence
+		_exitZone = -1;
+		if (_arrowZone != -1 && events._released)
+			_exitZone = _arrowZone;
+
+		// Turn any Text display off
+		if (_arrowZone == -1 || events._rightReleased)
+			freeMenu();
+
+		bool noDesc = false;
+		if (_personFound) {
+			if (people[_bgFound - 1000]._description.empty() || people[_bgFound - 1000]._description.hasPrefix(" "))
+				noDesc = true;
+		} else if (_bgFound != -1) {
+			if (_bgShape->_description.empty() || _bgShape->_description.hasPrefix(" "))
+				noDesc = true;
+		} else {
+			noDesc = true;
+		}
+
+		if (events._rightReleased) {
+			// Show the verbs menu for the highlighted object
+			_tooltipWidget.banishWindow();
+			saves.createThumbnail();
+			_verbsWidget.load(!noDesc);
+			_verbsWidget.summonWindow();
+
+			_selector = _oldSelector = -1;
+			_activeObj = _bgFound;
+			_menuMode = VERB_MODE;
+		} else if (_personFound || (_bgFound != -1 && _bgFound < 1000 && _bgShape->_aType == PERSON)) {
+			// The object found is a person (the default for people is TALK)
+			talk.initTalk(_bgFound);
+			_activeObj = -1;
+		} else if (!noDesc) {
+			// Either call the code to Look at its Examine Field or call the Exit animation
+			// if the object is an exit, specified by the first four characters of the name being "EXIT"
+			Common::String name = _personFound ? people[_bgFound - 1000]._name : _bgShape->_name;
+			if (!name.hasPrefix("EXIT")) {
+				lookAtObject();
+			} else {
+				// Run the Exit animation and set which scene to go to next
+				for (int idx = 0; idx < 6; ++idx) {
+					if (!_bgShape->_use[idx]._verb.compareToIgnoreCase("Open")) {
+						checkAction(_bgShape->_use[idx], _bgFound);
+						_activeObj = -1;
+					}
+				}
+			}
+		} else {
+			// See if there are any Script Zones where they clicked
+			if (scene.checkForZones(mousePos, _scriptZone) != 0) {
+				// Mouse click in a script zone
+				events._pressed = events._released = false;
+			} else if (scene.checkForZones(mousePos, NOWALK_ZONE) != 0) {
+				events._pressed = events._released = false;
+			} else {
+				// Walk to where the mouse was clicked
+				people[HOLMES]._walkDest = mousePos;
+				people[HOLMES].goAllTheWay();
+			}
+		}
+	}
+}
+
+void TattooUserInterface::doLookControl() {
+	Events &events = *_vm->_events;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+
+	// See if a mouse button was released or a key pressed to close the active look dialog
+	if (events._released || events._rightReleased || _keyState.keycode) {
+		// See if we were looking at an inventory object
+		if (!_invLookFlag) {
+			// See if there is any more text to display
+			if (!_textWidget._remainingText.empty()) {
+				printObjectDesc(_textWidget._remainingText, false);
+			} else {
+				// Otherwise restore the background and go back into STD_MODE
+				freeMenu();
+				_key = -1;
+				_menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+
+				events.setCursor(ARROW);
+				events._pressed = events._released = events._rightReleased = false;
+				events._oldButtons = 0;
+			}
+		} else {
+			// We were looking at a Inventory object
+			// Erase the text window, and then redraw the inventory window
+			_textWidget.banishWindow();
+			doInventory(0);
+
+			_invLookFlag = false;
+			_key = -1;
+
+			events.setCursor(ARROW);
+			events._pressed = events._released = events._rightReleased = false;
+			events._oldButtons = 0;
+		}
+	}
+}
+
+void TattooUserInterface::displayObjectNames() {
+	Events &events = *_vm->_events;
+	Scene &scene = *_vm->_scene;
+	Common::Point mousePos = events.mousePos();
+	_arrowZone = -1;
+
+	if (_bgFound == -1 || scene._currentScene == OVERHEAD_MAP2) {
+		for (uint idx = 0; idx < scene._exits.size() && _arrowZone == -1; ++idx) {
+			Exit &exit = scene._exits[idx];
+			if (exit.contains(mousePos))
+				_arrowZone = idx;
+		}
+	}
+
+	_tooltipWidget.handleEvents();
+	_oldArrowZone = _arrowZone;
+}
+
+void TattooUserInterface::doInventory(int mode) {
+	People &people = *_vm->_people;
+	people[HOLMES].gotoStand();
+	
+	_inventoryWidget.load(mode);
+	_inventoryWidget.summonWindow();
+
+	_menuMode = INV_MODE;
+}
+
+void TattooUserInterface::doControls() {
+	_optionsWidget.load();
+}
+
+void TattooUserInterface::pickUpObject(int objNum) {
+	Inventory &inv = *_vm->_inventory;
+	Scene &scene = *_vm->_scene;
+	Talk &talk = *_vm->_talk;
+	Object &obj = scene._bgShapes[objNum];
+	bool printed = false;
+	int verbField = -1;
+
+	// Find which Verb field to use for pick up data
+	for (int idx = 0; idx < 6; ++idx) {
+		if (!scumm_stricmp(obj._use[idx]._target.c_str(), "*PICKUP"))
+			verbField = idx;
+	}
+
+	if (verbField != -1) {
+		if (obj._use[verbField]._cAnimNum)
+			scene.startCAnim(obj._use[verbField]._cAnimNum - 1);
+	}
+
+	if (!talk._talkToAbort) {
+		if (obj._type == NO_SHAPE)
+			obj._type = INVALID;
+		else
+			// Erase shape
+			obj._type = REMOVE;
+	} else {
+		return;
+	}
+
+	if (verbField != -1) {
+		for (int idx = 0; idx < 4 && !talk._talkToAbort; ++idx) {
+			if (obj.checkNameForCodes(obj._use[verbField]._names[idx])) {
+				if (!talk._talkToAbort)
+					printed = true;
+			}
+		}
+	}
+
+	if (talk._talkToAbort)
+		return;
+
+	// Add the item to the player's inventory
+	inv.putItemInInventory(obj);
+
+	if (!printed) {
+		Common::String desc = obj._description;
+		desc.setChar(tolower(desc[0]), 0);
+
+		putMessage("%s %s", FIXED(PickedUp), desc.c_str());
+	}
+
+	if (_menuMode != TALK_MODE && _menuMode != MESSAGE_MODE) {
+		_menuMode = STD_MODE;
+		_keyState.keycode = Common::KEYCODE_INVALID;
+	}
+}
+
+void TattooUserInterface::doQuitMenu() {
+	_quitWidget.show();
+}
+
+void TattooUserInterface::putMessage(const char *formatStr, ...) {
+	// Create the string to display
+	va_list args;
+	va_start(args, formatStr);
+	Common::String str = Common::String::vformat(formatStr, args);
+	va_end(args);
+
+	// Open the message widget
+	_menuMode = MESSAGE_MODE;
+	_messageWidget.load(str, 25);
+	_messageWidget.summonWindow();
+}
+
+void TattooUserInterface::setupBGArea(const byte cMap[PALETTE_SIZE]) {
+	Scene &scene = *_vm->_scene;
+
+	// This requires that there is a 16 grayscale palette sequence in the palette that goes from lighter 
+	// to darker as the palette numbers go up. The last palette entry in that run is specified by _bgColor
+	byte *p = &_lookupTable[0];
+	for (int idx = 0; idx < PALETTE_COUNT; ++idx)
+		*p++ = BG_GREYSCALE_RANGE_END - (cMap[idx * 3] * 30 + cMap[idx * 3 + 1] * 59 + cMap[idx * 3 + 2] * 11) / 480;
+
+	// If we're going to a scene with a haze special effect, initialize the translate table to lighten the colors
+	if (_mask != nullptr) {
+		p = &_lookupTable1[0];
+
+		for (int idx = 0; idx < PALETTE_COUNT; ++idx) {
+			int r, g, b;
+			switch (scene._currentScene) {
+			case 8:
+				r = cMap[idx * 3] * 4 / 5;
+				g = cMap[idx * 3 + 1] * 3 / 4;
+				b = cMap[idx * 3 + 2] * 3 / 4;
+				break;
+
+			case 18:
+			case 68:
+				r = cMap[idx * 3] * 4 / 3;
+				g = cMap[idx * 3 + 1] * 4 / 3;
+				b = cMap[idx * 3 + 2] * 4 / 3;
+				break;
+
+			case 7:
+			case 53:
+				r = cMap[idx * 3] * 4 / 3;
+				g = cMap[idx * 3 + 1] * 4 / 3;
+				b = cMap[idx * 3 + 2] * 4 / 3;
+				break;
+			
+			default:
+				r = g = b = 0;
+				break;
+			}
+
+			byte c = 0xff;
+			int cd = 99999;
+
+			for (int pal = 0; pal < PALETTE_COUNT; ++pal) {
+				int d = (r - cMap[pal * 3]) * (r - cMap[pal * 3]) + (g - cMap[pal * 3 + 1]) * (g - cMap[pal * 3 + 1]) + 
+					(b - cMap[pal * 3 + 2]) * (b - cMap[pal * 3 + 2]);
+
+				if (d < cd) {
+					c = pal;
+					cd = d;
+					if (!d)
+						break;
+				}
+			}
+			*p++ = c;
+		}
+	}
+}
+
+void TattooUserInterface::doBgAnimEraseBackground() {
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	
+	static const int16 OFFSETS[16] = { -1, -2, -3, -3, -2, -1, -1, 0, 1, 2, 3, 3, 2, 1, 0, 0 };
+
+	if (_mask != nullptr) {
+		// Since a mask is active, restore the screen from the secondary back buffer prior to applying the mask
+		screen._backBuffer1.blitFrom(screen._backBuffer2, screen._currentScroll, Common::Rect(screen._currentScroll.x, 0, 
+			screen._currentScroll.x + SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));
+
+		switch (scene._currentScene) {
+		case 7:
+			if (++_maskCounter == 2) {
+				_maskCounter = 0;
+				if (--_maskOffset.x < 0)
+					_maskOffset.x = SHERLOCK_SCREEN_WIDTH - 1;
+			}
+			break;
+
+		case 8:
+			_maskOffset.x += 2;
+			if (_maskOffset.x >= SHERLOCK_SCREEN_WIDTH)
+				_maskOffset.x = 0;
+			break;
+
+		case 18:
+		case 68:
+			++_maskCounter;
+			if (_maskCounter / 4 >= 16)
+				_maskCounter = 0;
+
+			_maskOffset.x = OFFSETS[_maskCounter / 4];
+			break;
+
+		case 53:
+			if (++_maskCounter == 2) {
+				_maskCounter = 0;
+				if (++_maskOffset.x == screen._backBuffer1.w())
+					_maskOffset.x = 0;
+			}
+			break;
+
+		default:
+			break;
+		}
+	} else {
+		// Standard scene without mask, so call user interface to erase any UI elements as necessary
+		doBgAnimRestoreUI();
+		
+		// Restore background for any areas covered by characters and shapes
+		for (int idx = 0; idx < MAX_CHARACTERS; ++idx)
+			screen.restoreBackground(Common::Rect(people[idx]._oldPosition.x, people[idx]._oldPosition.y,
+				people[idx]._oldPosition.x + people[idx]._oldSize.x, people[idx]._oldPosition.y + people[idx]._oldSize.y));
+
+		for (uint idx = 0; idx < scene._bgShapes.size(); ++idx) {
+			Object &obj = scene._bgShapes[idx];
+						
+			if ((obj._type == ACTIVE_BG_SHAPE && (obj._maxFrames > 1 || obj._delta.x != 0 || obj._delta.y != 0)) || 
+					obj._type == HIDE_SHAPE || obj._type == REMOVE)
+				screen._backBuffer1.blitFrom(screen._backBuffer2, obj._oldPosition, 
+					Common::Rect(obj._oldPosition.x, obj._oldPosition.y, obj._oldPosition.x + obj._oldSize.x,
+						obj._oldPosition.y + obj._oldSize.y));
+		}
+
+		// If credits are active, erase the area they cover
+		if (_creditsWidget.active())
+			_creditsWidget.eraseCredits();
+	}
+
+	for (uint idx = 0; idx < scene._bgShapes.size(); ++idx) {
+		Object &obj = scene._bgShapes[idx];
+
+		if (obj._type == NO_SHAPE && (obj._flags & 1) == 0) {
+			screen._backBuffer1.blitFrom(screen._backBuffer2, obj._position, obj.getNoShapeBounds());
+
+			obj._oldPosition = obj._position;
+			obj._oldSize = obj._noShapeSize;
+		}
+	}
+
+	// Adjust the Target Scroll if needed
+	if ((people[people._walkControl]._position.x / FIXED_INT_MULTIPLIER - screen._currentScroll.x) < 
+			(SHERLOCK_SCREEN_WIDTH / 8) && people[people._walkControl]._delta.x < 0) {
+		
+		_targetScroll.x = (short)(people[people._walkControl]._position.x / FIXED_INT_MULTIPLIER - 
+				SHERLOCK_SCREEN_WIDTH / 8 - 250);
+		if (_targetScroll.x < 0)
+			_targetScroll.x = 0;
+	}
+
+	if ((people[people._walkControl]._position.x / FIXED_INT_MULTIPLIER - screen._currentScroll.x) >
+			(SHERLOCK_SCREEN_WIDTH / 4 * 3)	&& people[people._walkControl]._delta.x > 0)
+		_targetScroll.x = (short)(people[people._walkControl]._position.x / FIXED_INT_MULTIPLIER - 
+			SHERLOCK_SCREEN_WIDTH / 4 * 3 + 250);
+
+	if (_targetScroll.x > _scrollSize)
+		_targetScroll.x = _scrollSize;
+
+	doScroll();
+}
+
+void TattooUserInterface::drawMaskArea(bool mode) {
+	Scene &scene = *_vm->_scene;
+	int xp = mode ? _maskOffset.x : 0;
+
+	if (_mask != nullptr) {
+		switch (scene._currentScene) {
+		case 7:
+			maskArea(*_mask, Common::Point(_maskOffset.x - SHERLOCK_SCREEN_WIDTH, 110));
+			maskArea(*_mask, Common::Point(_maskOffset.x, 110));
+			maskArea(*_mask, Common::Point(_maskOffset.x + SHERLOCK_SCREEN_WIDTH, 110));
+			break;
+
+		case 8:
+			maskArea(*_mask, Common::Point(_maskOffset.x - SHERLOCK_SCREEN_WIDTH, 180));
+			maskArea(*_mask, Common::Point(_maskOffset.x, 180));
+			maskArea(*_mask, Common::Point(_maskOffset.x + SHERLOCK_SCREEN_WIDTH, 180));
+			if (!_vm->readFlags(880))
+				maskArea(*_mask1, Common::Point(940, 300));
+			break;
+
+		case 18:
+			maskArea(*_mask, Common::Point(xp, 203));
+			if (!_vm->readFlags(189))
+				maskArea(*_mask1, Common::Point(124 + xp, 239));
+			break;
+
+		case 53:
+			maskArea(*_mask, Common::Point(_maskOffset.x, 110));
+			if (mode)
+				maskArea(*_mask, Common::Point(_maskOffset.x - SHERLOCK_SCREEN_WIDTH, 110));
+			break;
+
+		case 68:
+			maskArea(*_mask, Common::Point(xp, 203));
+			maskArea(*_mask1, Common::Point(124 + xp, 239));
+			break;
+		}
+	}
+}
+
+void TattooUserInterface::maskArea(Common::SeekableReadStream &mask, const Common::Point &pt) {
+	Screen &screen = *_vm->_screen;
+	Surface &bb1 = screen._backBuffer1;
+	mask.seek(0);
+	int xSize = mask.readUint16LE();
+	int ySize = mask.readUint16LE();
+	int pixel, len, xp, yp;
+
+	for (yp = 0; yp < ySize; ++yp) {
+		byte *ptr = bb1.getBasePtr(pt.x, pt.y + yp);
+
+		for (xp = 0; xp < xSize;) {
+			// The mask data consists of pairs of pixel/lengths, where all non-zero pixels means that the
+			// given pixel on the back buffer is darkened (the mask pixel value isn't otherwise used)
+			pixel = mask.readByte();
+			len = mask.readByte();
+
+			for (; len > 0; --len, ++xp, ++ptr) {
+				if (pixel && (pt.x + xp) >= screen._currentScroll.x && (pt.x + xp) < (screen._currentScroll.x + SHERLOCK_SCREEN_WIDTH)) {
+					*ptr = _lookupTable1[*ptr];
+				}
+			}
+		}
+
+		assert(xp == xSize);
+	}
+}
+
+void TattooUserInterface::makeBGArea(const Common::Rect &r) {
+	Screen &screen = *_vm->_screen;
+
+	for (int yp = r.top; yp < r.bottom; ++yp) {
+		byte *ptr = screen._backBuffer1.getBasePtr(r.left, yp);
+
+		for (int xp = r.left; xp < r.right; ++xp, ++ptr)
+			*ptr = _lookupTable[*ptr];
+	}
+
+	screen.slamRect(r);
+}
+
+void TattooUserInterface::drawDialogRect(Surface &s, const Common::Rect &r, bool raised) {
+	if (raised) {
+		// Draw Left
+		s.vLine(r.left, r.top, r.bottom - 1, INFO_TOP);
+		s.vLine(r.left + 1, r.top, r.bottom - 2, INFO_TOP);
+		// Draw Top
+		s.hLine(r.left + 2, r.top, r.right - 1, INFO_TOP);
+		s.hLine(r.left + 2, r.top + 1, r.right - 2, INFO_TOP);
+		// Draw Right
+		s.vLine(r.right - 1, r.top + 1, r.bottom - 1, INFO_BOTTOM);
+		s.vLine(r.right - 2, r.top + 2, r.bottom - 1, INFO_BOTTOM);
+		// Draw Bottom
+		s.hLine(r.left + 1, r.bottom - 1, r.right - 3, INFO_BOTTOM);
+		s.hLine(r.left + 2, r.bottom - 2, r.right - 3, INFO_BOTTOM);
+
+	} else {
+		// Draw Left
+		s.vLine(r.left, r.top, r.bottom - 1, INFO_BOTTOM);
+		s.vLine(r.left + 1, r.top, r.bottom - 2, INFO_BOTTOM);
+		// Draw Top
+		s.hLine(r.left + 2, r.top, r.right - 1, INFO_BOTTOM);
+		s.hLine(r.left + 2, r.top + 1, r.right - 2, INFO_BOTTOM);
+		// Draw Right
+		s.vLine(r.right - 1, r.top + 1, r.bottom - 1, INFO_TOP);
+		s.vLine(r.right - 2, r.top + 2, r.bottom - 1, INFO_TOP);
+		// Draw Bottom
+		s.hLine(r.left + 1, r.bottom - 1, r.right - 3, INFO_TOP);
+		s.hLine(r.left + 2, r.bottom - 2, r.right - 3, INFO_TOP);
+	}
+}
+
+void TattooUserInterface::banishWindow(bool slideUp) {
+	if (!_widgets.empty())
+		_widgets.back()->banishWindow();
+}
+
+void TattooUserInterface::freeMenu() {
+	for (Common::List<WidgetBase *>::iterator i = _widgets.begin(); i != _widgets.end(); ++i)
+		(*i)->erase();
+	_widgets.clear();
+}
+
+void TattooUserInterface::clearWindow() {
+	banishWindow();
+}
+
+void TattooUserInterface::loadGame() {
+	WidgetFiles &files = *(WidgetFiles *)_vm->_saves;
+	files.show(SAVEMODE_LOAD);
+}
+
+void TattooUserInterface::saveGame() {
+	WidgetFiles &files = *(WidgetFiles *)_vm->_saves;
+	files.show(SAVEMODE_SAVE);
+}
+
+void TattooUserInterface::addFixedWidget(WidgetBase *widget) {
+	_fixedWidgets.push_back(widget);
+	widget->summonWindow();
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/tattoo_user_interface.h b/engines/sherlock/tattoo/tattoo_user_interface.h
new file mode 100644
index 0000000000..d89da4a6da
--- /dev/null
+++ b/engines/sherlock/tattoo/tattoo_user_interface.h
@@ -0,0 +1,264 @@
+/* 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 SHERLOCK_TATTOO_UI_H
+#define SHERLOCK_TATTOO_UI_H
+
+#include "common/scummsys.h"
+#include "common/list.h"
+#include "sherlock/saveload.h"
+#include "sherlock/screen.h"
+#include "sherlock/user_interface.h"
+#include "sherlock/tattoo/widget_credits.h"
+#include "sherlock/tattoo/widget_files.h"
+#include "sherlock/tattoo/widget_inventory.h"
+#include "sherlock/tattoo/widget_options.h"
+#include "sherlock/tattoo/widget_quit.h"
+#include "sherlock/tattoo/widget_text.h"
+#include "sherlock/tattoo/widget_tooltip.h"
+#include "sherlock/tattoo/widget_verbs.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+// Button width/height
+#define BUTTON_SIZE 15				
+// How long to play the intro before it can be skipped
+#define STARTUP_KEYS_DISABLED_DELAY 200
+
+class WidgetBase;
+
+enum ScrollHighlight { SH_NONE = 0, SH_SCROLL_UP = 1, SH_PAGE_UP = 2, SH_THUMBNAIL = 3, SH_PAGE_DOWN = 4, SH_SCROLL_DOWN = 5 };
+
+class WidgetList : public Common::List <WidgetBase *> {
+public:
+	bool contains(const WidgetBase *item) const;
+};
+
+class TattooUserInterface : public UserInterface {
+	friend class WidgetBase;
+private:
+	int _scriptZone;
+	int _cAnimFramePause;
+	WidgetInventory _inventoryWidget;
+	WidgetMessage _messageWidget;
+	WidgetQuit _quitWidget;
+	WidgetList _fixedWidgets;
+	WidgetList _widgets;
+	byte _lookupTable[PALETTE_COUNT];
+	byte _lookupTable1[PALETTE_COUNT];
+private:
+	/**
+	 * Handle any input when we're in standard mode (with no windows open)
+	 */
+	void doStandardControl();
+
+	/**
+	 * Handle input when in look mode
+	 */
+	void doLookControl();
+
+	/**
+	 * Handle input when the File window is open
+	 */
+	void doFileControl();
+
+	/**
+	 * Handle input while the verb menu is open
+	 */
+	void doVerbControl();
+
+	/**
+	 * Free any active menu
+	 */
+	void freeMenu();
+public:
+	Common::Point _targetScroll;
+	int _scrollSize, _scrollSpeed;
+	bool _drawMenu;
+	int _arrowZone, _oldArrowZone;
+	Object *_bgShape;
+	bool _personFound;
+	int _activeObj;
+	Common::KeyState _keyState;
+	Common::Point _lookPos;
+	ScrollHighlight _scrollHighlight;
+	Common::SeekableReadStream *_mask, *_mask1;
+	Common::Point _maskOffset;
+	int _maskCounter;
+	int _lockoutTimer;
+	ImageFile *_interfaceImages;
+	WidgetCredits _creditsWidget;
+	WidgetOptions _optionsWidget;
+	WidgetText _textWidget;
+	WidgetSceneTooltip _tooltipWidget;
+	WidgetVerbs _verbsWidget;
+	WidgetList _postRenderWidgets;
+public:
+	TattooUserInterface(SherlockEngine *vm);
+	virtual ~TattooUserInterface();
+
+	/**
+	 * Handles restoring any areas of the back buffer that were/are covered by UI elements
+	 */
+	void doBgAnimRestoreUI();
+
+	/**
+	 * Checks to see if the screen needs to be scrolled. If so, scrolls it towards the target position
+	 */
+	void doScroll();
+
+	/**
+	 * Initializes scroll variables
+	 */
+	void initScrollVars();
+
+	/**
+	 * Display the long description for an object in a window
+	 */
+	void lookAtObject();
+
+	/**
+	 * Display the passed long description for an object. If the flag firstTime is set,
+	 * the window will be opened to accomodate the text. Otherwise, the remaining text
+	 * will be printed in an already open window
+	 */
+	void printObjectDesc(const Common::String &str, bool firstTime);
+
+	/**
+	 * Handles displaying the journal
+	 */
+	void doJournal();
+
+	/**
+	 * Put the game in inventory mode by opening the inventory dialog
+	 */
+	void doInventory(int mode);
+
+	/**
+	 * Handle the display of the options/setup menu
+	 */
+	void doControls();
+
+	/**
+	 * Handle the display of the quit menu
+	 */
+	void doQuitMenu();
+
+	/**
+	 * Pick up the selected object
+	 */
+	void pickUpObject(int objNum);
+
+	/**
+	 * This will display a text message in a dialog at the bottom of the screen
+	 */
+	void putMessage(const char *formatStr, ...) GCC_PRINTF(2, 3);
+
+	/**
+	 * Makes a greyscale translation table for each palette entry in the table
+	 */
+	void setupBGArea(const byte cMap[PALETTE_SIZE]);
+
+	/**
+	 * Erase any background as needed before drawing frame
+	 */
+	void doBgAnimEraseBackground();
+
+	/**
+	 * Draws overlays onto the scene. Basically, the smoke effects some scenes have
+	 */
+	void drawMaskArea(bool mode);
+
+	/**
+	 * Takes the data passed in the image and apply it to the surface at the given position.
+	 * The src mask data is encoded with a different color for each item. To highlight one,
+	 the runs that do not match the highlight number will be darkened
+	 */
+	void maskArea(Common::SeekableReadStream &mask, const Common::Point &pt);
+
+	/**
+	 * Translate a given area of the back buffer to greyscale shading
+	 */
+	void makeBGArea(const Common::Rect &r);
+
+	/**
+	 * Draws all the dialog rectangles for any items that need them
+	 */
+	void drawDialogRect(Surface &s, const Common::Rect &r, bool raised);
+
+	/**
+	 * If the mouse cursor is point at the cursor, then display the name of the object on the screen.
+	 * If there is no object being pointed it, clear any previously displayed name
+	 */
+	void displayObjectNames();
+
+	/**
+	 * Show the load game dialog, and allow the user to load a game
+	 */
+	void loadGame();
+
+	/**
+	 * Show the save game dialog, and allow the user to save the game
+	 */
+	void saveGame();
+
+	/**
+	 * Add a widget to the current scene to be executed if there are no active widgets in the
+	 * main _widgets list
+	 */
+	void addFixedWidget(WidgetBase *widget);
+public:
+	/**
+	 * Resets the user interface
+	 */
+	virtual void reset();
+
+	/**
+	 * Main input handler for the user interface
+	 */
+	virtual void handleInput();
+
+	/**
+	 * Draw the user interface onto the screen's back buffers
+	 */	
+	virtual void drawInterface(int bufferNum = 3);
+
+	/**
+	 * Clear any active text window
+	 */
+	virtual void clearWindow();
+
+	/**
+	 * Banish any active window
+	 * @remarks		Tattoo doesn't use sliding windows, but the parameter is in the base
+	 * UserInterface class as a convenience for Scalpel UI code
+	 */
+	virtual void banishWindow(bool slideUp = true);
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_base.cpp b/engines/sherlock/tattoo/widget_base.cpp
new file mode 100644
index 0000000000..9e10cee0d1
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_base.cpp
@@ -0,0 +1,375 @@
+/* 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 "sherlock/tattoo/widget_base.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_talk.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+WidgetBase::WidgetBase(SherlockEngine *vm) : _vm(vm) {
+	_scroll = false;
+	_dialogTimer = 0;
+}
+
+void WidgetBase::summonWindow() {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	// Double-check that the same widget isn't added twice
+	if (ui._widgets.contains(this))
+		error("Tried to add a widget multiple times");
+
+	// Add widget to the screen
+	if (!ui._fixedWidgets.contains(this))
+		ui._widgets.push_back(this);
+	ui._windowOpen = true;
+
+	_outsideMenu = false;
+
+	draw();
+}
+
+void WidgetBase::banishWindow() {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	erase();
+	_surface.free();
+	ui._widgets.remove(this);
+	ui._windowOpen = false;
+}
+
+void WidgetBase::close() {
+	Events &events = *_vm->_events;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	banishWindow();
+	ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+	events.clearEvents();
+}
+
+bool WidgetBase::active() const {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	for (Common::List<WidgetBase *>::iterator i = ui._widgets.begin(); i != ui._widgets.end(); ++i) {
+		if ((*i) == this)
+			return true;
+	}
+
+	return false;
+}
+
+
+void WidgetBase::erase() {
+	Screen &screen = *_vm->_screen;
+
+	if (_oldBounds.width() > 0) {
+		// Restore the affected area from the secondary back buffer into the first one, and then copy to screen
+		screen._backBuffer1.blitFrom(screen._backBuffer2, Common::Point(_oldBounds.left, _oldBounds.top), _oldBounds);
+		screen.slamRect(_oldBounds);
+
+		// Reset the old bounds so it won't be erased again
+		_oldBounds = Common::Rect(0, 0, 0, 0);
+	}
+}
+
+void WidgetBase::draw() {
+	Screen &screen = *_vm->_screen;
+
+	// If there was a previously drawn frame in a different position that hasn't yet been erased, then erase it
+	if (_oldBounds.width() > 0 && _oldBounds != _bounds)
+		erase();
+
+	if (_bounds.width() > 0 && !_surface.empty()) {
+		// Get the area to draw, adjusted for scroll position
+		restrictToScreen();
+		
+		// Draw the background for the widget
+		drawBackground();
+
+		// Draw the widget onto the back buffer and then slam it to the screen
+		screen._backBuffer1.transBlitFrom(_surface, Common::Point(_bounds.left, _bounds.top));
+		screen.slamRect(_bounds);
+
+		// Store a copy of the drawn area for later erasing
+		_oldBounds = _bounds;
+	}
+}
+
+void WidgetBase::drawBackground() {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Screen &screen = *_vm->_screen;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	Common::Rect bounds = _bounds;
+
+	if (vm._transparentMenus) {
+		ui.makeBGArea(bounds);
+	} else {
+		bounds.grow(-3);
+		screen._backBuffer1.fillRect(bounds, MENU_BACKGROUND);
+	}
+}
+
+Common::String WidgetBase::splitLines(const Common::String &str, Common::StringArray &lines, int maxWidth, uint maxLines) {
+	Talk &talk = *_vm->_talk;
+	const char *strP = str.c_str();
+
+	// Loop counting up lines
+	lines.clear();
+	do {
+		int width = 0;
+		const char *spaceP = nullptr;
+		const char *lineStartP = strP;
+
+		// Find how many characters will fit on the next line
+		while (width < maxWidth && *strP && ((byte)*strP < talk._opcodes[OP_SWITCH_SPEAKER] || 
+				(byte)*strP == talk._opcodes[OP_NULL])) {
+			width += _surface.charWidth(*strP);
+
+			// Keep track of the last space
+			if (*strP == ' ')
+				spaceP = strP;
+			++strP;
+		}
+
+		// If the line was too wide to fit on a single line, go back to the last space 
+		// if there was one, or otherwise simply break the line at this point
+		if (width >= maxWidth && spaceP != nullptr)
+			strP = spaceP;
+
+		// Add the line to the output array
+		lines.push_back(Common::String(lineStartP, strP));
+
+		// Move the string ahead to the next line
+		if (*strP == ' ' || *strP == 13)
+			++strP;
+	} while (*strP && (lines.size() < maxLines) && ((byte)*strP < talk._opcodes[OP_SWITCH_SPEAKER] 
+			|| (byte)*strP == talk._opcodes[OP_NULL]));
+
+	// Return any remaining text left over
+	return *strP ? Common::String(strP) : Common::String();
+}
+
+void WidgetBase::restrictToScreen() {
+	Screen &screen = *_vm->_screen;
+
+	if (_bounds.left < screen._currentScroll.x)
+		_bounds.moveTo(screen._currentScroll.x, _bounds.top);
+	if (_bounds.top < 0)
+		_bounds.moveTo(_bounds.left, 0);
+	if (_bounds.right > (screen._currentScroll.x + SHERLOCK_SCREEN_WIDTH))
+		_bounds.moveTo(screen._currentScroll.x + SHERLOCK_SCREEN_WIDTH - _bounds.width(), _bounds.top);
+	if (_bounds.bottom > screen._backBuffer1.h())
+		_bounds.moveTo(_bounds.left, screen._backBuffer1.h() - _bounds.height());
+}
+
+void WidgetBase::makeInfoArea(Surface &s) {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	ImageFile &images = *ui._interfaceImages;
+
+	// Draw the four corners of the Info Box
+	s.transBlitFrom(images[0], Common::Point(0, 0));
+	s.transBlitFrom(images[1], Common::Point(s.w() - images[1]._width, 0));
+	s.transBlitFrom(images[2], Common::Point(0, s.h() - images[2]._height));
+	s.transBlitFrom(images[3], Common::Point(s.w() - images[3]._width, s.h()));
+
+	// Draw the top of the Info Box
+	s.hLine(images[0]._width, 0, s.w() - images[1]._width, INFO_TOP);
+	s.hLine(images[0]._width, 1, s.w() - images[1]._width, INFO_MIDDLE);
+	s.hLine(images[0]._width, 2, s.w() - images[1]._width, INFO_BOTTOM);
+
+	// Draw the bottom of the Info Box
+	s.hLine(images[0]._width, s.h()- 3, s.w() - images[1]._width, INFO_TOP);
+	s.hLine(images[0]._width, s.h()- 2, s.w() - images[1]._width, INFO_MIDDLE);
+	s.hLine(images[0]._width, s.h()- 1, s.w() - images[1]._width, INFO_BOTTOM);
+
+	// Draw the left Side of the Info Box
+	s.vLine(0, images[0]._height, s.h()- images[2]._height, INFO_TOP);
+	s.vLine(1, images[0]._height, s.h()- images[2]._height, INFO_MIDDLE);
+	s.vLine(2, images[0]._height, s.h()- images[2]._height, INFO_BOTTOM);
+
+	// Draw the right Side of the Info Box
+	s.vLine(s.w() - 3, images[0]._height, s.h()- images[2]._height, INFO_TOP);
+	s.vLine(s.w() - 2, images[0]._height, s.h()- images[2]._height, INFO_MIDDLE);
+	s.vLine(s.w() - 1, images[0]._height, s.h()- images[2]._height, INFO_BOTTOM);
+}
+
+void WidgetBase::makeInfoArea() {
+	makeInfoArea(_surface);
+}
+
+void WidgetBase::drawDialogRect(const Common::Rect &r, bool raised) {
+	static_cast<TattooUserInterface *>(_vm->_ui)->drawDialogRect(_surface, r, raised);
+}
+
+void WidgetBase::checkTabbingKeys(int numOptions) {
+}
+
+Common::Rect WidgetBase::getScrollBarBounds() const {
+	Common::Rect r(BUTTON_SIZE, _bounds.height() - 6);
+	r.moveTo(_bounds.width() - BUTTON_SIZE - 3, 3);
+	return r;
+}
+
+void WidgetBase::drawScrollBar(int index, int pageSize, int count) {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	// Fill the area with transparency
+	Common::Rect r = getScrollBarBounds();
+	_surface.fillRect(r, TRANSPARENCY);
+
+	bool raised = ui._scrollHighlight != 1;
+	_surface.fillRect(Common::Rect(r.left + 2, r.top + 2, r.right - 2, r.top + BUTTON_SIZE - 2), INFO_MIDDLE);
+	ui.drawDialogRect(_surface, Common::Rect(r.left, r.top, r.left + BUTTON_SIZE, r.top + BUTTON_SIZE), raised);
+
+	raised = ui._scrollHighlight != 5;
+	_surface.fillRect(Common::Rect(r.left + 2, r.bottom - BUTTON_SIZE + 2, r.right - 2, r.bottom - 2), INFO_MIDDLE);
+	ui.drawDialogRect(_surface, Common::Rect(r.left, r.bottom - BUTTON_SIZE, r.right, r.bottom), raised);
+
+	// Draw the arrows on the scroll buttons
+	byte color = index ? INFO_BOTTOM + 2 : INFO_BOTTOM;
+	_surface.hLine(r.left + r.width() / 2, r.top - 2 + BUTTON_SIZE / 2, r.left + r.width() / 2, color);
+	_surface.hLine(r.left + r.width() / 2 - 1, r.top - 1 + BUTTON_SIZE / 2, r.left + r.width() / 2 + 1, color);
+	_surface.hLine(r.left + r.width() / 2 - 2, r.top + BUTTON_SIZE / 2, r.left + r.width() / 2 + 2, color);
+	_surface.hLine(r.left + r.width() / 2 - 3, r.top + 1 + BUTTON_SIZE / 2, r.left + r.width() / 2 + 3, color);
+
+	color = (index + pageSize) < count ? INFO_BOTTOM + 2 : INFO_BOTTOM;
+	_surface.hLine(r.left + r.width() / 2 - 3, r.bottom - 1 - BUTTON_SIZE + BUTTON_SIZE / 2, r.left + r.width() / 2 + 3, color);
+	_surface.hLine(r.left + r.width() / 2 - 2, r.bottom - 1 - BUTTON_SIZE + 1 + BUTTON_SIZE / 2, r.left + r.width() / 2 + 2, color);
+	_surface.hLine(r.left + r.width() / 2 - 1, r.bottom - 1 - BUTTON_SIZE + 2 + BUTTON_SIZE / 2, r.left + r.width() / 2 + 1, color);
+	_surface.hLine(r.left + r.width() / 2, r.bottom - 1 - BUTTON_SIZE + 3 + BUTTON_SIZE / 2, r.left + r.width() / 2, color);
+
+	// Draw the scroll position bar
+	int barHeight = (r.height() - BUTTON_SIZE * 2) * pageSize / count;
+	barHeight = CLIP(barHeight, BUTTON_SIZE, r.height() - BUTTON_SIZE * 2);
+	int barY = (count <= pageSize) ? r.top + BUTTON_SIZE : r.top + BUTTON_SIZE + 
+		(r.height() - BUTTON_SIZE * 2 - barHeight) * index / (count - pageSize);
+
+	_surface.fillRect(Common::Rect(r.left + 2, barY + 2, r.right - 2, barY + barHeight - 3), INFO_MIDDLE);
+	ui.drawDialogRect(_surface, Common::Rect(r.left, barY, r.right, barY + barHeight), true);
+}
+
+void WidgetBase::handleScrollbarEvents(int index, int pageSize, int count) {
+	Events &events = *_vm->_events;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+
+	// If they're dragging the scrollbar thumb, keep it selected whilst the button is being held
+	if ((events._pressed || events._released) && ui._scrollHighlight == SH_THUMBNAIL)
+		return;
+
+	ui._scrollHighlight = SH_NONE;
+
+	if ((!events._pressed && !events._rightReleased) || !_scroll)
+		return;
+
+	Common::Rect r = getScrollBarBounds();
+	r.translate(_bounds.left, _bounds.top);
+
+	// Calculate the Scroll Position bar
+	int barHeight = (r.height() - BUTTON_SIZE * 2) * pageSize / count;
+	barHeight = CLIP(barHeight, BUTTON_SIZE, r.height() - BUTTON_SIZE * 2);
+	int barY = (count <= pageSize) ? r.top + BUTTON_SIZE : r.top + BUTTON_SIZE +
+		(r.height() - BUTTON_SIZE * 2 - barHeight) * index / (count - pageSize);
+
+	if (Common::Rect(r.left, r.top, r.right, r.top + BUTTON_SIZE).contains(mousePos))
+		// Mouse on scroll up button
+		ui._scrollHighlight = SH_SCROLL_UP;
+	else if (Common::Rect(r.left, r.top + BUTTON_SIZE, r.right, barY).contains(mousePos))
+		// Mouse on paging up area (the area of the vertical bar above the thumbnail)
+		ui._scrollHighlight = SH_PAGE_UP;
+	else if (Common::Rect(r.left, barY, r.right, barY + barHeight).contains(mousePos))
+		// Mouse on scrollbar thumb
+		ui._scrollHighlight = SH_THUMBNAIL;
+	else if (Common::Rect(r.left, barY + barHeight, r.right, r.bottom - BUTTON_SIZE).contains(mousePos))
+		// Mouse on paging down area (the area of the vertical bar below the thumbnail)
+		ui._scrollHighlight = SH_PAGE_DOWN;
+	else if (Common::Rect(r.left, r.bottom - BUTTON_SIZE, r.right, r.bottom).contains(mousePos))
+		// Mouse on scroll down button
+		ui._scrollHighlight = SH_SCROLL_DOWN;
+}
+
+void WidgetBase::handleScrolling(int &scrollIndex, int pageSize, int max) {
+	Events &events = *_vm->_events;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::KeyCode keycode = ui._keyState.keycode;
+	Common::Point mousePos = events.mousePos();
+
+	Common::Rect r = getScrollBarBounds();
+	r.translate(_bounds.left, _bounds.top);
+
+	if (ui._scrollHighlight != SH_NONE || keycode == Common::KEYCODE_HOME || keycode == Common::KEYCODE_END
+		|| keycode == Common::KEYCODE_PAGEUP || keycode == Common::KEYCODE_PAGEDOWN
+		|| keycode == Common::KEYCODE_UP || keycode == Common::KEYCODE_DOWN) {
+		// Check for the scrollbar
+		if (ui._scrollHighlight == SH_THUMBNAIL) {
+			int yp = mousePos.y;
+			yp = CLIP(yp, r.top + BUTTON_SIZE + 3, r.bottom - BUTTON_SIZE - 3);
+
+			// Calculate the line number that corresponds to the position that the mouse is on the scrollbar
+			int lineNum = (yp - r.top - BUTTON_SIZE - 3) * (max - pageSize) / (r.height() - BUTTON_SIZE * 2 - 6);
+			scrollIndex = CLIP(lineNum, 0, max - pageSize);
+		}
+
+		// Get the current frame so we can check the scroll timer against it
+		uint32 frameNum = events.getFrameCounter();
+
+		if (frameNum > _dialogTimer) {
+			// Set the timeout for the next scroll if the mouse button remains held down
+			_dialogTimer = (_dialogTimer == 0) ? frameNum + pageSize : frameNum + 1;
+
+			// Check for Scroll Up
+			if ((ui._scrollHighlight == SH_SCROLL_UP || keycode == Common::KEYCODE_UP) && scrollIndex)
+				--scrollIndex;
+
+			// Check for Page Up
+			else if ((ui._scrollHighlight == SH_PAGE_UP || keycode == Common::KEYCODE_PAGEUP) && scrollIndex)
+				scrollIndex -= pageSize;
+
+			// Check for Page Down
+			else if ((ui._scrollHighlight == SH_PAGE_DOWN || keycode == Common::KEYCODE_PAGEDOWN)
+				&& (scrollIndex + pageSize < max)) {
+				scrollIndex += pageSize;
+				if (scrollIndex + pageSize >max)
+					scrollIndex = max - pageSize;
+			}
+
+			// Check for Scroll Down
+			else if ((ui._scrollHighlight == SH_SCROLL_DOWN || keycode == Common::KEYCODE_DOWN) && (scrollIndex + pageSize < max))
+				++scrollIndex;
+		}
+
+		if (keycode == Common::KEYCODE_END)
+			scrollIndex = max - pageSize;
+
+		if (scrollIndex < 0 || keycode == Common::KEYCODE_HOME)
+			scrollIndex = 0;
+	}
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_base.h b/engines/sherlock/tattoo/widget_base.h
new file mode 100644
index 0000000000..dcafc8fb21
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_base.h
@@ -0,0 +1,147 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_TATTOO_WIDGET_BASE_H
+#define SHERLOCK_TATTOO_WIDGET_BASE_H
+
+#include "common/scummsys.h"
+#include "common/rect.h"
+#include "common/str-array.h"
+#include "sherlock/surface.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+class ImageFile;
+
+namespace Tattoo {
+
+class WidgetBase {
+private:
+	uint32 _dialogTimer;
+protected:
+	SherlockEngine *_vm;
+	Common::Rect _bounds;
+	Common::Rect _oldBounds;
+	Surface _surface;
+	bool _outsideMenu;
+	bool _scroll;
+
+	/**
+	 * Used by descendent classes to split up long text for display across multiple lines
+	 */
+	Common::String splitLines(const Common::String &str, Common::StringArray &lines, int maxWidth, uint maxLines);
+
+	/**
+	 * Ensure that menu is drawn entirely on-screen
+	 */
+	void restrictToScreen();
+
+	/**
+	 * Draw a window frame around the dges of the passed surface
+	 */
+	void makeInfoArea(Surface &s);
+
+	/**
+	 * Draw a window frame around the widget's surface
+	 */
+	void makeInfoArea();
+
+	/**
+	 * Draw a dialog rectangle
+	 */
+	void drawDialogRect(const Common::Rect &r, bool raised = true);
+
+	/**
+	 * Return the area of a widget that the scrollbar will be drawn in
+	 */
+	virtual Common::Rect getScrollBarBounds() const;
+
+	/**
+	 * Draw the scrollbar for the dialog
+	 */
+	void drawScrollBar(int index, int pageSize, int count);
+
+	/**
+	 * Handles any events when the mouse is on the scrollbar
+	 */
+	void handleScrollbarEvents(int index, int pageSize, int count);
+
+	/**
+	 * Handle adjusting a passed scrolling index as necessary
+	 */
+	void handleScrolling(int &scrollIndex, int pageSize, int max);
+
+	/**
+	 * Close the dialog
+	 */
+	void close();
+
+	/**
+	 * Handle drawing the background on the area the widget is going to cover
+	 */
+	virtual void drawBackground();
+public:
+	WidgetBase(SherlockEngine *vm);
+	virtual ~WidgetBase() {}
+
+	/**
+	 * Returns true if the given widget is active in the user interface's widget list
+	 */
+	bool active() const;
+
+	/**
+	 * Erase any previous display of the widget on the screen
+	 */
+	virtual void erase();
+
+	/**
+	 * Update the display of the widget on the screen
+	 */
+	virtual void draw();
+
+	/**
+	 * Used by some descendents to check for keys to mouse the mouse within the dialog
+	 */
+	void checkTabbingKeys(int numOptions);
+
+	/**
+	 * Summon the window
+	 */
+	virtual void summonWindow();
+
+	/**
+	 * Close a currently active menu
+	 */
+	virtual void banishWindow();
+
+	/**
+	 * Handle event processing
+	 */
+	virtual void handleEvents() {}
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_credits.cpp b/engines/sherlock/tattoo/widget_credits.cpp
new file mode 100644
index 0000000000..b8e297709f
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_credits.cpp
@@ -0,0 +1,215 @@
+/* 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 "sherlock/tattoo/widget_credits.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+WidgetCredits::WidgetCredits(SherlockEngine *vm) : _vm(vm) {
+	_creditSpeed = 4;
+	_creditsActive = false;
+}
+
+void WidgetCredits::initCredits() {
+	Resources &res = *_vm->_res;
+	Screen &screen = *_vm->_screen;
+	Common::SeekableReadStream *stream = res.load("credits.txt");
+	int spacing = screen.fontHeight() * 2;
+	int yp = screen.h();
+
+	_creditsActive = true;
+	_creditLines.clear();
+
+	while (stream->pos() < stream->size()) {
+		Common::String line = stream->readLine();
+
+		if (line.hasPrefix("Scroll Speed")) {
+			const char *p = line.c_str() + 12;
+			while ((*p < '0') || (*p > '9'))
+				p++;
+			
+			_creditSpeed = atoi(p);
+		} else if (line.hasPrefix("Y Spacing")) {
+			const char *p = line.c_str() + 12;
+			while ((*p < '0') || (*p > '9'))
+				p++;
+
+			spacing = atoi(p) + screen.fontHeight() + 1;
+		} else {
+			int width = screen.stringWidth(line) + 2;
+
+			_creditLines.push_back(CreditLine(line, Common::Point((screen.w() - width) / 2 + 1, yp), width));
+			yp += spacing;
+		}
+	}
+
+	// Post-processing for finding split lines
+	for (int l = 0; l < (int)_creditLines.size(); ++l) {
+		CreditLine &cl = _creditLines[l];
+		const char *p = strchr(cl._line.c_str(), '-');
+
+		if (p != nullptr && p[1] == '>') {
+			cl._line2 = Common::String(p + 3);
+			cl._line = Common::String(cl._line.c_str(), p);
+			
+			int width = cl._width;
+			int width1 = screen.stringWidth(cl._line);
+			int width2 = screen.stringWidth(cl._line2);
+
+			int c = 1;
+			for (int l1 = l + 1; l1 < (int)_creditLines.size(); ++l1) {
+				if ((p = strchr(_creditLines[l1]._line.c_str(), '-')) != nullptr) {
+					if (p[1] == '>') {
+						Common::String line1 = Common::String(_creditLines[l1]._line.c_str(), p);
+						Common::String line2 = Common::String(p + 3);
+
+						width1 = MAX(width1, screen.stringWidth(line1));
+
+						if (screen.stringWidth(line2) > width2)
+							width2 = screen.stringWidth(line2);
+						++c;
+					} else {
+						break;
+					}
+				} else {
+					break;
+				}
+			}
+
+			width = width1 + width2 + screen.widestChar();
+			width1 += screen.widestChar();
+
+			for (int l1 = l; l1 < l + c; ++l1) {
+				_creditLines[l1]._width = width;
+				_creditLines[l1]._xOffset = width1;
+			}
+
+			l += c - 1;
+		}
+	}
+
+	delete stream;
+}
+
+void WidgetCredits::close() {
+	_creditsActive = false;
+	_creditLines.clear();
+}
+
+void WidgetCredits::drawCredits() {
+	Screen &screen = *_vm->_screen;
+	Common::Rect screenRect(0, 0, screen.w(), screen.h());
+	Surface &bb1 = screen._backBuffer1;
+
+	for (uint idx = 0; idx < _creditLines.size() && _creditLines[idx]._position.y < screen.h(); ++idx) {
+		if (screenRect.contains(_creditLines[idx]._position)) {
+			if (!_creditLines[idx]._line2.empty()) {
+				int x1 = _creditLines[idx]._position.x;
+				int x2 = x1 + _creditLines[idx]._xOffset;
+				const Common::String &line1 = _creditLines[idx]._line;
+				const Common::String &line2 = _creditLines[idx]._line2;
+
+				bb1.writeString(line1, Common::Point(x1 - 1, _creditLines[idx]._position.y - 1), 0);
+				bb1.writeString(line1, Common::Point(x1, _creditLines[idx]._position.y - 1), 0);
+				bb1.writeString(line1, Common::Point(x1 + 1, _creditLines[idx]._position.y - 1), 0);
+
+				bb1.writeString(line1, Common::Point(x1 - 1, _creditLines[idx]._position.y), 0);
+				bb1.writeString(line1, Common::Point(x1 + 1, _creditLines[idx]._position.y), 0);
+
+				bb1.writeString(line1, Common::Point(x1 - 1, _creditLines[idx]._position.y + 1), 0);
+				bb1.writeString(line1, Common::Point(x1, _creditLines[idx]._position.y + 1), 0);
+				bb1.writeString(line1, Common::Point(x1 + 1, _creditLines[idx]._position.y + 1), 0);
+
+				bb1.writeString(line1, Common::Point(x1, _creditLines[idx]._position.y), INFO_TOP);
+
+				bb1.writeString(line2, Common::Point(x2 - 1, _creditLines[idx]._position.y - 1), 0);
+				bb1.writeString(line2, Common::Point(x2, _creditLines[idx]._position.y - 1), 0);
+				bb1.writeString(line2, Common::Point(x2 + 1, _creditLines[idx]._position.y - 1), 0);
+
+				bb1.writeString(line2, Common::Point(x2 - 1, _creditLines[idx]._position.y), 0);
+				bb1.writeString(line2, Common::Point(x2 + 1, _creditLines[idx]._position.y), 0);
+
+				bb1.writeString(line2, Common::Point(x2 - 1, _creditLines[idx]._position.y + 1), 0);
+				bb1.writeString(line2, Common::Point(x2, _creditLines[idx]._position.y + 1), 0);
+				bb1.writeString(line2, Common::Point(x2 + 1, _creditLines[idx]._position.y + 1), 0);
+
+				bb1.writeString(line2, Common::Point(x2, _creditLines[idx]._position.y), INFO_TOP);
+			} else {
+				bb1.writeString(_creditLines[idx]._line, Common::Point(_creditLines[idx]._position.x - 1, _creditLines[idx]._position.y - 1), 0);
+				bb1.writeString(_creditLines[idx]._line, Common::Point(_creditLines[idx]._position.x, _creditLines[idx]._position.y - 1), 0);
+				bb1.writeString(_creditLines[idx]._line, Common::Point(_creditLines[idx]._position.x + 1, _creditLines[idx]._position.y - 1), 0);
+
+				bb1.writeString(_creditLines[idx]._line, Common::Point(_creditLines[idx]._position.x - 1, _creditLines[idx]._position.y), 0);
+				bb1.writeString(_creditLines[idx]._line, Common::Point(_creditLines[idx]._position.x + 1, _creditLines[idx]._position.y), 0);
+
+				bb1.writeString(_creditLines[idx]._line, Common::Point(_creditLines[idx]._position.x - 1, _creditLines[idx]._position.y + 1), 0);
+				bb1.writeString(_creditLines[idx]._line, Common::Point(_creditLines[idx]._position.x, _creditLines[idx]._position.y + 1), 0);
+				bb1.writeString(_creditLines[idx]._line, Common::Point(_creditLines[idx]._position.x + 1, _creditLines[idx]._position.y + 1), 0);
+
+				bb1.writeString(_creditLines[idx]._line, Common::Point(_creditLines[idx]._position.x, _creditLines[idx]._position.y), INFO_TOP);
+			}
+		}
+	}
+}
+
+void WidgetCredits::blitCredits() {
+	Screen &screen = *_vm->_screen;
+	Common::Rect screenRect(0, -_creditSpeed, screen.w(), screen.h() + _creditSpeed);
+
+	for (uint idx = 0; idx < _creditLines.size(); ++idx) {
+		if (screenRect.contains(_creditLines[idx]._position)) {
+			Common::Rect r(_creditLines[idx]._width, screen.fontHeight() + 2);
+			r.moveTo(_creditLines[idx]._position.x, _creditLines[idx]._position.y - 1);
+
+			screen.slamRect(r);
+		}
+
+		_creditLines[idx]._position.y -= _creditSpeed;
+	}
+}
+
+void WidgetCredits::eraseCredits() {
+	Screen &screen = *_vm->_screen;
+	Common::Rect screenRect(0, -_creditSpeed, screen.w(), screen.h() + _creditSpeed);
+
+	for (uint idx = 0; idx < _creditLines.size(); ++idx) {
+		if (screenRect.contains(_creditLines[idx]._position)) {
+			Common::Rect r(_creditLines[idx]._width, screen.fontHeight() + 3);
+			r.moveTo(_creditLines[idx]._position.x, _creditLines[idx]._position.y - 1 + _creditSpeed);
+
+			screen.restoreBackground(r);
+		}
+	}
+
+	if (_creditLines[_creditLines.size() - 1]._position.y < -_creditSpeed) {
+		// Completely finished credits display. Note that the credits will still remain flagged as active,
+		// so that the user interface knows not to allow and standard scene interaction
+		_creditLines.clear();
+	}
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_credits.h b/engines/sherlock/tattoo/widget_credits.h
new file mode 100644
index 0000000000..d31c6ac216
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_credits.h
@@ -0,0 +1,89 @@
+/* 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 SHERLOCK_TATTOO_CREDITS_H
+#define SHERLOCK_TATTOO_CREDITS_H
+
+#include "common/array.h"
+#include "common/rect.h"
+
+namespace Sherlock {
+
+	class SherlockEngine;
+
+namespace Tattoo {
+
+struct CreditLine {
+	Common::Point _position;
+	int _xOffset;
+	int _width;
+	Common::String _line, _line2;
+
+	CreditLine(const Common::String &line, const Common::Point &pt, int width) :
+		_line(line), _position(pt), _width(width), _xOffset(0) {}
+};
+
+class WidgetCredits {
+private:
+	SherlockEngine *_vm;
+	Common::Array<CreditLine> _creditLines;
+	int _creditSpeed;
+	bool _creditsActive;
+public:
+	WidgetCredits(SherlockEngine *vm);
+
+	/**
+	 * Returns true if the credits are active
+	 */
+	bool active() const { return _creditsActive; }
+
+	/**
+	 * Initialize and load credit data for display
+	 */
+	void initCredits();
+
+	/**
+	 * Closes down credits display
+	 */
+	void close();
+
+	/**
+	 * Draw credits on the screen
+	 */
+	void drawCredits();
+
+	/**
+	 * Blit the drawn credits to the screen
+	 */
+	void blitCredits();
+
+	/**
+	 * Erase any area of the screen covered by credits
+	 */
+	void eraseCredits();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_files.cpp b/engines/sherlock/tattoo/widget_files.cpp
new file mode 100644
index 0000000000..0f5e6793c4
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_files.cpp
@@ -0,0 +1,427 @@
+/* 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/translation.h"
+#include "gui/saveload.h"
+#include "sherlock/tattoo/widget_files.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+#define FILES_LINES_COUNT 5
+
+WidgetFiles::WidgetFiles(SherlockEngine *vm, const Common::String &target) :
+		SaveManager(vm, target), WidgetBase(vm), _vm(vm) {
+	_fileMode = SAVEMODE_NONE;
+	_selector = _oldSelector = -1;
+}
+
+void WidgetFiles::show(SaveMode mode) {
+	Events &events = *_vm->_events;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+
+	if (_vm->_showOriginalSavesDialog) {
+		// Render and display the file dialog
+		_fileMode = mode;
+		ui._menuMode = FILES_MODE;
+		_selector = _oldSelector = -1;
+		_scroll = true;
+		createSavegameList();
+
+		// Set up the display area
+		_bounds = Common::Rect(SHERLOCK_SCREEN_WIDTH * 2 / 3, (_surface.fontHeight() + 1) * 
+			(FILES_LINES_COUNT + 1) + 17);
+		_bounds.moveTo(mousePos.x - _bounds.width() / 2, mousePos.y - _bounds.height() / 2);
+
+		// Create the surface and render its contents
+		_surface.create(_bounds.width(), _bounds.height());
+		render(RENDER_ALL);
+
+		summonWindow();
+		ui._menuMode = FILES_MODE;
+	} else if (mode == SAVEMODE_LOAD) {
+		showScummVMRestoreDialog();
+	} else {
+		showScummVMSaveDialog();
+	}
+}
+
+void WidgetFiles::showScummVMSaveDialog() {
+	GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Save game:"), _("Save"), true);
+
+	int slot = dialog->runModalWithCurrentTarget();
+	if (slot >= 0) {
+		Common::String desc = dialog->getResultString();
+
+		if (desc.empty()) {
+			// create our own description for the saved game, the user didn't enter it
+			desc = dialog->createDefaultSaveDescription(slot);
+		}
+
+		_vm->saveGameState(slot, desc);
+	}
+
+	close();
+	delete dialog;
+}
+
+void WidgetFiles::showScummVMRestoreDialog() {
+	GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Restore game:"), _("Restore"), false);
+	int slot = dialog->runModalWithCurrentTarget();
+	close();
+	delete dialog;
+
+	if (slot >= 0) {
+		_vm->loadGameState(slot);
+	}
+}
+
+void WidgetFiles::render(FilesRenderMode mode) {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	ImageFile &images = *ui._interfaceImages;
+	byte color;
+
+	if (mode == RENDER_ALL) {
+		_surface.fill(TRANSPARENCY);
+		makeInfoArea();
+
+		switch (_fileMode) {
+		case SAVEMODE_LOAD:
+			_surface.writeString(FIXED(LoadGame),
+				Common::Point((_surface.w() - _surface.stringWidth(FIXED(LoadGame))) / 2, 5), INFO_TOP);
+			break;
+
+		case SAVEMODE_SAVE:
+			_surface.writeString(FIXED(SaveGame),
+				Common::Point((_surface.w() - _surface.stringWidth(FIXED(SaveGame))) / 2, 5), INFO_TOP);
+			break;
+
+		default:
+			break;
+		}
+
+		_surface.hLine(3, _surface.fontHeight() + 7, _surface.w() - 4, INFO_TOP);
+		_surface.hLine(3, _surface.fontHeight() + 8, _surface.w() - 4, INFO_MIDDLE);
+		_surface.hLine(3, _surface.fontHeight() + 9, _surface.w() - 4, INFO_BOTTOM);
+		_surface.transBlitFrom(images[4], Common::Point(0, _surface.fontHeight() + 6));
+		_surface.transBlitFrom(images[5], Common::Point(_surface.w() - images[5]._width, _surface.fontHeight() + 6));
+
+		int xp = _surface.w() - BUTTON_SIZE - 6;
+		_surface.vLine(xp, _surface.fontHeight() + 10, _bounds.height() - 4, INFO_TOP);
+		_surface.vLine(xp + 1, _surface.fontHeight() + 10, _bounds.height() - 4, INFO_MIDDLE);
+		_surface.vLine(xp + 2, _surface.fontHeight() + 10, _bounds.height() - 4, INFO_BOTTOM);
+		_surface.transBlitFrom(images[6], Common::Point(xp - 1, _surface.fontHeight() + 8));
+		_surface.transBlitFrom(images[7], Common::Point(xp - 1, _bounds.height() - 4));
+	}
+
+	int xp = _surface.stringWidth("00.") + _surface.widestChar() + 5;
+	int yp = _surface.fontHeight() + 14;
+	
+	for (int idx = _savegameIndex; idx < (_savegameIndex + FILES_LINES_COUNT); ++idx) {
+		if (OP_NAMES || idx == _selector || idx == _oldSelector) {
+			if (idx == _selector && mode != RENDER_ALL)
+				color = COMMAND_HIGHLIGHTED;
+			else
+				color = INFO_TOP;
+
+			if (mode == RENDER_NAMES_AND_SCROLLBAR)
+				_surface.fillRect(Common::Rect(4, yp, _surface.w() - BUTTON_SIZE - 9, yp + _surface.fontHeight()), TRANSPARENCY);
+			
+			Common::String numStr = Common::String::format("%d.", idx + 1);
+			_surface.writeString(numStr, Common::Point(_surface.widestChar(), yp), color);
+			_surface.writeString(_savegames[idx], Common::Point(xp, yp), color);
+		}
+
+		yp += _surface.fontHeight() + 1;
+	}
+
+	// Draw the Scrollbar if neccessary
+	if (mode != RENDER_NAMES)
+		drawScrollBar(_savegameIndex, FILES_LINES_COUNT, _savegames.size());
+}
+
+void WidgetFiles::handleEvents() {
+	Events &events = *_vm->_events;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+	Common::KeyState keyState = ui._keyState;
+
+	// Handle scrollbar events
+	ScrollHighlight oldHighlight = ui._scrollHighlight;	
+	handleScrollbarEvents(_savegameIndex, FILES_LINES_COUNT, _savegames.size());
+
+	int oldScrollIndex = _savegameIndex;
+	handleScrolling(_savegameIndex, FILES_LINES_COUNT, _savegames.size());
+
+	// See if the mouse is pointing at any filenames in the window
+	if (Common::Rect(_bounds.left, _bounds.top + _surface.fontHeight() + 14,
+			_bounds.right - BUTTON_SIZE - 5, _bounds.bottom - 5).contains(mousePos)) {
+		_selector = (mousePos.y - _bounds.top - _surface.fontHeight() - 14) / (_surface.fontHeight() + 1) +
+			_savegameIndex;
+	} else {
+		_selector = -1;
+	}
+
+	// Check for the Tab key
+	if (keyState.keycode == Common::KEYCODE_TAB) {
+		// If the mouse is not over any of the filenames, move the mouse so that it points to the first one
+		if (_selector == -1) {
+			events.warpMouse(Common::Point(_bounds.right - BUTTON_SIZE - 20,
+				_bounds.top + _surface.fontHeight() * 2 + 8));
+		} else {
+			// See if we're doing Tab or Shift Tab
+			if (keyState.flags & Common::KBD_SHIFT) {
+				// We're doing Shift Tab
+				if (_selector == _savegameIndex)
+					_selector = _savegameIndex + 4;
+				else
+					--_selector;
+			} else {
+				// We're doing Tab
+				++_selector;
+				if (_selector >= _savegameIndex + 5)
+					_selector = _savegameIndex;
+			}
+
+			events.warpMouse(Common::Point(mousePos.x, _bounds.top + _surface.fontHeight() * 2
+				+ 8 + (_selector - _savegameIndex) * (_surface.fontHeight() + 1)));
+		}
+	}
+
+	// Only redraw the window if the the scrollbar position has changed
+	if (ui._scrollHighlight != oldHighlight || oldScrollIndex != _savegameIndex || _selector != _oldSelector)
+		render(RENDER_NAMES_AND_SCROLLBAR);
+	_oldSelector = _selector;
+
+	if (events._firstPress && !_bounds.contains(mousePos))
+		_outsideMenu = true;
+
+	if (events._released || events._rightReleased || keyState.keycode == Common::KEYCODE_ESCAPE) {
+		ui._scrollHighlight = SH_NONE;
+
+		if (_outsideMenu && !_bounds.contains(mousePos)) {
+			close();
+		} else {
+			_outsideMenu = false;
+
+			if (_selector != -1) {
+				if (_fileMode == SAVEMODE_LOAD) {
+					// We're in Load Mode
+					_vm->loadGameState(_selector);
+				} else if (_fileMode == SAVEMODE_SAVE) {
+					// We're in Save Mode
+					if (getFilename())
+						_vm->saveGameState(_selector, _savegames[_selector]);
+					close();
+				}
+			}
+		}
+	}
+}
+
+bool WidgetFiles::getFilename() {
+	Events &events = *_vm->_events;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	int index = 0;
+	int done = 0;
+	bool blinkFlag = false;
+	int blinkCountdown = 0;
+	int cursorColor = 192;
+	byte color, textColor;
+	bool insert = true;
+
+	assert(_selector != -1);
+	Common::Point pt(_surface.stringWidth("00.") + _surface.widestChar() + 5,
+		_surface.fontHeight() + 14 + (_selector - _savegameIndex) * (_surface.fontHeight() + 1));
+	
+	Common::String numStr = Common::String::format("%d.", _selector + 1);
+	_surface.writeString(numStr, Common::Point(_surface.widestChar(), pt.y), COMMAND_HIGHLIGHTED);
+
+	Common::String filename = _savegames[_selector];	
+
+	if (isSlotEmpty(_selector)) {
+		index = 0;
+		_surface.fillRect(Common::Rect(pt.x, pt.y, _bounds.right - BUTTON_SIZE - 9, pt.y + _surface.fontHeight() - 1), TRANSPARENCY);
+		filename = "";
+	} else {
+		index = filename.size();
+		_surface.writeString(filename, pt, COMMAND_HIGHLIGHTED);
+		pt.x = _surface.stringWidth("00.") + _surface.stringWidth(filename) + _surface.widestChar() + 5;
+	}
+
+	do {
+		scene.doBgAnim();
+
+		if (talk._talkToAbort)
+			return false;
+
+		char currentChar = (index == (int)filename.size()) ? ' ' : filename[index];
+		Common::String charString = Common::String::format("%c", currentChar);
+		int width = screen.charWidth(currentChar);
+
+		// Wait for keypress
+		while (!events.kbHit()) {
+			events.pollEventsAndWait();
+			events.setButtonState();
+
+			scene.doBgAnim();
+
+			if (talk._talkToAbort)
+				return false;
+
+			if (--blinkCountdown <= 0) {
+				blinkCountdown = 3;
+				blinkFlag = !blinkFlag;
+				if (blinkFlag) {
+					textColor = 236;
+					color = cursorColor;
+				} else {
+					textColor = COMMAND_HIGHLIGHTED;
+					color = TRANSPARENCY;
+				}
+
+				_surface.fillRect(Common::Rect(pt.x, pt.y, pt.x + width, pt.y + _surface.fontHeight()), color);
+				if (currentChar != ' ')
+					_surface.writeString(charString, pt, textColor);
+			}
+			if (_vm->shouldQuit())
+				return false;
+		}
+
+		Common::KeyState keyState = events.getKey();
+		if (keyState.keycode == Common::KEYCODE_BACKSPACE && index > 0) {
+			pt.x -= _surface.charWidth(filename[index - 1]);
+			--index;
+
+			if (insert) {
+				filename.deleteChar(index);
+			} else {
+				filename.setChar(' ', index);
+			}
+
+			_surface.fillRect(Common::Rect(pt.x, pt.y, _surface.w() - BUTTON_SIZE - 9, pt.y + _surface.fontHeight() - 1), TRANSPARENCY);
+			_surface.writeString(filename.c_str() + index, pt, COMMAND_HIGHLIGHTED);
+
+		} else if ((keyState.keycode == Common::KEYCODE_LEFT && index > 0)
+				|| (keyState.keycode == Common::KEYCODE_RIGHT && index < 49 && pt.x < (_bounds.right - BUTTON_SIZE - 20)) 
+				|| (keyState.keycode == Common::KEYCODE_HOME && index > 0)
+				|| (keyState.keycode == Common::KEYCODE_END)) {
+			_surface.fillRect(Common::Rect(pt.x, pt.y, pt.x + width, pt.y + _surface.fontHeight()), TRANSPARENCY);
+			if (currentChar)
+				_surface.writeString(charString, pt, COMMAND_HIGHLIGHTED);
+
+			switch (keyState.keycode) {
+			case Common::KEYCODE_LEFT:
+				pt.x -= _surface.charWidth(filename[index - 1]);
+				--index;
+				break;
+
+			case Common::KEYCODE_RIGHT:
+				pt.x += _surface.charWidth(filename[index]);
+				++index;
+				break;
+			
+			case Common::KEYCODE_HOME:
+				pt.x = _surface.stringWidth("00.") + _surface.widestChar() + 5;
+				index = 0;
+				break;
+
+			case Common::KEYCODE_END:
+				pt.x = _surface.stringWidth("00.") + _surface.stringWidth(filename) + _surface.widestChar() + 5;
+				index = filename.size();
+
+				while (filename[index - 1] == ' ' && index > 0) {
+					pt.x -= _surface.charWidth(filename[index - 1]);
+					--index;
+				}
+				break;
+
+			default:
+				break;
+			}
+		} else if (keyState.keycode == Common::KEYCODE_INSERT) {
+			insert = !insert;
+			if (insert)
+				cursorColor = 192;
+			else
+				cursorColor = 200;
+
+		} else if (keyState.keycode == Common::KEYCODE_DELETE) {
+			filename.deleteChar(index);
+
+			_surface.fillRect(Common::Rect(pt.x, pt.y, _bounds.right - BUTTON_SIZE - 9, pt.y + _surface.fontHeight() - 1), TRANSPARENCY);
+			_surface.writeString(filename + index, pt, COMMAND_HIGHLIGHTED);
+		
+		} else  if (keyState.keycode == Common::KEYCODE_RETURN) {
+			done = 1;
+
+		} else if (keyState.keycode == Common::KEYCODE_ESCAPE) {
+			_selector = -1;
+			render(RENDER_NAMES_AND_SCROLLBAR);
+			done = -1;
+		}
+
+		if ((keyState.ascii >= ' ') && ((keyState.ascii <= 168) || (keyState.ascii == 225)) && (index < 50)) {
+			if (pt.x + _surface.charWidth(keyState.ascii) < _surface.w() - BUTTON_SIZE - 20) {
+				if (insert)
+					filename.insertChar(keyState.ascii, index);
+				else
+					filename.setChar(keyState.ascii, index);
+
+				_surface.fillRect(Common::Rect(pt.x, pt.y, _bounds.width() - BUTTON_SIZE - 9, 
+					pt.y + _surface.fontHeight() - 1), TRANSPARENCY);
+				_surface.writeString(filename.c_str() + index, pt, COMMAND_HIGHLIGHTED);
+				pt.x += _surface.charWidth(keyState.ascii);
+				++index;
+			}
+		}
+	} while (!done && !_vm->shouldQuit());
+
+	scene.doBgAnim();
+
+	if (talk._talkToAbort)
+		return false;
+
+	if (done == 1)
+		_savegames[_selector] = filename;
+
+	return done == 1;
+}
+
+Common::Rect WidgetFiles::getScrollBarBounds() const {
+	Common::Rect scrollRect(BUTTON_SIZE, _bounds.height() - _surface.fontHeight() - 16);
+	scrollRect.moveTo(_bounds.width() - BUTTON_SIZE - 3, _surface.fontHeight() + 13);
+
+	return scrollRect;
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_files.h b/engines/sherlock/tattoo/widget_files.h
new file mode 100644
index 0000000000..94a029d18d
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_files.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 SHERLOCK_TATTOO_WIDGET_FILES_H
+#define SHERLOCK_TATTOO_WIDGET_FILES_H
+
+#include "common/scummsys.h"
+#include "sherlock/tattoo/widget_base.h"
+#include "sherlock/saveload.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+enum FilesRenderMode { RENDER_ALL, RENDER_NAMES, RENDER_NAMES_AND_SCROLLBAR };
+
+class WidgetFiles: public WidgetBase, public SaveManager {
+private:
+	SherlockEngine *_vm;
+	SaveMode _fileMode;
+	int _selector, _oldSelector;
+
+	/**
+	 * Render the dialog
+	 */
+	void render(FilesRenderMode mode);
+
+	/**
+	 * Show the ScummVM Save Game dialog
+	 */
+	void showScummVMSaveDialog();
+	
+	/**
+	 * Show the ScummVM Load Game dialog
+	 */
+	void showScummVMRestoreDialog();
+
+	/**
+	 * Prompt the user for a savegame name in the currently selected slot
+	 */
+	bool getFilename();
+
+	/**
+	 * Return the area of a widget that the scrollbar will be drawn in
+	 */
+	virtual Common::Rect getScrollBarBounds() const;
+public:
+	WidgetFiles(SherlockEngine *vm, const Common::String &target);
+	virtual ~WidgetFiles() {}
+
+	/**
+	 * Prompt the user whether to quit
+	 */
+	void show(SaveMode mode);
+
+	/**
+	 * Handle event processing
+	 */
+	virtual void handleEvents();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_foolscap.cpp b/engines/sherlock/tattoo/widget_foolscap.cpp
new file mode 100644
index 0000000000..8246e9a371
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_foolscap.cpp
@@ -0,0 +1,299 @@
+/* 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 "sherlock/tattoo/widget_foolscap.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+WidgetFoolscap::WidgetFoolscap(TattooEngine *vm) : WidgetBase(vm) {
+	for (int idx = 0; idx < 3; ++idx) {
+		Common::fill(&_answers[idx][0], &_answers[idx][10], 0);
+		_solutions[idx] = nullptr;
+	}
+	_images = nullptr;
+	_numWide = 0;
+	_spacing = 0;
+	_blinkFlag = false;
+	_blinkCounter = 0;
+	_lineNum = _charNum = 0;
+	_solved = false;
+}
+
+WidgetFoolscap::~WidgetFoolscap() {
+	delete _images;
+}
+
+void WidgetFoolscap::show() {
+	Screen &screen = *_vm->_screen;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	switch (_vm->getLanguage()) {
+	case Common::FR_FRA:
+		_lines[0] = Common::Point(34, 210);
+		_lines[1] = Common::Point(72, 242);
+		_lines[2] = Common::Point(34, 276);
+		_numWide = 8;
+		_spacing = 19;
+		_images = new ImageFile("paperf.vgs");
+		break;
+
+	case Common::DE_DEU:
+		_lines[0] = Common::Point(44, 73);
+		_lines[1] = Common::Point(56, 169);
+		_lines[2] = Common::Point(47, 256);
+		_numWide = 7;
+		_spacing = 19;
+		_images = new ImageFile("paperg.vgs");
+		break;
+
+	default:
+		// English
+		_lines[0] = Common::Point(65, 84);
+		_lines[1] = Common::Point(65, 159);
+		_lines[2] = Common::Point(75, 234);
+		_numWide = 5;
+		_spacing = 20;
+		_images = new ImageFile("paper.vgs");
+		break;
+	}
+
+	_solved = false;
+	_blinkFlag = false;
+	_blinkCounter = 0;
+	_lineNum = _charNum = 0;
+	_cursorPos = Common::Point(_lines[0].x + 8 - screen.widestChar() / 2, _lines[0].y - screen.fontHeight() - 2);
+
+	// Set up window bounds
+	ImageFrame &paperFrame = (*_images)[0];
+	_bounds = Common::Rect(paperFrame._width, paperFrame._height);
+	_bounds.moveTo(screen._currentScroll.x + (SHERLOCK_SCREEN_WIDTH - paperFrame._width) / 2,
+		(SHERLOCK_SCREEN_HEIGHT - paperFrame._height) / 2);
+
+	// Clear answer data and set correct solution strings
+	for (int idx = 0; idx < 3; ++idx)
+		Common::fill(&_answers[idx][0], &_answers[idx][10], 0);
+	_solutions[0] = FIXED(Apply);
+	_solutions[1] = FIXED(Water);
+	_solutions[2] = FIXED(Heat);
+
+	// Set up the window background
+	_surface.create(_bounds.width(), _bounds.height());
+	_surface.blitFrom(paperFrame, Common::Point(0, 0));
+
+	// If they have already solved the puzzle, put the answer on the graphic
+	if (_vm->readFlags(299)) {
+		Common::Point cursorPos;
+		for (int line = 0; line < 3; ++line) {
+			cursorPos.y = _lines[line].y - screen.fontHeight() - 2;
+
+			for (uint idx = 0; idx < strlen(_solutions[line]); ++idx) {
+				cursorPos.x = _lines[line].x + 8 - screen.widestChar() / 2 + idx * _spacing;
+				char c = _solutions[line][idx];
+
+				Common::String str = Common::String::format("%c", c);
+				_surface.writeString(str, Common::Point(cursorPos.x + screen.widestChar() / 2
+					- screen.charWidth(c) / 2, cursorPos.y), 0);
+			}
+		}
+	}
+
+	// Show the window
+	summonWindow();
+	ui._menuMode = FOOLSCAP_MODE;
+} 
+
+void WidgetFoolscap::handleEvents() {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+	byte cursorColor = 254;
+
+	if (events._firstPress && !_bounds.contains(mousePos))
+		_outsideMenu = true;
+
+	// If they have not solved the puzzle, let them solve it here
+	if (!_vm->readFlags(299)) {
+		if (!ui._keyState.keycode) {
+			if (--_blinkCounter < 0) {
+				_blinkCounter = 3;
+				_blinkFlag = !_blinkFlag;
+
+				if (_blinkFlag) {
+					// Draw the caret
+					_surface.fillRect(Common::Rect(_cursorPos.x, _cursorPos.y, _cursorPos.x + screen.widestChar() - 1,
+						_cursorPos.y + screen.fontHeight() - 1), cursorColor);
+
+					if (_answers[_lineNum][_charNum]) {
+						Common::String str = Common::String::format("%c", _answers[_lineNum][_charNum]);
+						_surface.writeString(str, Common::Point(_cursorPos.x + screen.widestChar() / 2
+							- screen.charWidth(_answers[_lineNum][_charNum]) / 2, _cursorPos.y), 0);
+					}
+				} else {
+					// Restore background
+					restoreChar();
+
+					// Draw the character at that position if there is one
+					if (_answers[_lineNum][_charNum]) {
+						Common::String str = Common::String::format("%c", _answers[_lineNum][_charNum]);
+						_surface.writeString(str, Common::Point(_cursorPos.x + screen.widestChar() / 2
+							- screen.charWidth(_answers[_lineNum][_charNum]) / 2, _cursorPos.y), 0);
+					}
+				}
+			}
+		} else {
+			// Handle keyboard events
+			handleKeyboardEvents();
+		}
+	}
+
+	if ((events._released || events._rightReleased) && _outsideMenu && !_bounds.contains(mousePos)) {
+		// Clicked outside window to close it
+		events.clearEvents();
+		close();
+	}
+}
+
+void WidgetFoolscap::handleKeyboardEvents() {
+	Screen &screen = *_vm->_screen;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::KeyState keyState = ui._keyState;
+
+	if (((toupper(keyState.ascii) >= 'A') && (toupper(keyState.ascii) <= 'Z')) ||
+		((keyState.ascii >= 128) && ((keyState.ascii <= 168) || (keyState.ascii == 225)))) {
+		// Visible key pressed, set it and set the keycode to move the caret to the right
+		_answers[_lineNum][_charNum] = keyState.ascii;
+		keyState.keycode = Common::KEYCODE_RIGHT;
+	}
+
+	// Restore background
+	restoreChar();
+
+	if (_answers[_lineNum][_charNum]) {
+		Common::String str = Common::String::format("%c", _answers[_lineNum][_charNum]);
+		_surface.writeString(str, Common::Point(_cursorPos.x + screen.widestChar() / 2
+			- screen.charWidth(_answers[_lineNum][_charNum]) / 2, _cursorPos.y), 0);
+	}
+
+	switch (keyState.keycode) {
+	case Common::KEYCODE_ESCAPE:
+		close();
+		break;
+
+	case Common::KEYCODE_UP:
+		if (_lineNum) {
+			--_lineNum;
+			if (_charNum >= (int)strlen(_solutions[_lineNum]))
+				_charNum = (int)strlen(_solutions[_lineNum]) - 1;
+		}
+		break;
+
+	case Common::KEYCODE_DOWN:
+		if (_lineNum < 2) {
+			++_lineNum;
+			if (_charNum >= (int)strlen(_solutions[_lineNum]))
+				_charNum = (int)strlen(_solutions[_lineNum]) - 1;
+		}
+		break;
+
+	case Common::KEYCODE_BACKSPACE:
+	case Common::KEYCODE_LEFT:
+		if (_charNum)
+			--_charNum;
+		else if (_lineNum) {
+			--_lineNum;
+
+			_charNum = strlen(_solutions[_lineNum]) - 1;
+		}
+
+		if (keyState.keycode == Common::KEYCODE_BACKSPACE)
+			_answers[_lineNum][_charNum] = ' ';
+		break;
+
+	case Common::KEYCODE_RIGHT:
+		if (_charNum < (int)strlen(_solutions[_lineNum]) - 1)
+			++_charNum;
+		else if (_lineNum < 2) {
+			++_lineNum;
+			_charNum = 0;
+		}
+		break;
+
+	case Common::KEYCODE_DELETE:
+		_answers[_lineNum][_charNum] = ' ';
+		break;
+
+	default:
+		break;
+	}
+
+	_cursorPos.x = _lines[_lineNum].x + 8 - screen.widestChar() / 2 + _charNum * _spacing;
+	_cursorPos.y = _lines[_lineNum].y - screen.fontHeight() - 2;
+
+	// See if all of their anwers are correct
+	if (!scumm_stricmp(_answers[0], _solutions[0]) && !scumm_stricmp(_answers[1], _solutions[1])
+			&& !scumm_stricmp(_answers[2], _solutions[2])) {
+		_solved = true;
+		close();
+	}
+}
+
+void WidgetFoolscap::restoreChar() {
+	Screen &screen = *_vm->_screen;
+	ImageFrame &bgFrame = (*_images)[0];
+	_surface.blitFrom(bgFrame, _cursorPos, Common::Rect(_cursorPos.x, _cursorPos.y,
+		_cursorPos.x + screen.widestChar(), _cursorPos.y + screen.fontHeight()));
+}
+
+void WidgetFoolscap::close() {
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Talk &talk = *_vm->_talk;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	delete _images;
+	_images = nullptr;
+
+	// Close the window
+	banishWindow();
+	ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+
+	// Don't call the talk files if the puzzle has already been solved
+	if (!_vm->readFlags(299)) {
+		// Run the appropriate script depending on whether or not they solved the puzzle correctly
+		if (_solved) {
+			talk.talkTo("SLVE12S.TLK");
+			talk.talkTo("WATS12X.TLK");
+			_vm->setFlags(299);
+		} else {
+			talk.talkTo("HOLM12X.TLK");
+		}
+	}
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_foolscap.h b/engines/sherlock/tattoo/widget_foolscap.h
new file mode 100644
index 0000000000..3c85998cee
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_foolscap.h
@@ -0,0 +1,82 @@
+/* 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 SHERLOCK_TATTOO_FOOLSCAP_H
+#define SHERLOCK_TATTOO_FOOLSCAP_H
+
+#include "sherlock/tattoo/widget_base.h"
+#include "sherlock/image_file.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+class TattooEngine;
+
+class WidgetFoolscap: public WidgetBase {
+private:
+	ImageFile *_images;
+	Common::Point _lines[3];
+	char _answers[3][10];
+	const char *_solutions[3];
+	int _numWide;
+	int _spacing;
+	Common::Point _cursorPos;
+	int _blinkCounter;
+	bool _blinkFlag;
+	int _lineNum, _charNum;
+	bool _solved;
+
+	/**
+	 * Handle keyboard events
+	 */
+	void handleKeyboardEvents();
+
+	/**
+	 * Restore the background for the current line/horiz position
+	 */
+	void restoreChar();
+public:
+	WidgetFoolscap(TattooEngine *vm);
+	virtual ~WidgetFoolscap();
+
+	/**
+	 * Show the foolscap puzzle
+	 */
+	void show();
+
+	/**
+	 * Close the window
+	 */
+	void close();
+
+	/**
+	* Handle events whilst the widget is on-screen
+	*/
+	virtual void handleEvents();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_inventory.cpp b/engines/sherlock/tattoo/widget_inventory.cpp
new file mode 100644
index 0000000000..b49e30b30d
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_inventory.cpp
@@ -0,0 +1,791 @@
+/* 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 "sherlock/tattoo/widget_inventory.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_people.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+#define INVENTORY_XSIZE 70			// Width of the box that surrounds inventory items
+#define INVENTORY_YSIZE 70			// Height of the box that surrounds inventory items
+#define MAX_INV_COMMANDS 10			// Maximum elements in dialog
+#define NUM_INV_PER_LINE 4			// Number of inentory items per line in the dialog
+
+WidgetInventoryTooltip::WidgetInventoryTooltip(SherlockEngine *vm, WidgetInventory *owner) : 
+		WidgetTooltipBase(vm), _owner(owner) {
+}
+
+void WidgetInventoryTooltip::setText(const Common::String &str) {
+	// If no text specified, erase any previously displayed tooltip and free its surface
+	if (str.empty()) {
+		erase();
+		_surface.free();
+		return;
+	}
+
+	int width = _surface.stringWidth(str) + 2;
+	int height = 0;
+	Common::String line1 = str, line2;
+
+	// See if we need to split it into two lines
+	if (width > 150) {
+		// Yes, we do
+		const char *s = str.c_str();
+		const char *space = nullptr;
+		int dif = 10000;
+
+		while (*s) {
+			s = strchr(s, ' ');
+
+			if (!s) {
+				if (!space) {
+					height = _surface.stringHeight(str) + 2;
+				} else {
+					line1 = Common::String(str.c_str(), space);
+					line2 = Common::String(space + 1);
+					height = _surface.stringHeight(line1) + _surface.stringHeight(line2) + 4;
+				}
+				break;
+			} else {
+				line1 = Common::String(str.c_str(), s);
+				line2 = Common::String(s + 1);
+				int width1 = _surface.stringWidth(line1);
+				int width2 = _surface.stringWidth(line2);
+
+				if (ABS(width1 - width2) < dif) {
+					// Found a split point that results in less overall width
+					space = s;
+					dif = ABS(width1 - width2);
+					width = MAX(width1, width2);
+				}
+
+				s++;
+			}
+		}
+	} else {
+		height = _surface.stringHeight(str) + 2;
+	}
+
+	// Allocate a fresh surface for the new string
+	_bounds = Common::Rect(width, height);
+	_surface.create(width, height);
+	_surface.fill(TRANSPARENCY);
+
+	if (line2.empty()) {
+		_surface.writeFancyString(str, Common::Point(0, 0), BLACK, INFO_TOP);
+	} else {
+		int xp, yp;
+		
+		xp = (_bounds.width() - _surface.stringWidth(line1) - 2) / 2;
+		_surface.writeFancyString(line1, Common::Point(xp, 0), BLACK, INFO_TOP);
+
+		xp = (_bounds.width() - _surface.stringWidth(line2) - 2) / 2;
+		yp = _surface.stringHeight(line2) + 2;
+		_surface.writeFancyString(line2, Common::Point(xp, yp), BLACK, INFO_TOP);
+	}
+}
+
+void WidgetInventoryTooltip::handleEvents() {	
+	Events &events = *_vm->_events;
+	FixedText &fixedText = *_vm->_fixedText;
+	Inventory &inv = *_vm->_inventory;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Scene &scene = *_vm->_scene;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+	Common::String str;
+	int select = -1, oldSelect = 999;
+	Common::String strWith = fixedText.getText(kFixedText_With);
+	Common::String strUse = fixedText.getText(kFixedText_Use);
+
+	// Register the tooltip for requiring post-rendering drawing, since we draw directly to the screen if a scene
+	// mask is active, since the initial draw to the screen will be covered by the mask rendering
+	if (ui._mask) {
+		ui._postRenderWidgets.push_back(this);
+	}
+
+	// If we are using an inventory item on an object in the room, display the appropriate text above the mouse cursor
+	if (_owner->_invVerbMode == 3) {
+		select = ui._bgFound;
+		oldSelect = ui._oldBgFound;
+	
+		if (select != -1 && (select != oldSelect || (select != -1 && _surface.empty()))) {
+			// See if we're pointing at a shape or a sprite
+			if (select < 1000) {
+				Object &obj = scene._bgShapes[select];
+
+				if (!obj._description.empty() && !obj._description.hasPrefix(" ")) {
+					if (_vm->getLanguage() == Common::GR_GRE) {
+
+						if (!_owner->_swapItems)
+							str = Common::String::format("%s %s %s %s", _owner->_action.c_str(), obj._description.c_str(), 
+								inv[_owner->_invSelect]._name.c_str(), _owner->_verb.c_str());
+						else
+							str = Common::String::format("%s %s %s %s", _owner->_action.c_str(), inv[_owner->_invSelect]._name.c_str(), 
+								obj._description.c_str(), _owner->_verb.c_str());
+					} else {
+						if (_owner->_swapItems)
+							str = Common::String::format("%s %s %s %s", _owner->_verb.c_str(), obj._description.c_str(), _owner->_action.c_str(), 
+								inv[_owner->_invSelect]._name.c_str());
+						else
+							str = Common::String::format("%s %s %s %s", _owner->_verb.c_str(), inv[_owner->_invSelect]._name.c_str(), 
+								_owner->_action.c_str(), obj._description.c_str());
+					}
+				}
+			} else {
+				Person &person = people[ui._bgFound - 1000];
+
+				if (!person._description.empty() && !person._description.hasPrefix(" ")) {
+					if (_vm->getLanguage() == Common::GR_GRE) {
+						if (!_owner->_swapItems)
+							str = Common::String::format("%s %s %s %s", _owner->_action.c_str(), person._description.c_str(),
+								inv[_owner->_invSelect]._name.c_str(), _owner->_verb.c_str());
+						else
+							str = Common::String::format("%s %s %s %s", _owner->_action.c_str(), inv[_owner->_invSelect]._name.c_str(),
+								person._description.c_str(), _owner->_verb.c_str());
+					} else {
+
+						if (_owner->_swapItems)
+							str = Common::String::format("%s %s %s %s", _owner->_verb.c_str(), person._description.c_str(),
+								_owner->_action.c_str(), inv[_owner->_invSelect]._name.c_str());
+						else
+							str = Common::String::format("%s %s %s %s", _owner->_verb.c_str(),
+								inv[_owner->_invSelect]._name.c_str(), _owner->_action.c_str(), person._description.c_str());
+					}
+				}
+			}
+		}
+	} else {
+		const Common::Rect &b = _owner->_bounds;
+		Common::Rect r(b.left + 3, b.top + 3, b.right - 3 - BUTTON_SIZE, b.bottom - 3);
+
+		if (r.contains(mousePos)) {
+			select = (mousePos.x - r.left) / (INVENTORY_XSIZE + 3) + NUM_INVENTORY_SHOWN / 2 *
+				((mousePos.y - r.top) / (INVENTORY_YSIZE + 3)) + inv._invIndex;
+
+			if (select >= inv._holdings) {
+				select = -1;
+			} else {
+				oldSelect = _owner->_invSelect;
+				
+				if (select != _owner->_invSelect || _surface.empty()) {
+
+					if (_owner->_invMode == 1) {
+						// See if we were pointing at a shapre or sprite
+						if (ui._activeObj < 1000) {
+							Object &obj = scene._bgShapes[ui._activeObj];
+
+							if (!obj._description.empty() && !obj._description.hasPrefix(" "))
+								str = Common::String::format("%s %s %s %s", strUse.c_str(), inv[select]._name.c_str(),
+									strWith.c_str(), obj._description.c_str());
+						} else {
+							Person &person = people[ui._activeObj - 1000];
+
+							if (!person._description.empty() && !person._description.hasPrefix(" "))
+								str = Common::String::format("%s %s %s %s", strUse.c_str(), inv[select]._name.c_str(),
+									strWith.c_str(), person._description.c_str());
+						}
+					} else {
+						if (_owner->_invVerbMode == 2)
+							str = Common::String::format("%s %s %s %s", strUse.c_str(), inv[_owner->_invSelect]._name.c_str(),
+								strWith.c_str(), inv[select]._name.c_str());
+						else
+							str = inv[select]._description.c_str();
+					}
+				}
+			}
+		}
+	}
+
+	// See if they are pointing at a different inventory object and we need to
+	// change the graphics of the Text Tag
+	if (select != oldSelect || (select != -1 && _surface.empty())) {
+		// Set the text
+		setText(str);
+
+		if (_owner->_invVerbMode != 3)
+			_owner->_invSelect = select;
+		else
+			ui._oldBgFound = select;
+	} else if (select == -1 && oldSelect != -1) {
+		setText(Common::String());
+		return;
+	}
+
+	if (_owner->_invVerbMode == 3)
+		// Adjust tooltip to be above the inventory item being shown above the standard cursor
+		mousePos.y -= events._hotspotPos.y;
+
+	// Update the position of the tooltip
+	int xs = CLIP(mousePos.x - _bounds.width() / 2, 0, SHERLOCK_SCENE_WIDTH - _bounds.width());
+	int ys = CLIP(mousePos.y - _bounds.height(), 0, SHERLOCK_SCREEN_HEIGHT - _bounds.height());
+	_bounds.moveTo(xs, ys);
+}
+
+/*----------------------------------------------------------------*/
+
+WidgetInventoryVerbs::WidgetInventoryVerbs(SherlockEngine *vm, WidgetInventory *owner) : 
+		WidgetBase(vm), _owner(owner) {
+	_invVerbSelect = _oldInvVerbSelect = -1;
+}
+
+void WidgetInventoryVerbs::load() {
+	Events &events = *_vm->_events;
+	Inventory &inv = *_vm->_inventory;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+
+	// Make the Verb List for this Inventory Item
+	_inventCommands.clear();
+	_inventCommands.push_back(FIXED(Look));
+
+	// Default the Action word to "with"
+	_owner->_action = _vm->getLanguage() == Common::GR_GRE ? "" : FIXED(With);
+
+	// Search all the bgshapes for any matching Target Fields
+	for (uint idx = 0; idx < scene._bgShapes.size(); ++idx) {
+		Object &obj = scene._bgShapes[idx];
+
+		if (obj._type != INVALID && obj._type != HIDDEN) {
+			for (int useNum = 0; useNum < 6; ++useNum) {
+				if (!obj._use[useNum]._verb.hasPrefix("*") &&
+					!obj._use[useNum]._target.compareToIgnoreCase(inv[_owner->_invSelect]._name)) {
+					// Make sure the Verb is not already in the list
+					bool found1 = false;
+					for (uint cmdNum = 0; cmdNum < _inventCommands.size() && !found1; ++cmdNum) {
+						if (!_inventCommands[cmdNum].compareToIgnoreCase(obj._use[useNum]._verb))
+							found1 = true;
+					}
+
+					if (!found1) {
+						_inventCommands.push_back(obj._use[useNum]._verb);
+
+						// Check for any Special Action commands
+						for (int nameNum = 0; nameNum < 4; ++nameNum) {
+							if (!scumm_strnicmp(obj._use[useNum]._names[nameNum].c_str(), "*V", 2)) {
+								if (!scumm_strnicmp(obj._use[useNum]._names[nameNum].c_str(), "*VSWAP", 6))
+									_owner->_swapItems = true;
+								else
+									_owner->_action = Common::String(obj._use[useNum]._names[nameNum].c_str() + 2);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Search the NPCs for matches as well
+	for (int idx = 1; idx < MAX_CHARACTERS; ++idx) {
+		for (int useNum = 0; useNum < 2; ++useNum) {
+			if (!people[idx]._use[useNum]._target.compareToIgnoreCase(inv[_owner->_invSelect]._name) &&
+				!people[idx]._use[useNum]._verb.empty() && !people[idx]._use[useNum]._verb.hasPrefix(" ")) {
+				bool found1 = false;
+				for (uint cmdNum = 0; cmdNum < _inventCommands.size() && !found1; ++cmdNum) {
+					if (!_inventCommands[cmdNum].compareToIgnoreCase(people[idx]._use[cmdNum]._verb))
+						found1 = true;
+				}
+
+				if (!found1)
+					_inventCommands.push_back(people[idx]._use[useNum]._verb);
+			}
+		}
+	}
+
+	// Finally see if the item itself has a verb
+	if (!inv[_owner->_invSelect]._verb._verb.empty()) {
+		// Don't add "Solve" to the Foolscap if it's already been "Solved"
+		if (inv[_owner->_invSelect]._verb._verb.compareToIgnoreCase(FIXED(Solve)) || !_vm->readFlags(299))
+			_inventCommands.push_back(inv[_owner->_invSelect]._verb._verb);
+	}
+
+	// Now find the widest command in the _inventCommands array
+	int width = 0;
+	for (uint idx = 0; idx < _inventCommands.size(); ++idx)
+		width = MAX(width, _surface.stringWidth(_inventCommands[idx]));
+
+	// Set up bounds for the menu
+	_bounds = Common::Rect(width + _surface.widestChar() * 2 + 6,
+		(_surface.fontHeight() + 7) * _inventCommands.size() + 3);
+	_bounds.moveTo(mousePos.x - _bounds.width() / 2, mousePos.y - _bounds.height() / 2);
+
+	// Create the surface
+	_surface.create(_bounds.width(), _bounds.height());
+	_surface.fill(TRANSPARENCY);
+	makeInfoArea();
+
+	// Draw the Verb commands and the lines separating them
+	ImageFile &images = *ui._interfaceImages;
+	for (int idx = 0; idx < (int)_inventCommands.size(); ++idx) {
+		_surface.writeString(_inventCommands[idx], Common::Point((_bounds.width() -
+			_surface.stringWidth(_inventCommands[idx])) / 2, (_surface.fontHeight() + 7) * idx + 5), INFO_TOP);
+
+		if (idx < (int)_inventCommands.size() - 1) {
+			_surface.vLine(3, (_surface.fontHeight() + 7) * (idx + 1), _bounds.right - 4, INFO_TOP);
+			_surface.vLine(3, (_surface.fontHeight() + 7) * (idx + 1) + 1, _bounds.right - 4, INFO_MIDDLE);
+			_surface.vLine(3, (_surface.fontHeight() + 7) * (idx + 1) + 2, _bounds.right - 4, INFO_BOTTOM);
+
+			_surface.transBlitFrom(images[4], Common::Point(0, (_surface.fontHeight() + 7) * (idx + 1)));
+			_surface.transBlitFrom(images[5], Common::Point(_bounds.width() - images[5]._width,
+				(_surface.fontHeight() + 7) * (idx + 1) - 1));
+		}
+	}
+
+	summonWindow();
+}
+
+void WidgetInventoryVerbs::handleEvents() {
+	Events &events = *_vm->_events;
+	Inventory &inv = *_vm->_inventory;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Common::Point mousePos = events.mousePos();
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	TattooEngine &vm = *(TattooEngine *)_vm;
+
+	// Handle changing highlighted verb entry
+	highlightControls();
+
+	// See if they want to close the menu (by clicking outside the menu)
+	Common::Rect innerBounds = _bounds;
+	innerBounds.grow(-3);
+
+	// Flag is they started pressing outside of the menu
+	if (events._firstPress && !_bounds.contains(mousePos))
+		_outsideMenu = true;
+
+	if (events._released || events._rightReleased || ui._keyState.keycode == Common::KEYCODE_ESCAPE) {
+		ui._scrollHighlight = SH_NONE;
+		banishWindow();
+
+		if ((_outsideMenu && !innerBounds.contains(mousePos)) || ui._keyState.keycode == Common::KEYCODE_ESCAPE) {
+			_owner->_invVerbMode = 0;
+		} else if (innerBounds.contains(mousePos)) {
+			_outsideMenu = false;
+
+			// Check if they are trying to solve the Foolscap puzzle, or looking at the completed puzzle
+			bool doFoolscap = !inv[_owner->_invSelect]._name.compareToIgnoreCase(FIXED(Inv6)) &&
+				!_inventCommands[_invVerbSelect].compareToIgnoreCase(FIXED(Solve));
+			doFoolscap |= (!inv[_owner->_invSelect]._name.compareToIgnoreCase(FIXED(Inv6)) || !inv[_owner->_invSelect]._name.compareToIgnoreCase(FIXED(Inv7)))
+				&& !_inventCommands[_invVerbSelect].compareToIgnoreCase(FIXED(Look)) && vm.readFlags(299);
+
+			if (doFoolscap) {
+				// Close the entire Inventory and return to Standard Mode
+				_owner->_invVerbMode = 0;
+
+				_owner->_tooltipWidget.banishWindow();
+				_owner->banishWindow();
+				inv.freeInv();
+
+				events.clearEvents();
+				vm.doFoolscapPuzzle();
+			} else if (_invVerbSelect == 0) {
+				// They have released the mouse on the Look Verb command, so Look at the inventory item
+				ui._invLookFlag = true;
+				inv.freeInv();
+				ui._windowOpen = false;
+				ui._lookPos = mousePos;
+				ui.printObjectDesc(inv[_owner->_invSelect]._examine, true);
+			} else {
+				_owner->_invVerbMode = 3;
+				ui._oldBgFound = -1;
+
+				// See if the selected Verb with the selected Iventory Item, is to be used by itself
+				if (!_inventCommands[_invVerbSelect].compareToIgnoreCase(inv[_owner->_invSelect]._verb._verb) ||
+					!inv[_owner->_invSelect]._verb._target.compareToIgnoreCase("*SELF")) {
+					inv.freeInv();
+
+					ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+					events.clearEvents();
+					ui.checkAction(inv[_owner->_invSelect]._verb, 2000);
+				} else {
+					_owner->_verb = _inventCommands[_invVerbSelect];
+				}
+
+				// If we are still in Inventory Mode, setup the graphic to float in front of the mouse cursor
+				if (ui._menuMode == INV_MODE) {
+					// Add the inventory item to the cursor
+					ImageFrame &imgFrame = (*inv._invShapes[_owner->_invSelect - inv._invIndex])[0];
+					events.setCursor(ARROW, Common::Point(-100, imgFrame._height), imgFrame._frame);
+
+					// Close the inventory dialog without banishing it, so it can keep getting events
+					// to handle tooltips and actually making the selection of what object to use them item on
+					inv.freeInv();
+					_owner->_surface.free();
+				}
+			}
+		}
+	}
+}
+
+void WidgetInventoryVerbs::highlightControls() {
+	Events &events = *_vm->_events;
+	Common::Point mousePos = events.mousePos();
+
+	Common::Rect innerBounds = _bounds;
+	innerBounds.grow(-3);
+
+	// Set the highlighted verb
+	_invVerbSelect = -1;
+	if (innerBounds.contains(mousePos))
+		_invVerbSelect = (mousePos.y - _bounds.top - 3) / (_surface.fontHeight() + 7);
+
+	// See if the highlighted verb has changed
+	if (_invVerbSelect != _oldInvVerbSelect) {
+		// Draw the list again, with the new highlighting
+		for (int idx = 0; idx < (int)_inventCommands.size(); ++idx) {
+			byte color = (idx == _invVerbSelect) ? COMMAND_HIGHLIGHTED : INFO_TOP;
+			_surface.writeString(_inventCommands[idx], Common::Point(
+				(_bounds.width() - _surface.stringWidth(_inventCommands[idx])) / 2,
+				(_surface.fontHeight() + 7) * idx + 5), color);
+		}
+
+		_oldInvVerbSelect = _invVerbSelect;
+	}
+}
+
+/*----------------------------------------------------------------*/
+
+WidgetInventory::WidgetInventory(SherlockEngine *vm) : WidgetBase(vm), 
+		_tooltipWidget(vm, this), _verbList(vm, this) {
+	_invMode = 0;
+	_invVerbMode = 0;
+	_invSelect = _oldInvSelect = -1;
+	_selector = _oldSelector = -1;
+	_swapItems = false;
+}
+
+void WidgetInventory::load(int mode) {
+	Events &events = *_vm->_events;
+	Inventory &inv = *_vm->_inventory;
+	Screen &screen = *_vm->_screen;
+	Common::Point mousePos = events.mousePos();
+
+	if (mode == 3) {
+		mode = 2;
+		mousePos = Common::Point(screen._currentScroll.x + SHERLOCK_SCREEN_WIDTH / 2, SHERLOCK_SCREEN_HEIGHT / 2);
+	}
+
+	if (mode != 0)
+		_invMode = mode;
+	_invVerbMode = 0;
+	_invSelect = _oldInvSelect = -1;
+	_selector = _oldSelector = -1;
+	_scroll = true;
+
+	if (mode == 0) {
+		banishWindow();
+	} else {
+		_bounds = Common::Rect((INVENTORY_XSIZE + 3) * NUM_INVENTORY_SHOWN / 2 + BUTTON_SIZE + 6,
+			(INVENTORY_YSIZE + 3) * 2 + 3);
+		_bounds.moveTo(mousePos.x - _bounds.width() / 2, mousePos.y - _bounds.height() / 2);
+	}
+
+	// Ensure menu will be on-screen
+	restrictToScreen();
+
+	// Load the inventory data
+	inv.loadInv();
+
+	// Redraw the inventory menu on the widget surface
+	_surface.create(_bounds.width(), _bounds.height());
+	_surface.fill(TRANSPARENCY);
+
+	// Draw the window background and then the inventory on top of it
+	makeInfoArea(_surface);
+	drawBars();
+	drawInventory();
+}
+
+void WidgetInventory::drawBars() {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	ImageFile &images = *ui._interfaceImages;
+	int x;
+
+	_surface.hLine(3, INVENTORY_YSIZE + 3, _bounds.width() - 4, INFO_TOP);
+	_surface.hLine(3, INVENTORY_YSIZE + 4, _bounds.width() - 4, INFO_MIDDLE);
+	_surface.hLine(3, INVENTORY_YSIZE + 5, _bounds.width() - 4, INFO_BOTTOM);
+	_surface.transBlitFrom(images[4], Common::Point(0, INVENTORY_YSIZE + 2));
+
+	for (int idx = 1; idx <= NUM_INVENTORY_SHOWN / 2; ++idx) {
+		x = idx * (INVENTORY_XSIZE + 3);
+
+		_surface.vLine(x, 3, _bounds.height() - 4, INFO_TOP);
+		_surface.vLine(x + 1, 3, _bounds.height() - 4, INFO_MIDDLE);
+		_surface.vLine(x + 2, 3, _bounds.height() - 4, INFO_BOTTOM);
+
+		_surface.transBlitFrom(images[6], Common::Point(x - 1, 1));
+		_surface.transBlitFrom(images[7], Common::Point(x - 1, _bounds.height() - 4));
+		_surface.transBlitFrom(images[6], Common::Point(x - 1, INVENTORY_YSIZE + 5));
+		_surface.transBlitFrom(images[7], Common::Point(x - 1, INVENTORY_YSIZE + 2));
+	}
+
+	_surface.hLine(x + 2, INVENTORY_YSIZE + 2, INVENTORY_YSIZE + 8, INFO_BOTTOM);
+}
+
+void WidgetInventory::drawInventory() {
+	Inventory &inv = *_vm->_inventory;
+
+	// TODO: Refactor _invIndex into this widget class
+	for (int idx = 0, itemId = inv._invIndex; idx < NUM_INVENTORY_SHOWN; ++idx, ++itemId) {
+		// Figure out the drawing position
+		Common::Point pt(3 + (INVENTORY_XSIZE + 3) * (idx % (NUM_INVENTORY_SHOWN / 2)),
+			3 + (INVENTORY_YSIZE + 3) * (idx / (NUM_INVENTORY_SHOWN / 2)));
+
+		// Draw the box to serve as the background for the item
+		_surface.hLine(pt.x + 1, pt.y, pt.x + INVENTORY_XSIZE - 2, TRANSPARENCY);
+		_surface.fillRect(Common::Rect(pt.x, pt.y + 1, pt.x + INVENTORY_XSIZE, pt.y + INVENTORY_YSIZE - 1), TRANSPARENCY);
+		_surface.hLine(pt.x + 1, pt.y + INVENTORY_YSIZE - 1, pt.x + INVENTORY_XSIZE - 2, TRANSPARENCY);
+
+		// Draw the item
+		if (itemId < inv._holdings) {
+			ImageFrame &img = (*inv._invShapes[idx])[0];
+			_surface.transBlitFrom(img, Common::Point(pt.x + (INVENTORY_XSIZE - img._width) / 2,
+				pt.y + (INVENTORY_YSIZE - img._height) / 2));
+		}
+	}
+
+	drawScrollBar(inv._invIndex / NUM_INV_PER_LINE, NUM_INVENTORY_SHOWN / NUM_INV_PER_LINE, 
+		(inv._holdings + NUM_INV_PER_LINE - 1) / NUM_INV_PER_LINE);
+}
+
+void WidgetInventory::handleEvents() {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Events &events = *_vm->_events;
+	Inventory &inv = *_vm->_inventory;
+	People &people = *_vm->_people;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+
+	if (_invVerbMode == 1) {
+		checkTabbingKeys(MAX_INV_COMMANDS);
+	} else if (_invVerbMode == 0) {
+		checkInvTabbingKeys();
+
+		// Handle scrollbar events
+		int oldScrollIndex = inv._invIndex / NUM_INV_PER_LINE;
+		int invIndex = inv._invIndex / NUM_INV_PER_LINE;
+
+		ScrollHighlight oldHighlight = ui._scrollHighlight;
+		handleScrollbarEvents(invIndex, NUM_INVENTORY_SHOWN / NUM_INV_PER_LINE, 
+			(inv._holdings + NUM_INV_PER_LINE - 1) / NUM_INV_PER_LINE);
+
+		handleScrolling(invIndex, NUM_INVENTORY_SHOWN / NUM_INV_PER_LINE, 
+			(inv._holdings + NUM_INV_PER_LINE - 1) / NUM_INV_PER_LINE);
+
+		if (oldScrollIndex != invIndex) {
+			// Starting visible item index has changed, so set the index and reload inventory graphics
+			inv._invIndex = invIndex * NUM_INV_PER_LINE;
+			inv.freeGraphics();
+			inv.loadGraphics();
+		}
+
+		if (ui._scrollHighlight != oldHighlight || oldScrollIndex != invIndex) {
+			drawInventory();
+			return;
+		}
+	}
+
+	if (_invVerbMode != 1)
+		_tooltipWidget.handleEvents();
+
+	// Flag is they started pressing outside of the menu
+	if (events._firstPress && !_bounds.contains(mousePos))
+		_outsideMenu = true;
+
+	if (_invVerbMode != 3)
+		highlightControls();
+
+	// See if they released a mouse button button
+	if (events._released || events._rightReleased || ui._keyState.keycode == Common::KEYCODE_ESCAPE) {
+		ui._scrollHighlight = SH_NONE;
+
+		// See if they have a Verb List open for an Inventry Item
+		if (_invVerbMode == 1)
+			return;
+
+		if (_invVerbMode == 3) {
+			// Selecting object after inventory verb has been selected
+			_tooltipWidget.banishWindow();
+			close();
+
+			if (ui._keyState.keycode != Common::KEYCODE_ESCAPE) {
+				// If user pointed at an item, use the selected inventory item with this item
+				bool found = false;
+				if (ui._bgFound != -1) {
+					if (ui._personFound) {
+						Person &person = people[ui._bgFound - 1000];
+
+						for (int idx = 0; idx < 2; ++idx) {
+							if (!person._use[idx]._verb.compareToIgnoreCase(_verb) &&
+								!person._use[idx]._target.compareToIgnoreCase(_invTarget)) {
+								ui.checkAction(person._use[idx], ui._bgFound);
+								found = true;
+							}
+						}
+					} else {
+						for (int idx = 0; idx < 6; ++idx) {
+							if (!ui._bgShape->_use[idx]._verb.compareToIgnoreCase(_verb) &&
+									!ui._bgShape->_use[idx]._target.compareToIgnoreCase(_invTarget)) {
+								ui.checkAction(ui._bgShape->_use[idx], ui._bgFound);
+								found = true;
+							}
+						}
+					}
+				}
+
+				if (!found)
+					ui.putMessage("%s", FIXED(NoEffect));
+			}
+		} else if ((_outsideMenu && !_bounds.contains(mousePos)) || ui._keyState.keycode == Common::KEYCODE_ESCAPE) {
+			// Want to close the window (clicked outside of it). So close the window and return to Standard 
+			close();
+
+		} else if (_bounds.contains(mousePos)) {
+			// Mouse button was released inside the inventory window
+			_outsideMenu = false;
+		
+			//  See if they are pointing at one of the inventory items
+			if (_invSelect != -1) {
+				// See if they are in Use Obj with Inv. Mode (they right clicked on an item 
+				// in the room and selected "Use with Inv.")
+				if (_invMode == 1) {
+					_tooltipWidget.banishWindow();
+					banishWindow();
+
+					// See if the item in the room that they started with was a person
+					bool found = false;
+					if (ui._activeObj >= 1000) {
+						// Object was a person, activate anything in his two verb fields
+						for (int idx = 0; idx < 2; ++idx) {
+							if (!people[ui._activeObj - 1000]._use[idx]._target.compareToIgnoreCase(inv[_invSelect]._name)) {
+								ui.checkAction(people[ui._activeObj - 1000]._use[idx], ui._activeObj);
+								found = true;
+							}
+						}
+					} else {
+						// Object was a regular object, activate anything in its verb fields
+						for (int idx = 0; idx < 6; ++idx) {
+							if (!scene._bgShapes[ui._activeObj]._use[idx]._target.compareToIgnoreCase(inv[_invSelect]._name)) {
+								ui.checkAction(scene._bgShapes[ui._activeObj]._use[idx], ui._activeObj);
+								found = true;
+							}
+						}
+					}
+					if (!found)
+						ui.putMessage("%s", FIXED(NoEffect));
+
+				} else {
+					// See if they right clicked on an item
+					if (events._rightReleased) {
+						_invVerbMode = 1;
+						_verbList._oldInvVerbSelect = -1;
+						_tooltipWidget.banishWindow();
+
+						// Keep track of the name of the inventory object so we can check it against the target fields 
+						// of verbs when we activate it
+						_invTarget = inv[_invSelect]._name;
+						_swapItems = false;
+
+						_verbList.load();
+					} else {		
+						// They left clicked on an inventory item, so Look at it
+
+						// Check if they are looking at the solved Foolscap
+						if ((!inv[_invSelect]._name.compareToIgnoreCase(FIXED(Inv6)) || !inv[_invSelect]._name.compareToIgnoreCase(FIXED(Inv7)))
+								&& vm.readFlags(299)) {
+							banishWindow();
+							_tooltipWidget.erase();
+
+							_invVerbMode = 0;
+							inv.freeInv();
+							
+							events.clearEvents();
+							events.setCursor(ARROW);
+							ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+
+							scene.doBgAnim();
+							vm.doFoolscapPuzzle();
+						} else {
+							ui._invLookFlag = true;
+							inv.freeInv();
+
+							_tooltipWidget.banishWindow();
+							ui._windowOpen = false;
+							ui._lookPos = mousePos;
+							ui.printObjectDesc(inv[_invSelect]._examine, true);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void WidgetInventory::checkInvTabbingKeys() {
+}
+
+void WidgetInventory::highlightControls() {
+	// TODO
+}
+
+void WidgetInventory::banishWindow() {
+	WidgetBase::banishWindow();
+
+	_verbList.banishWindow();
+}
+
+void WidgetInventory::draw() {
+	WidgetBase::draw();
+	_tooltipWidget.draw();
+}
+
+void WidgetInventory::erase() {
+	WidgetBase::erase();
+	_tooltipWidget.erase();
+}
+
+void WidgetInventory::close() {
+	Events &events = *_vm->_events;
+	Inventory &inv = *_vm->_inventory;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	banishWindow();
+	inv.freeInv();
+	events.clearEvents();
+
+	events.setCursor(ARROW);
+	ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_inventory.h b/engines/sherlock/tattoo/widget_inventory.h
new file mode 100644
index 0000000000..a051c328e9
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_inventory.h
@@ -0,0 +1,158 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_TATTOO_WIDGET_INVENTORY_H
+#define SHERLOCK_TATTOO_WIDGET_INVENTORY_H
+
+#include "common/scummsys.h"
+#include "sherlock/tattoo/widget_base.h"
+#include "sherlock/tattoo/widget_tooltip.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+#define NUM_INVENTORY_SHOWN 8		// Number of Inventory Items Shown
+
+class WidgetInventory;
+
+class WidgetInventoryTooltip: public WidgetTooltipBase {
+private:
+	WidgetInventory *_owner;
+protected:
+	/**
+	* Overriden from base class, since tooltips have a completely transparent background
+	*/
+	virtual void drawBackground() {}
+public:
+	WidgetInventoryTooltip(SherlockEngine *vm, WidgetInventory *owner);
+	virtual ~WidgetInventoryTooltip() {}
+
+	/**
+	 * Set the text for the tooltip
+	 */
+	void setText(const Common::String &str);
+
+	/**
+	 * Handle updating the tooltip state
+	 */
+	virtual void handleEvents();
+};
+
+class WidgetInventoryVerbs : public WidgetBase {
+private:
+	WidgetInventory *_owner;
+	Common::StringArray _inventCommands;
+
+	void highlightControls();
+public:
+	int _invVerbSelect, _oldInvVerbSelect;
+public:
+	WidgetInventoryVerbs(SherlockEngine *vm, WidgetInventory *owner);
+	virtual ~WidgetInventoryVerbs() {}
+
+	void load();
+
+	/**
+	 * Handle updating the tooltip state
+	 */
+	virtual void handleEvents();
+};
+
+class WidgetInventory: public WidgetBase {
+	friend class WidgetInventoryTooltip;
+	friend class WidgetInventoryVerbs;
+private:
+	int _invVerbMode;
+	int _selector, _oldSelector;
+	int _invSelect, _oldInvSelect;
+	WidgetInventoryTooltip _tooltipWidget;
+	WidgetInventoryVerbs _verbList;
+	bool _swapItems;
+	Surface _menuSurface;
+	Common::String _invTarget;
+
+	/**
+	 * Draw the bars within the dialog
+	 */
+	void drawBars();
+
+	/**
+	 * Check for keys to mouse the mouse within the inventory dialog
+	 */
+	void checkInvTabbingKeys();
+
+	/**
+	 * Highlights the controls
+	 */
+	void highlightControls();
+public:
+	int _invMode;
+	Common::String _action;
+	Common::String _verb;
+public:
+	WidgetInventory(SherlockEngine *vm);
+	virtual ~WidgetInventory() {}
+
+	/**
+	 * Load the inventory window
+	 */
+	void load(int mode);
+
+	/**
+	 * Draw the inventory on the surface
+	 */
+	void drawInventory();
+
+	/**
+	 * Close the window
+	 */
+	void close();
+
+	/**
+	 * Handle events whilst the widget is on-screen
+	 */
+	virtual void handleEvents();
+
+	/**
+	 * Close a currently active menu
+	 */
+	virtual void banishWindow();
+
+	/**
+	 * Erase any previous display of the widget on the screen
+	 */
+	virtual void erase();
+
+	/**
+	 * Update the display of the widget on the screen
+	 */
+	virtual void draw();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_lab.cpp b/engines/sherlock/tattoo/widget_lab.cpp
new file mode 100644
index 0000000000..eb32e2e22c
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_lab.cpp
@@ -0,0 +1,198 @@
+/* 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 "sherlock/tattoo/widget_lab.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+WidgetLab::WidgetLab(SherlockEngine *vm) : WidgetBase(vm) {
+	_labObject = nullptr;
+}
+
+void WidgetLab::summonWindow() {
+	WidgetBase::summonWindow();
+	_labObject = nullptr;
+}
+
+void WidgetLab::handleEvents() {
+	Events &events = *_vm->_events;
+	Scene &scene = *_vm->_scene;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+
+	WidgetBase::handleEvents();
+
+	// Handle drawing tooltips. If the user is dragging a lab item, display a tooltip for using the item
+	// on another. Otherwise, fall back on showing standard tooltips
+	if (events.getCursor() == INVALID_CURSOR)
+		displayLabNames();
+	else
+		ui.displayObjectNames();
+
+	// See if they've released a mouse button to do an action
+	if (events._released || events._rightReleased) {
+		// See if the mouse was released in an exit/arrow zone (ie. the "Exit" button)
+		ui._exitZone = -1;
+		if (ui._arrowZone != -1 && events._released)
+			ui._exitZone = ui._arrowZone;
+
+		// Turn any current tooltip off
+		if (ui._arrowZone == -1 || events._rightReleased)
+			ui._tooltipWidget.setText("");
+
+		bool noDesc = false;
+		if (ui._bgFound != -1) {
+			if (ui._bgShape->_description.hasPrefix(" ") || ui._bgShape->_description.empty())
+				noDesc = true;
+		} else {
+			noDesc = true;
+		}
+
+		events.setCursor(ARROW);
+
+		if (events._rightReleased) {
+			// If the player is dragging an object around, restore it to its previous location and reset the cursor
+			if (_labObject) {
+				_labObject->toggleHidden();
+
+				// Toggle any other objects (like shadows) tied to this object
+				for (int idx = 0; idx < 6; ++idx) {
+					if (!_labObject->_use[idx]._target.compareToIgnoreCase("Toggle")) {
+						for (int nameNum = 0; nameNum < 4; ++nameNum)
+							scene.toggleObject(_labObject->_use[idx]._names[nameNum]);
+					}
+				}
+
+				events.setCursor(ARROW);
+			}
+
+			// Show the command list for this object
+			ui._verbsWidget.load(!noDesc);
+		} else if (!noDesc) {
+			// The player has released on an object, see if they had an object selected 
+			// that will be used with this new object
+			if (_labObject) {
+				// See if the dragged object can be used with the new object
+				for (int idx = 0; idx < 6; ++idx) {
+					// See if the name of the dragged object is in any of the Target
+					// fields of the verbs for the new object
+					if (!_labObject->_name.compareToIgnoreCase(ui._bgShape->_use[idx]._target.c_str())) {
+						// This object can be used, so use it
+						ui.checkAction(ui._bgShape->_use[idx], ui._bgFound);
+						ui._activeObj = -1;
+					}
+				}
+
+				// Restore the dragged object to its previous location
+				_labObject->toggleHidden();
+
+				// Toggle any other objects (like shadows) tied to this object
+				for (int idx = 0; idx < 6; ++idx) {
+					if (!_labObject->_use[idx]._target.compareToIgnoreCase("Toggle")) {
+						for (int nameNum = 0; nameNum < 4; ++nameNum)
+							scene.toggleObject(_labObject->_use[idx]._names[nameNum]);
+					}
+				}
+			} else if (!ui._bgShape->_name.compareToIgnoreCase("Exit")) {
+				// Execute the Exit button's script, which will leave the scene
+				ui.lookAtObject();
+			}
+		} else {
+			// The player has released the mouse while NOT over an object. If theu were dragging an object
+			// around with the mouse, restore it to its previous location and reset the cursor
+			if (_labObject) {
+				_labObject->toggleHidden();
+
+				// Toggle any other objects (like shadows) tied to this object
+				for (int idx = 0; idx < 6; ++idx) {
+					if (!_labObject->_use[idx]._target.compareToIgnoreCase("Toggle")) {
+						for (int nameNum = 0; nameNum < 4; ++nameNum)
+							scene.toggleObject(_labObject->_use[idx]._names[nameNum]);
+					}
+				}
+			}
+		}
+
+		_labObject = nullptr;
+		ui._tooltipWidget._offsetY = 0;
+	} else if (events._pressed && !_labObject) {
+		// If the mouse is over an object and the object is not SOLID, then we need to pick this object
+		// up so the player can move it around
+		if (ui._bgFound != -1) {
+			// Check if the object is set as SOLID, you can't pick up Solid items
+			if (ui._bgShape->_aType != SOLID && ui._bgShape->_type != NO_SHAPE) {
+				// Save a reference to the object about to be dragged
+				_labObject = ui._bgShape;
+
+				// Set the mouse cursor to the object
+				Graphics::Surface &img = _labObject->_imageFrame->_frame;
+				Common::Point cursorOffset = mousePos - _labObject->_position;					
+				events.setCursor(ARROW, cursorOffset, img);
+				ui._tooltipWidget._offsetY = cursorOffset.y;
+
+				// Hide this object until they are done with it (releasing it)
+				_labObject->toggleHidden();
+
+				// Toggle any other objects (like shadows) tied to this object
+				for (int idx = 0; idx < 6; ++idx) {
+					if (!_labObject->_use[idx]._target.compareToIgnoreCase("Toggle")) {
+						for (int nameNum = 0; nameNum < 4; ++nameNum)
+							scene.toggleObject(_labObject->_use[idx]._names[nameNum]);
+					}
+				}
+			}
+		}
+	}
+}
+
+void WidgetLab::displayLabNames() {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+
+	// See if thay are pointing at a different object and we need to change the tooltip
+	if (ui._bgFound != ui._oldBgFound) {
+		// See if there is a new object to be displayed
+		if (ui._bgFound == -1) {
+			ui._tooltipWidget.setText("");
+		} else {
+			Common::String str = Common::String::format("%s %s %s %s", FIXED(Use), _labObject->_description.c_str(),
+				FIXED(With), ui._bgShape->_description.c_str());
+
+			// Make sure that the Object has a name
+			if (!ui._bgShape->_description.empty() && !ui._bgShape->_description.hasPrefix(" ")) {
+				ui._tooltipWidget.setText(str);
+			} else {
+				ui._tooltipWidget.setText("");
+			}
+		}
+	}
+
+	ui._oldArrowZone = ui._arrowZone;
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_lab.h b/engines/sherlock/tattoo/widget_lab.h
new file mode 100644
index 0000000000..2f19200b81
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_lab.h
@@ -0,0 +1,66 @@
+/* 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 SHERLOCK_TATTOO_WIDGET_LAB_H
+#define SHERLOCK_TATTOO_WIDGET_LAB_H
+
+#include "common/scummsys.h"
+#include "sherlock/tattoo/widget_base.h"
+#include "sherlock/objects.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+class WidgetLab: public WidgetBase {
+private:
+	Object *_labObject;
+
+	/**
+	 * Display tooltips of an object being dragged along with any object the dragged
+	 * object is currently over
+	 */
+	void displayLabNames();
+public:
+	Common::String _remainingText;
+public:
+	WidgetLab(SherlockEngine *vm);
+	virtual ~WidgetLab() {}
+
+	/**
+	 * Summon the window
+	 */
+	virtual void summonWindow();
+
+	/**
+	 * Handle event processing
+	 */
+	virtual void handleEvents();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_options.cpp b/engines/sherlock/tattoo/widget_options.cpp
new file mode 100644
index 0000000000..5dc6fc55b9
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_options.cpp
@@ -0,0 +1,388 @@
+/* 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 "sherlock/tattoo/widget_options.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+WidgetOptions::WidgetOptions(SherlockEngine *vm) : WidgetBase(vm) {
+	_midiSliderX = _digiSliderX = 0;
+	_selector = _oldSelector = -1;
+}
+
+void WidgetOptions::load() {
+	Events &events = *_vm->_events;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	_centerPos = events.mousePos();
+
+	render();
+
+	summonWindow();
+	ui._menuMode = OPTION_MODE;
+}
+
+void WidgetOptions::handleEvents() {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Events &events = *_vm->_events;
+	Music &music = *_vm->_music;
+	Screen &screen = *_vm->_screen;
+	Sound &sound = *_vm->_sound;
+	Talk &talk = *_vm->_talk;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+
+	if (talk._talkToAbort) {
+		sound.stopSound();
+		return;
+	}
+
+	// Flag if they started pressing outside the window
+	if (events._firstPress && !_bounds.contains(mousePos))
+		_outsideMenu = true;
+
+	if (events.kbHit()) {
+		ui._keyState = events.getKey();
+
+		// Emulate a mouse release if Enter or Space Bar is pressed
+		if (ui._keyState.keycode == Common::KEYCODE_RETURN || ui._keyState.keycode == Common::KEYCODE_SPACE) {
+			events._pressed  = events._oldButtons = false;
+			events._released = true;
+		} else if (ui._keyState.keycode == Common::KEYCODE_ESCAPE) {
+			close();
+			return;
+		} else {
+			checkTabbingKeys(11);
+		}
+	}
+
+	// Check highlighting the various controls
+	if (_bounds.contains(mousePos)) {
+		_selector = (mousePos.y - _bounds.top) / (_surface.fontHeight() + 7);
+
+		// If one of the sliders has been selected, & the mouse is not pressed, reset the selector to -1
+		if ((_selector == 3 || _selector == 6) && !events._pressed)
+			_selector = -1;
+	} else {
+		_selector = -1;
+		if (_outsideMenu && (events._released || events._rightReleased)) {
+			events.clearEvents();
+			close();
+			return;
+		}
+	}
+
+	// If the selected control has changed, redraw the dialog contents
+	if (_selector != _oldSelector)
+		render(OP_CONTENTS);
+	_oldSelector = _selector;
+
+	// Adjust the Volume Sliders (if neccessary) here
+	switch (_selector) {
+	case 3: {
+		// Set Music Volume
+		_midiSliderX = mousePos.x - _bounds.left;
+		if (_midiSliderX < _surface.widestChar())
+			_midiSliderX = _surface.widestChar();
+		else
+			if (_midiSliderX > _bounds.width() - _surface.widestChar())
+				_midiSliderX = _bounds.width() - _surface.widestChar();
+
+		int newVolume = (_midiSliderX - _surface.widestChar()) * 255 / (_bounds.width() - _surface.widestChar() * 2);
+		if (newVolume != music._musicVolume) {
+			music.setMusicVolume(newVolume);
+			vm.saveConfig();
+		}
+
+		render(OP_NAMES);
+		break;
+	}
+
+	case 6: {
+		// Set Digitized Volume
+		_digiSliderX = mousePos.x - _bounds.left;
+		if (_digiSliderX < _surface.widestChar())
+			_digiSliderX = _surface.widestChar();
+		else if (_digiSliderX > _bounds.width() - _surface.widestChar())
+			_digiSliderX = _bounds.width() - _surface.widestChar();
+
+		int temp = sound._soundVolume;
+		sound._soundVolume = (_digiSliderX - _surface.widestChar()) * 255 / (_bounds.width() - _surface.widestChar() * 2);
+		if (sound._soundVolume != temp) {
+			sound.setVolume(sound._soundVolume);
+			vm.saveConfig();
+		}
+
+		render(OP_NAMES);
+		break;
+	}
+
+	default:
+		break;
+	}
+
+	// Option selected
+	if (events._released || events._rightReleased) {
+		events.clearEvents();
+		_outsideMenu = false;
+		int temp = _selector;
+		_selector = -1;
+
+		switch (temp) {
+		case 0:
+			// Load Game
+			close();
+			ui.loadGame();
+			break;
+
+		case 1:
+			// Save Game
+			close();
+			ui.saveGame();
+			break;
+
+		case 2:
+			// Toggle Music
+			music._musicOn = !music._musicOn;
+			if (!music._musicOn)
+				music.stopMusic();
+			else
+				music.startSong();
+
+			render(OP_NAMES);
+			vm.saveConfig();
+			break;
+
+		case 4:
+			// Toggle Sound Effects
+			sound.stopSound();
+			sound._digitized = !sound._digitized;
+
+			render(OP_NAMES);
+			vm.saveConfig();
+			break;
+
+		case 5:
+			// Toggle Voices
+			sound._voices = !sound._voices;
+
+			render(OP_NAMES);
+			vm.saveConfig();
+			break;
+			
+		case 7:
+			// Toggle Text Windows
+			vm._textWindowsOn = !vm._textWindowsOn;
+
+			render(OP_NAMES);
+			vm.saveConfig();
+			break;
+
+		case 8: {
+			// New Font Style
+			int fontNumber = screen.fontNumber() + 1;
+			if (fontNumber == 7)
+				fontNumber = 0;
+			screen.setFont(fontNumber);
+
+			render(OP_ALL);
+			vm.saveConfig();
+			break;
+		}
+
+		case 9:
+			// Toggle Transparent Menus
+			vm._transparentMenus = !vm._transparentMenus;
+
+			render(OP_NAMES);
+			vm.saveConfig();
+			break;
+
+		case 10:
+			// Quit
+			banishWindow();
+			ui.doQuitMenu();
+			break;
+
+		default:
+			break;
+		}
+		
+		_oldSelector = -1;
+	}
+}
+
+void WidgetOptions::render(OptionRenderMode mode) {
+	TattooEngine &vm = *(TattooEngine *)_vm;
+	Music &music = *_vm->_music;
+	Sound &sound = *_vm->_sound;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	ImageFile &images = *ui._interfaceImages;
+	const char *const OFF_ON[2] = { FIXED(Off), FIXED(On) };
+
+	// Draw the border if necessary
+	if (mode == OP_ALL) {
+		// Set bounds for the dialog
+		Common::String widestString = Common::String::format("%s %s", FIXED(TransparentMenus), FIXED(Off));
+		_bounds = Common::Rect(_surface.stringWidth(widestString) + _surface.widestChar() * 2 + 6,
+			(_surface.fontHeight() + 7) * 11 + 3);
+		_bounds.moveTo(_centerPos.x - _bounds.width() / 2, _centerPos.y - _bounds.height() / 2);
+
+		// Get slider positions
+		_midiSliderX = music._musicVolume * (_bounds.width() - _surface.widestChar() * 2) / 255 + _surface.widestChar();
+		_digiSliderX = sound._soundVolume * (_bounds.width() - _surface.widestChar() * 2) / 255 + _surface.widestChar();
+
+		// Setup the dialog
+		_surface.create(_bounds.width(), _bounds.height());
+		_surface.fill(TRANSPARENCY);
+		makeInfoArea();
+
+		// Draw the lines separating options in the dialog
+		int yp = _surface.fontHeight() + 7;
+		for (int idx = 0; idx < 7; ++idx) {
+			_surface.transBlitFrom(images[4], Common::Point(0, yp - 1));
+			_surface.transBlitFrom(images[5], Common::Point(_surface.w() - images[5]._width, yp - 1));
+			_surface.hLine(3, yp, _surface.w() - 4, INFO_TOP);
+			_surface.hLine(3, yp + 1, _surface.w() - 4, INFO_MIDDLE);
+			_surface.hLine(3, yp + 2, _surface.w() - 4, INFO_BOTTOM);
+
+			yp += _surface.fontHeight() + 7;
+			if (idx == 1)
+				yp += _surface.fontHeight() + 7;
+			else if (idx == 2)
+				yp += (_surface.fontHeight() + 7) * 2;
+		}
+	}
+
+	// Now go through and display all the items that can be highlighted
+	for (int idx = 0, yp = 5; idx < 11; ++idx, yp += _surface.fontHeight() + 7) {
+		if (mode == OP_ALL || idx == _selector || idx == _oldSelector) {
+			if (mode == OP_NAMES)
+				_surface.fillRect(Common::Rect(4, yp, _surface.w() - 5, yp + _surface.fontHeight() - 1), TRANSPARENCY);
+			byte color = (idx == _selector) ? COMMAND_HIGHLIGHTED : INFO_TOP;
+			Common::String str;
+
+			switch (idx) {
+			case 0:
+				str = FIXED(LoadGame);
+				break;
+
+			case 1:
+				str = FIXED(SaveGame);
+				break;
+
+			case 2:
+				str = Common::String::format("%s %s", FIXED(Music), OFF_ON[music._musicOn]);
+				break;
+
+			case 3: {
+				int num = (_surface.fontHeight() + 4) & 0xfe;
+				int sliderY = yp + num / 2 - 8;
+
+				_surface.fillRect(Common::Rect(4, sliderY - (num - 6) / 2, _surface.w() - 5, 
+					sliderY - (num - 6) / 2 + num - 1), TRANSPARENCY);
+				_surface.fillRect(Common::Rect(_surface.widestChar(), sliderY + 2, 
+					_surface.w() - _surface.widestChar() - 1, sliderY + 3), INFO_MIDDLE);
+				drawDialogRect(Common::Rect(_surface.widestChar(), sliderY, _surface.w() - _surface.widestChar(), sliderY + 6));
+				
+				_surface.fillRect(Common::Rect(_midiSliderX - 1, sliderY - (num - 6) / 2 + 2, 
+					_midiSliderX + 1, sliderY - (num - 6) / 2 + num - 3), INFO_MIDDLE);
+				drawDialogRect(Common::Rect(_midiSliderX - 3, sliderY - (num - 6) / 2, 
+					_midiSliderX + 4, sliderY - (num - 6) / 2 + num));
+	
+				if (_midiSliderX - 4 > _surface.widestChar())
+					_surface.fillRect(Common::Rect(_midiSliderX - 4, sliderY, _midiSliderX - 4, sliderY + 4), INFO_BOTTOM);
+				if (_midiSliderX + 4 < _surface.w() - _surface.widestChar())
+					_surface.fillRect(Common::Rect(_midiSliderX + 4, sliderY, _midiSliderX + 4, sliderY + 4), INFO_BOTTOM);
+				break;
+			}
+
+			case 4:
+				str = Common::String::format("%s %s", FIXED(SoundEffects), OFF_ON[sound._digitized]);
+				break;
+
+			case 5:
+				str = Common::String::format("%s %s", FIXED(Voices), OFF_ON[sound._voices]);
+				break;
+
+			case 6: {
+				int num = (_surface.fontHeight() + 4) & 0xfe;
+				int sliderY = yp + num / 2 - 8;
+
+				_surface.fillRect(Common::Rect(4, sliderY - (num - 6) / 2, _surface.w() - 5, 
+					sliderY - (num - 6) / 2 + num - 1), TRANSPARENCY);
+				_surface.fillRect(Common::Rect(_surface.widestChar(), sliderY + 2, _surface.w() - _surface.widestChar() - 1, 
+					sliderY + 3), INFO_MIDDLE);
+				drawDialogRect(Common::Rect(_surface.widestChar(), sliderY, _surface.w() - _surface.widestChar(), sliderY + 6));
+				_surface.fillRect(Common::Rect(_digiSliderX - 1, sliderY - (num - 6) / 2 + 2, _digiSliderX + 1, 
+					sliderY - (num - 6) / 2 + num - 3), INFO_MIDDLE);
+				drawDialogRect(Common::Rect(_digiSliderX - 3, sliderY - (num - 6) / 2, _digiSliderX + 4, 
+					sliderY - (num - 6) / 2 + num));
+				if (_digiSliderX - 4 > _surface.widestChar())
+					_surface.fillRect(Common::Rect(_digiSliderX - 4, sliderY, _digiSliderX - 4, sliderY + 4), INFO_BOTTOM);
+				if (_digiSliderX + 4 < _surface.w() - _surface.widestChar())
+					_surface.fillRect(Common::Rect(_digiSliderX + 4, sliderY, _digiSliderX + 4, sliderY + 4), INFO_BOTTOM);
+				break;
+			}
+
+			case 7:
+				if (!sound._voices) {
+					color = INFO_BOTTOM;
+					str = Common::String::format("%s %s", FIXED(TextWindows), FIXED(On));
+				} else {
+					str = Common::String::format("%s %s", FIXED(TextWindows), OFF_ON[vm._textWindowsOn]);
+				}
+				break;
+
+			case 8:
+				str = FIXED(ChangeFont);
+				break;
+
+			case 9:
+				str = Common::String::format("%s %s", FIXED(TransparentMenus), OFF_ON[vm._transparentMenus]);
+				break;
+
+			case 10:
+				str = FIXED(Quit);
+				break;
+
+			default:
+				break;
+			}
+
+			// Unless we're doing one of the Slider Controls, print the text for the line
+			if (idx != 3 && idx != 6) {
+				int xp = (_surface.w() - _surface.stringWidth(str)) / 2;
+				_surface.writeString(str, Common::Point(xp, yp), color);
+			}
+		}
+	}
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_options.h b/engines/sherlock/tattoo/widget_options.h
new file mode 100644
index 0000000000..9be0105ab4
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_options.h
@@ -0,0 +1,69 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_TATTOO_WIDGET_OPTIONS_H
+#define SHERLOCK_TATTOO_WIDGET_OPTIONS_H
+
+#include "common/scummsys.h"
+#include "sherlock/tattoo/widget_base.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+enum OptionRenderMode { OP_ALL = 0, OP_CONTENTS = 1, OP_NAMES = 2};
+
+/**
+ * Handles displaying the options dialog
+ */
+class WidgetOptions : public WidgetBase {
+private:
+	int _midiSliderX, _digiSliderX;
+	int _selector, _oldSelector;
+	Common::Point _centerPos;
+
+	/**
+	 * Render the contents of the dialog onto the widget's surface
+	 */
+	void render(OptionRenderMode mode = OP_ALL);
+public:
+	WidgetOptions(SherlockEngine *vm);
+	virtual ~WidgetOptions() {}
+
+	/**
+	 * Load and then display the options dialog
+	 */
+	void load();
+
+	/**
+	 * Handle event processing
+	 */
+	virtual void handleEvents();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_password.cpp b/engines/sherlock/tattoo/widget_password.cpp
new file mode 100644
index 0000000000..3dd0e308ff
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_password.cpp
@@ -0,0 +1,210 @@
+/* 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 "sherlock/tattoo/widget_password.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+WidgetPassword::WidgetPassword(SherlockEngine *vm) : WidgetBase(vm) {
+	_blinkFlag = false;
+	_blinkCounter = 0;
+	_index = 0;
+	_cursorColor = 192;
+	_insert = true;
+}
+
+void WidgetPassword::show() {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	ImageFile &images = *ui._interfaceImages;
+
+	// Set the up window to be centered on the screen
+	_bounds = Common::Rect(_surface.widestChar() * 20 + 6, (_surface.fontHeight() + 7) * 2 + 3);
+	_bounds.moveTo(SHERLOCK_SCREEN_WIDTH / 2 - _bounds.width() / 2, SHERLOCK_SCREEN_HEIGHT / 2 - _bounds.height() / 2);
+
+	// Create the surface
+	_surface.create(_bounds.width(), _bounds.height());
+	_surface.fill(TRANSPARENCY);
+	makeInfoArea();
+
+	// Draw the header area
+	_surface.writeString(FIXED(EnterPassword), Common::Point((_bounds.width() - _surface.stringWidth(FIXED(EnterPassword))) / 2, 5), INFO_TOP);
+	_surface.hLine(3, _surface.fontHeight() + 7, _bounds.width() - 4, INFO_TOP);
+	_surface.hLine(3, _surface.fontHeight() + 8, _bounds.width() - 4, INFO_MIDDLE);
+	_surface.hLine(3, _surface.fontHeight() + 9, _bounds.width() - 4, INFO_BOTTOM);
+	_surface.transBlitFrom(images[4], Common::Point(0, _surface.fontHeight() + 7 - 1));
+	_surface.transBlitFrom(images[5], Common::Point(_bounds.width() - images[5]._width, _surface.fontHeight() + 7 - 1));
+
+	// Set the password entry data
+	_cursorPos = Common::Point(_surface.widestChar(), _surface.fontHeight() + 12);
+	_password = "";
+	_index = 0;
+	_cursorColor = 192;
+	_insert = true;
+
+	// Show the dialog
+	ui._menuMode = PASSWORD_MODE;
+	summonWindow();
+}
+
+void WidgetPassword::handleEvents() {
+	Events &events = *_vm->_events;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+	const Common::KeyCode &keycode = ui._keyState.keycode;
+	char currentChar = (_index == (int)_password.size()) ? ' ' : _password[_index];
+	int width = _surface.charWidth(currentChar);
+
+	if (!keycode) {
+		// Nothing entered, so keep blinking the cursor
+		if (--_blinkCounter < 0) {
+			_blinkCounter = 3;
+			_blinkFlag = !_blinkFlag;
+
+			byte color, textColor;
+			if (_blinkFlag) {
+				textColor = 236;
+				color = _cursorColor;
+			} else {
+				textColor = COMMAND_HIGHLIGHTED;
+				color = TRANSPARENCY;
+			}
+
+			// Draw the cursor and the character it's over
+			_surface.fillRect(Common::Rect(_cursorPos.x, _cursorPos.y, _cursorPos.x + width, _cursorPos.y + _surface.fontHeight()), color);
+			if (currentChar != ' ')
+				_surface.writeString(Common::String::format("%c", _password[_index]), _cursorPos, textColor);
+		}
+	} else if (keycode == Common::KEYCODE_BACKSPACE && _index) {
+		_cursorPos.x -= _surface.charWidth(_password[_index - 1]);
+
+		if (_insert)
+			_password.deleteChar(_index - 1);
+		else
+			_password.setChar(' ', _index - 1);
+
+		// Redraw the text
+		--_index;
+		_surface.fillRect(Common::Rect(_cursorPos.x, _cursorPos.y, _bounds.width() - 9, _cursorPos.y +
+			_surface.fontHeight() - 1), TRANSPARENCY);
+		_surface.writeString(_password.c_str() + _index, _cursorPos, COMMAND_HIGHLIGHTED);
+	} else if ((keycode == Common::KEYCODE_LEFT && _index > 0)
+			|| (keycode == Common::KEYCODE_RIGHT && _index < (int)_password.size() && _cursorPos.x < (_bounds.width() - _surface.widestChar() - 3))
+			|| (keycode == Common::KEYCODE_HOME && _index > 0)
+			|| (keycode == Common::KEYCODE_END)) {
+		// Restore character the cursor was previously over
+		_surface.fillRect(Common::Rect(_cursorPos.x, _cursorPos.y, _cursorPos.x + width, _cursorPos.y + _surface.fontHeight()), TRANSPARENCY);
+		if (currentChar != ' ')
+			_surface.writeString(Common::String::format("%c", _password[_index]), _cursorPos, COMMAND_HIGHLIGHTED);
+		
+		switch (keycode) {
+		case Common::KEYCODE_LEFT:
+			_cursorPos.x -= _surface.charWidth(_password[_index - 1]);
+			--_index;
+			break;
+		case Common::KEYCODE_RIGHT:
+			_cursorPos.x += _surface.charWidth(_password[_index]);
+			++_index;
+			break;
+		case Common::KEYCODE_HOME:
+			_cursorPos.x = _surface.widestChar();
+			_index = 0;
+			break;
+		case Common::KEYCODE_END:
+			_cursorPos.x = _surface.stringWidth(_password) + _surface.widestChar();
+			_index = _password.size();
+			
+			while (_index > 0 && _password[_index - 1] == ' ') {
+				_cursorPos.x -= _surface.charWidth(_password[_index - 1]);
+				--_index;
+			}
+			break;
+		default:
+			break;
+		}
+	} else if (keycode == Common::KEYCODE_INSERT) {
+		_insert = !_insert;
+		_cursorColor = _insert ? 192 : 200;
+	} else if (keycode == Common::KEYCODE_DELETE) {
+		if (_index < (int)_password.size())
+			_password.deleteChar(_index);
+
+		// Redraw the text
+		_surface.fillRect(Common::Rect(_cursorPos.x, _cursorPos.y, _bounds.width() - 9, _cursorPos.y +
+			_surface.fontHeight() - 1), TRANSPARENCY);
+		_surface.writeString(_password.c_str() + _index, _cursorPos, COMMAND_HIGHLIGHTED);
+	} else if (keycode == Common::KEYCODE_RETURN || keycode == Common::KEYCODE_ESCAPE) {
+		close();
+		return;
+	} else if (((ui._keyState.ascii >= ' ' && ui._keyState.ascii < 169) || ui._keyState.ascii == 225)) {
+		if (_cursorPos.x + _surface.charWidth(ui._keyState.ascii) < _bounds.width() - _surface.widestChar() - 3) {
+			if (_insert)
+				_password.insertChar(ui._keyState.ascii, _index);
+			else
+				_password.setChar(ui._keyState.ascii, _index);
+
+			// Redraw the text
+			_surface.fillRect(Common::Rect(_cursorPos.x, _cursorPos.y, _bounds.width() - 9, _cursorPos.y +
+				_surface.fontHeight() - 1), TRANSPARENCY);
+			_surface.writeString(_password.c_str() + _index, _cursorPos, COMMAND_HIGHLIGHTED);
+
+			_cursorPos.x += _surface.charWidth(ui._keyState.ascii);
+			++_index;
+		}
+	}
+
+	// Also handle clicking outside the window to abort
+	if (events._firstPress && !_bounds.contains(mousePos))
+		_outsideMenu = true;
+
+	if ((events._released || events._rightReleased) && _outsideMenu && !_bounds.contains(mousePos)) {
+		close();
+	}
+}
+
+void WidgetPassword::close() {
+	Talk &talk = *_vm->_talk;
+	
+	banishWindow();
+	if (talk._talkToAbort)
+		return;
+
+	// See if they entered the correct password
+	Common::String correct1 = FIXED(CorrectPassword);
+	Common::String correct2 = Common::String::format("%s?", FIXED(CorrectPassword));
+	Common::String correct3 = Common::String::format("%s ?", FIXED(CorrectPassword));
+
+	if (!_password.compareToIgnoreCase(correct1) || !_password.compareToIgnoreCase(correct2)
+			|| !_password.compareToIgnoreCase(correct3))
+		// They got it correct
+		_vm->setFlags(149);
+
+	talk.talkTo("LASC52P");
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_password.h b/engines/sherlock/tattoo/widget_password.h
new file mode 100644
index 0000000000..f7e82c798d
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_password.h
@@ -0,0 +1,68 @@
+/* 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 SHERLOCK_TATTOO_WIDGET_PASSWORD_H
+#define SHERLOCK_TATTOO_WIDGET_PASSWORD_H
+
+#include "common/scummsys.h"
+#include "sherlock/tattoo/widget_base.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+class WidgetPassword: public WidgetBase {
+private:
+	Common::Point _cursorPos;
+	Common::String _password;
+	int _index;
+	bool _blinkFlag;
+	int _blinkCounter;
+	byte _cursorColor;
+	bool _insert;
+
+	/**
+	 * Close the window and check if the entered password is correct
+	 */
+	void close();
+public:
+	WidgetPassword(SherlockEngine *vm);
+	virtual ~WidgetPassword() {}
+
+	/**
+	 * Show the password entry window
+	 */
+	void show();
+
+	/**
+	 * Handle event processing
+	 */
+	virtual void handleEvents();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_quit.cpp b/engines/sherlock/tattoo/widget_quit.cpp
new file mode 100644
index 0000000000..f853e7f47f
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_quit.cpp
@@ -0,0 +1,155 @@
+/* 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 "sherlock/tattoo/widget_quit.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+WidgetQuit::WidgetQuit(SherlockEngine *vm) : WidgetBase(vm) {
+	_select = _oldSelect = -1;
+}
+
+void WidgetQuit::show() {
+	Events &events = *_vm->_events;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	ImageFile &images = *ui._interfaceImages;
+	Common::Point mousePos = events.mousePos();
+	const char *YES = FIXED(Yes);
+	const char *NO = FIXED(No);
+
+	// Set up the display area
+	_bounds = Common::Rect(_surface.stringWidth(FIXED(AreYouSureYou)) + _surface.widestChar() * 2,
+		(_surface.fontHeight() + 7) * 4);
+	_bounds.moveTo(mousePos.x - _bounds.width() / 2, mousePos.y - _bounds.height() / 2);
+
+	// Create the surface
+	_surface.create(_bounds.width(), _bounds.height());
+	_surface.fill(TRANSPARENCY);
+	makeInfoArea();
+
+	// Draw the message text
+	_surface.writeString(FIXED(AreYouSureYou), Common::Point((_surface.w() - _surface.stringWidth(FIXED(AreYouSureYou))) / 2, 5), INFO_TOP);
+	_surface.writeString(FIXED(WishToQuit), Common::Point((_surface.w() - _surface.stringWidth(FIXED(WishToQuit))) / 2,
+		_surface.fontHeight() + 9), INFO_TOP);
+
+	// Draw the horizontal bars seperating the commands and the message
+	int yp = (_surface.fontHeight() + 4) * 2 + 3;
+	for (int idx = 0; idx < 2; ++idx) {
+		_surface.transBlitFrom(images[4], Common::Point(0, yp - 1));
+		_surface.transBlitFrom(images[5], Common::Point(_surface.w() - images[5]._width, yp - 1));
+		_surface.hLine(3, yp, _surface.w() - 4, INFO_TOP);
+		_surface.hLine(3, yp + 1, _surface.w() - 4, INFO_MIDDLE);
+		_surface.hLine(3, yp + 2, _surface.w() - 4, INFO_BOTTOM);
+
+		const char *btn = (idx == 0) ? YES : NO;
+		_surface.writeString(btn, Common::Point((_bounds.width() - _surface.stringWidth(btn)) / 2, yp + 5), INFO_TOP);
+		yp += _surface.fontHeight() + 7;
+	}
+
+	ui._menuMode = QUIT_MODE;
+	summonWindow();
+}
+
+void WidgetQuit::handleEvents() {
+	Events &events = *_vm->_events;
+	Talk &talk = *_vm->_talk;
+	Common::Point mousePos = events.mousePos();
+	Common::Rect yesRect(_bounds.left, _bounds.top + (_surface.fontHeight() + 4) * 2 + 3, _bounds.right,
+		_bounds.top + (_surface.fontHeight() + 4) * 2 + 3 + _surface.fontHeight() + 7);
+	Common::Rect noRect(_bounds.left, _bounds.top + (_surface.fontHeight() + 4) * 2 + _surface.fontHeight() + 10,
+		_bounds.right, _bounds.top + (_surface.fontHeight() + 4) * 2 + 10 + _surface.fontHeight() * 2 + 7);
+
+	if (talk._talkToAbort)
+		return;
+
+	// Determine the highlighted item
+	_select = -1;
+	if (yesRect.contains(mousePos))
+		_select = 1;
+	else if (noRect.contains(mousePos))
+		_select = 0;
+
+	if (events.kbHit()) {
+		Common::KeyState keyState = events.getKey();
+
+		switch (keyState.keycode) {
+		case Common::KEYCODE_TAB:
+			// If the mouse is not over any of the options, move the mouse so that it points to the first option
+			if (_select == -1)
+				events.warpMouse(Common::Point(_bounds.right - 10, _bounds.top + (_surface.fontHeight() + 4) * 2
+					+ 3 + _surface.fontHeight() + 1));
+			else if (_select == 1)
+				events.warpMouse(Common::Point(mousePos.x, _bounds.top + (_surface.fontHeight() + 4) * 2
+					+ 3 + _surface.fontHeight() * 2 + 11));
+			else
+				events.warpMouse(Common::Point(mousePos.x, _bounds.top + (_surface.fontHeight() + 4) * 2
+					+ 3 + _surface.fontHeight() + 1));
+			break;
+
+		case Common::KEYCODE_ESCAPE:
+		case Common::KEYCODE_n:
+			close();
+			return;
+
+		case Common::KEYCODE_y:
+			close();
+			_vm->quitGame();
+			break;
+
+		default:
+			break;
+		}
+	}
+
+	// Check for change of the highlighted item
+	if (_select != _oldSelect) {
+		byte color = (_select == 1) ? COMMAND_HIGHLIGHTED : INFO_TOP;
+		int yp = (_surface.fontHeight() + 4) * 2 + 8;
+		_surface.writeString(FIXED(Yes), Common::Point((_surface.w() - _surface.stringWidth(FIXED(Yes))) / 2, yp), color);
+		
+		color = (_select == 0) ? COMMAND_HIGHLIGHTED : INFO_TOP;
+		yp += (_surface.fontHeight() + 7);
+		_surface.writeString(FIXED(No), Common::Point((_surface.w() - _surface.stringWidth(FIXED(No))) / 2, yp), color);
+	}
+	_oldSelect = _select;
+
+	// Flag is they started pressing outside of the menu
+	if (events._firstPress && !_bounds.contains(mousePos))
+		_outsideMenu = true;
+
+	if (events._released || events._rightReleased) {
+		events.clearEvents();
+		close();
+		if (_select == 1)
+			// Yes selected
+			_vm->quitGame();
+	}
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_quit.h b/engines/sherlock/tattoo/widget_quit.h
new file mode 100644
index 0000000000..b8b640f2d2
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_quit.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 SHERLOCK_TATTOO_WIDGET_QUIT_H
+#define SHERLOCK_TATTOO_WIDGET_QUIT_H
+
+#include "common/scummsys.h"
+#include "sherlock/tattoo/widget_base.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+class WidgetQuit: public WidgetBase {
+private:
+	int _select, _oldSelect;
+public:
+	WidgetQuit(SherlockEngine *vm);
+	virtual ~WidgetQuit() {}
+
+	/**
+	 * Prompt the user whether to quit
+	 */
+	void show();
+
+	/**
+	 * Handle event processing
+	 */
+	virtual void handleEvents();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_talk.cpp b/engines/sherlock/tattoo/widget_talk.cpp
new file mode 100644
index 0000000000..6e7bde292f
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_talk.cpp
@@ -0,0 +1,470 @@
+/* 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 "sherlock/tattoo/widget_talk.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_journal.h"
+#include "sherlock/tattoo/tattoo_people.h"
+#include "sherlock/tattoo/tattoo_talk.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+#define STATEMENT_NUM_X 6
+#define NUM_VISIBLE_TALK_LINES 6
+
+WidgetTalk::WidgetTalk(SherlockEngine *vm) : WidgetBase(vm) {
+	_talkScrollIndex = 0;
+	_selector = _oldSelector = -1;
+	_talkTextX = 0;
+	_dialogTimer = 0;
+}
+
+void WidgetTalk::getTalkWindowSize() {
+	TattooTalk &talk = *(TattooTalk *)_vm->_talk;
+	int width, height;
+
+	// See how many statements are going to be available
+	int numStatements = 0;
+	for (uint idx = 0; idx < talk._statements.size(); ++idx) {
+		if (talk._statements[idx]._talkMap != -1)
+			++numStatements;
+	}
+
+	width = SHERLOCK_SCREEN_WIDTH * 2 / 3;
+
+	// Split up the questions into separate strings for each line
+	_bounds = Common::Rect(width, 1);
+	setStatementLines();
+
+	// Make sure that the window does not get too big
+	if (_statementLines.size() < 7) {
+		height = (_surface.fontHeight() + 1) * _statementLines.size() + 9;
+		_scroll = false;
+	} else {
+		// Set up the height to a constrained amount, and add extra width for the scrollbar
+		width += BUTTON_SIZE + 3;
+		height = (_surface.fontHeight() + 1) * 6 + 9;
+		_scroll = true;
+	}
+
+	_bounds = Common::Rect(width, height);
+}
+
+void WidgetTalk::load() {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+
+	// Figure out the window size
+	getTalkWindowSize();
+
+	// Place the window centered above the player
+	Common::Point pt;
+	int scaleVal = scene.getScaleVal(people[HOLMES]._position);
+	pt.x = people[HOLMES]._position.x / FIXED_INT_MULTIPLIER - _bounds.width() / 2;
+
+	if (scaleVal == SCALE_THRESHOLD) {
+		pt.x += people[0].frameWidth() / 2;
+		pt.y = people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES].frameHeight()
+			- _bounds.height() - _surface.fontHeight();
+	} else {
+		pt.x += people[HOLMES]._imageFrame->sDrawXSize(scaleVal) / 2;
+		pt.y = people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES]._imageFrame->sDrawYSize(scaleVal)
+			- _bounds.height() - _surface.fontHeight();
+	}
+
+	_bounds.moveTo(pt);
+
+	// Set up the surface
+	_surface.create(_bounds.width(), _bounds.height());
+	_surface.fill(TRANSPARENCY);
+
+	// Form the background for the new window
+	makeInfoArea();
+}
+
+void WidgetTalk::handleEvents() {
+	Events &events = *_vm->_events;
+	TattooJournal &journal = *(TattooJournal *)_vm->_journal;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Sound &sound = *_vm->_sound;
+	TattooTalk &talk = *(TattooTalk *)_vm->_talk;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+	Common::KeyCode keycode = ui._keyState.keycode;
+	bool hotkey = false;
+	bool callParrotFile = false;
+
+	// Handle scrollbar events
+	ScrollHighlight oldHighlight = ui._scrollHighlight;
+	handleScrollbarEvents(_talkScrollIndex, NUM_VISIBLE_TALK_LINES, _statementLines.size());
+
+	int oldScrollIndex = _talkScrollIndex;
+	handleScrolling(_talkScrollIndex, NUM_VISIBLE_TALK_LINES, _statementLines.size());
+
+	// Only redraw the window if the the scrollbar position has changed
+	if (ui._scrollHighlight != oldHighlight || oldScrollIndex != _talkScrollIndex)
+		render(HL_NO_HIGHLIGHTING);
+
+	// Flag if they started pressing outside of the window
+	if (events._firstPress && !_bounds.contains(mousePos))
+		_outsideMenu = true;
+		
+	// Check for which statement they are pointing at
+	_selector = -1;
+	if (ui._scrollHighlight == SH_NONE) {
+		if (Common::Rect(_bounds.left, _bounds.top + 5, _bounds.right - 3, _bounds.bottom - 5).contains(mousePos)) {
+			if (_scroll) {
+				// Disregard the scrollbar when setting the statement number
+				if (!Common::Rect(_bounds.right - BUTTON_SIZE, _bounds.top, _bounds.right, _bounds.bottom).contains(mousePos))
+					_selector = (mousePos.y - _bounds.top - 5) / (_surface.fontHeight() + 1) + _talkScrollIndex;
+			} else {
+				_selector = (mousePos.y - _bounds.top - 5) / (_surface.fontHeight() + 1);
+			}
+
+			// Now translate the line number of the displayed line into the appropriate
+			// Statement number or set it to 255 to indicate no Statement selected
+			if (_selector >= 0 && _selector < (int)_statementLines.size())
+				_selector = _statementLines[_selector]._num;
+			else
+				_selector = -1;
+		}
+	}
+
+	// Check for the tab keys
+	if (keycode == Common::KEYCODE_TAB && ui._scrollHighlight == SH_NONE) {
+		if (_selector == -1) {
+			_selector = _statementLines[_scroll ? _talkScrollIndex : 0]._num;
+			
+			events.warpMouse(Common::Point(_bounds.right - BUTTON_SIZE - 10, _bounds.top + _surface.fontHeight() + 2));
+		} else {
+			if (ui._keyState.flags & Common::KBD_SHIFT) {
+				_selector = (mousePos.y - _bounds.top - 5) / (_surface.fontHeight() + 1) + _talkScrollIndex;
+				if (_statementLines[_selector]._num == _statementLines[_talkScrollIndex]._num) {
+					_selector = (_bounds.height() - 10) / (_surface.fontHeight() + 1) + _talkScrollIndex;
+				} else {
+					int idx = _selector;
+					do {
+						--_selector;
+					} while (_selector > 0 && _statementLines[idx]._num == _statementLines[_selector]._num);
+				}
+
+				int idx = _selector;
+				while ((_statementLines[idx]._num == _statementLines[_selector - 1]._num) && (_selector > _talkScrollIndex))
+					--_selector;
+			} else {
+				_selector = (mousePos.y - _bounds.top - 5) / (_surface.fontHeight() + 1) + _talkScrollIndex;
+				if (_statementLines[_selector]._num == _statementLines[(_bounds.height() - 10) / (_surface.fontHeight() + 1) + _talkScrollIndex]._num) {
+					_selector = _talkScrollIndex;
+				} else {
+					int idx = _selector;
+					do {
+						++_selector;
+					} while (_selector < (int)_statementLines.size() && _statementLines[idx]._num == _statementLines[_selector]._num);
+				}
+			}
+
+			events.warpMouse(Common::Point(mousePos.x, _bounds.top + _surface.fontHeight() + 2 + (_surface.fontHeight() + 1)
+				* (_selector - _talkScrollIndex)));
+			_selector = _statementLines[_selector]._num;
+		}
+	}
+
+	// Handle selecting a talk entry if a numeric key has been pressed
+	if (keycode >= Common::KEYCODE_1 && keycode <= Common::KEYCODE_9) {
+		int x = 0, t = 0, y = 0;
+
+		do {
+			if (y == (keycode - Common::KEYCODE_1)) {
+				_selector = _statementLines[t]._num;
+				_outsideMenu = false;
+				hotkey = true;
+				break;
+			}
+
+			++t;
+			if (_statementLines[x]._num != _statementLines[t]._num) {
+				x = t;
+				++y;
+			}
+		} while (t < (int)_statementLines.size());
+	}
+
+	// Display the selected statement highlighted and reset the last statement.
+	if (_selector != _oldSelector) {
+		render(HL_CHANGED_HIGHLIGHTS);
+		_oldSelector = _selector;
+	}
+
+	if (events._released || events._rightReleased || keycode == Common::KEYCODE_ESCAPE || hotkey) {
+		events.clearEvents();
+		_dialogTimer = 0;
+		ui._scrollHighlight = SH_NONE;
+
+		// See if they want to close the menu (click outside the window or Escape pressed)
+		if ((_outsideMenu && !_bounds.contains(mousePos)) || keycode == Common::KEYCODE_ESCAPE) {
+			if (keycode == Common::KEYCODE_ESCAPE)
+				_selector = -1;
+
+			talk.freeTalkVars();
+			talk.pullSequence();
+
+			for (int idx = 1; idx < MAX_CHARACTERS; ++idx) {
+				if (people[idx]._type == CHARACTER) {
+					while (!people[idx]._pathStack.empty())
+						people[idx].pullNPCPath();
+				}
+			}
+
+			banishWindow();
+			ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+
+			if (scene._currentScene == WEARY_PUNT)
+				callParrotFile = true;
+		}
+
+		_outsideMenu = false;
+
+		// See if they have selected a statement to say
+		if (_selector != -1) {
+			if (!talk._talkHistory[talk._converseNum][_selector] && talk._statements[_selector]._journal)
+				journal.record(talk._converseNum, _selector);
+			talk._talkHistory[talk._converseNum][_selector] = true;
+
+			banishWindow();
+			talk._speaker = _vm->readFlags(FLAG_PLAYER_IS_HOLMES) ? HOLMES : WATSON;
+			_scroll = false;
+			const byte *msg = (const byte *)talk._statements[_selector]._statement.c_str();
+			talk.talkInterface(msg);
+
+			if (sound._speechOn)
+				sound._talkSoundFile += Common::String::format("%02dA", _selector + 1);
+
+			int msgLen = MAX((int)talk._statements[_selector]._statement.size(), 160);
+			people.setTalkSequence(talk._speaker);
+
+			talk.waitForMore(msgLen);
+			if (talk._talkToAbort)
+				return;
+
+			people.setListenSequence(talk._speaker);
+
+			do {
+				talk._scriptSelect = _selector;
+				talk._speaker = talk._talkTo;
+				
+				// Make a copy of the reply (since talkTo can reload the statements list), and call talkTo
+				Common::String reply = talk._statements[_selector]._reply;
+				talk.doScript(reply);
+
+				// Reset the misc field in case any people changed their sequences
+				for (int idx = 0; idx < MAX_CHARACTERS; ++idx)
+					people[idx]._misc = 0;
+
+				if (!talk._talkToAbort) {
+					if (!talk._statements[_selector]._modified.empty()) {
+						for (uint idx = 0; idx < talk._statements[_selector]._modified.size(); ++idx)
+							_vm->setFlags(talk._statements[_selector]._modified[idx]);
+
+						talk.setTalkMap();
+					}
+
+					// See if there is another talk file linked to this.
+					if (!talk._statements[_selector]._linkFile.empty() && !talk._scriptMoreFlag) {
+						Common::String linkFile = talk._statements[_selector]._linkFile;
+						talk.freeTalkVars();
+						talk.loadTalkFile(linkFile);
+
+						_talkScrollIndex = 0;
+						int select = -1;
+						_selector = _oldSelector = -1;
+
+						// Find the first statement that has all its flags set correctly
+						for (uint idx = 0; idx < talk._statements.size() && select == -1; ++select) {
+							if (!talk._statements[idx]._talkMap)
+								select = idx;
+						}
+
+						if (select == -1) {
+							talk.freeTalkVars();
+							talk.nothingToSay();
+							return;
+						}
+
+						// See is the new statement is in stealth mode
+						talk._talkStealth = (talk._statements[select]._statement.hasPrefix("^")) ? 2 : 0;
+
+						// See if the new file is a standard file, a reply first file, or a Stealth Mode file
+						if (!talk._statements[select]._statement.hasPrefix("*") && !talk._statements[select]._statement.hasPrefix("^")) {
+							load();
+							summonWindow();
+
+							setStatementLines();
+							render(HL_NO_HIGHLIGHTING);
+							break;
+						} else {
+							_selector = select;
+
+							if (!talk._talkHistory[talk._converseNum][_selector] && talk._statements[_selector]._journal)
+								journal.record(talk._converseNum, _selector);
+
+							talk._talkHistory[talk._converseNum][_selector] = true;
+						}
+					} else {
+						talk.freeTalkVars();
+						talk.pullSequence();
+
+						for (int idx = 1; idx < MAX_CHARACTERS; ++idx) {
+							if (people[idx]._type == CHARACTER)
+								while (!people[idx]._pathStack.empty())
+									people[idx].pullNPCPath();
+						}
+
+						if (ui._menuMode != PASSWORD_MODE) {
+							ui.banishWindow();
+							ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+							events.setCursor(ARROW);
+						}
+						break;
+					}
+				} else {
+					break;
+				}
+			} while (!_vm->shouldQuit());
+
+			events.clearEvents();
+
+			// Now, if a script was pushed onto the script stack, restore them to allow the previous script to continue.
+			talk.popStack();
+		}
+	}
+
+	if (callParrotFile)
+		talk.talkTo("POUT52A");
+}
+
+void WidgetTalk::render(Highlight highlightMode) {
+	TattooTalk &talk = *(TattooTalk *)_vm->_talk;
+
+	if (highlightMode != HL_SCROLLBAR_ONLY) {
+		int yp = 5;
+		int statementNum = 1;
+
+		// Draw all the statements
+		// Check whether scrolling has occurred, and if so, figure out what the starting
+		// number for the first visible statement will be
+		if (_talkScrollIndex) {
+			for (int idx = 1; idx <= _talkScrollIndex; ++idx) {
+				if (_statementLines[idx - 1]._num != _statementLines[idx]._num)
+					++statementNum;
+			}
+		}
+
+		// Main drawing loop
+		for (uint idx = _talkScrollIndex; idx < _statementLines.size() && yp < (_bounds.height() - _surface.fontHeight()); ++idx) {
+			if (highlightMode == HL_NO_HIGHLIGHTING || _statementLines[idx]._num == _selector ||
+					_statementLines[idx]._num == _oldSelector) {
+				// Erase the line contents
+				_surface.fillRect(Common::Rect(3, yp, _surface.w() - BUTTON_SIZE - 3, yp + _surface.fontHeight()), TRANSPARENCY);
+
+				// Different coloring based on whether the option has been previously chosen or not
+				byte color = (!talk._talkHistory[talk._converseNum][_statementLines[idx]._num]) ?
+					INFO_TOP : INFO_BOTTOM;
+
+				if (_statementLines[idx]._num == _selector && highlightMode == HL_CHANGED_HIGHLIGHTS)
+					color = COMMAND_HIGHLIGHTED;
+
+				// See if it's the start of a new statement, so needs the statement number to be displayed
+				if (!idx || _statementLines[idx]._num != _statementLines[idx - 1]._num) {
+					Common::String numStr = Common::String::format("%d.", statementNum);
+					_surface.writeString(numStr, Common::Point(STATEMENT_NUM_X, yp), color);
+				}
+
+				// Display the statement line
+				_surface.writeString(_statementLines[idx]._line, Common::Point(_talkTextX, yp), color);
+			}
+			yp += _surface.fontHeight() + 1;
+
+			// If the next line starts a new statement, then increment the statement number
+			if (idx == (_statementLines.size() - 1) || _statementLines[idx]._num != _statementLines[idx + 1]._num)
+				++statementNum;
+		}
+	}
+
+	// See if the scroll bar needs to be drawn
+	if (_scroll && highlightMode != HL_CHANGED_HIGHLIGHTS)
+		drawScrollBar(_talkScrollIndex, NUM_VISIBLE_TALK_LINES, _statementLines.size());
+}
+
+void WidgetTalk::setStatementLines() {
+	TattooTalk &talk = *(TattooTalk *)_vm->_talk;
+	const char *numStr = "19.";
+
+	// See how many statements are going to be available
+	int numStatements = 0;
+	for (uint idx = 0; idx < talk._statements.size(); ++idx) {
+		if (talk._statements[idx]._talkMap != -1)
+			++numStatements;
+	}
+
+	// If there are more lines than can be displayed in the interface window at one time, adjust the allowed 
+	// width to take into account needing a scrollbar
+	int xSize = _scroll ? _bounds.width() - BUTTON_SIZE - 3 : _bounds.width();
+
+	// Also adjust the width to allow room for the statement numbers at the left edge of the display
+	int n = (numStatements < 10) ? 1 : 0;
+	xSize -= _surface.stringWidth(numStr + n) + _surface.widestChar() / 2 + 9;
+	_talkTextX = _surface.stringWidth(numStr + n) + _surface.widestChar() / 4 + 6;
+	_statementLines.clear();
+
+	for (uint statementNum = 0; statementNum < talk._statements.size(); ++statementNum) {
+		// See if this statment meets all of its flag requirements
+		if (talk._statements[statementNum]._talkMap != -1) {
+			// Get the next statement text to process
+			Common::String str = talk._statements[statementNum]._statement;
+
+			Common::StringArray statementLines;
+			splitLines(str, statementLines, xSize, 999);
+
+			// Add the lines in
+			for (uint idx = 0; idx < statementLines.size(); ++idx)
+				_statementLines.push_back(StatementLine(statementLines[idx], statementNum));
+		}
+	}
+}
+
+void WidgetTalk::refresh() {
+	_talkScrollIndex = 0;
+	_selector = _oldSelector = -1;
+
+	setStatementLines();
+	render(HL_NO_HIGHLIGHTING);
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_talk.h b/engines/sherlock/tattoo/widget_talk.h
new file mode 100644
index 0000000000..f5e939b393
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_talk.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 SHERLOCK_TATTOO_WIDGET_TALK_H
+#define SHERLOCK_TATTOO_WIDGET_TALK_H
+
+#include "common/scummsys.h"
+#include "sherlock/tattoo/widget_base.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+enum Highlight { HL_NO_HIGHLIGHTING, HL_CHANGED_HIGHLIGHTS, HL_SCROLLBAR_ONLY };
+
+/**
+ * Handles displaying a dialog with conversation options the player can select from
+ */
+class WidgetTalk: public WidgetBase {
+	struct StatementLine {
+		Common::String _line;
+		int _num;
+
+		StatementLine() : _num(0) {}
+		StatementLine(const Common::String &line, int num) : _line(line), _num(num) {}
+	};
+private:
+	int _talkScrollIndex;
+	Common::Array<StatementLine> _statementLines;
+	int _selector, _oldSelector;
+	int _talkTextX;
+	uint32 _dialogTimer;
+
+	/**
+	 * Get the needed size for a talk window
+	 */
+	void getTalkWindowSize();
+
+	/**
+	 * Re-renders the contenst of the window to the widget's surface
+	 */
+	void render(Highlight highlightMode);
+
+	/**
+	 * This initializes the _statementLines array, which contains the talk options split up line
+	 * by line, as well as which statement a particular line is part of.
+	 */
+	void setStatementLines();
+public:
+	WidgetTalk(SherlockEngine *vm);
+	virtual ~WidgetTalk() {}
+
+	/**
+	 * Figures out how many lines the available talk lines will take up, and opens a text window
+	 * of appropriate size
+	 */
+	void load();
+
+	/**
+	 * Refresh the talk display
+	 */
+	void refresh();
+
+	/**
+	 * Handle event processing
+	 */
+	virtual void handleEvents();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_text.cpp b/engines/sherlock/tattoo/widget_text.cpp
new file mode 100644
index 0000000000..86aa067301
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_text.cpp
@@ -0,0 +1,228 @@
+/* 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 "sherlock/tattoo/widget_text.h"
+#include "sherlock/tattoo/tattoo_people.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+WidgetText::WidgetText(SherlockEngine *vm) : WidgetBase(vm) {
+}
+
+void WidgetText::load(const Common::String &str, int speaker) {
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::StringArray lines;
+
+	int width = SHERLOCK_SCREEN_WIDTH / 3;
+	int height;
+
+	for (;;) {
+		splitLines(str, lines, width - _surface.widestChar() * 2, 100);
+		height = (screen.fontHeight() + 1) * lines.size() + 9;
+
+		if ((width - _surface.widestChar() * 2 > height * 3 / 2) || (width - _surface.widestChar() * 2
+				> SHERLOCK_SCREEN_WIDTH * 3 / 4))
+			break;
+
+		width += (width / 4);
+	}
+
+	// See if it's only a single line long
+	if (height == _surface.fontHeight() + 10) {
+		width = _surface.widestChar() * 2 + 6;
+			
+		const char *strP = str.c_str();
+		while (*strP && (*strP < talk._opcodes[OP_SWITCH_SPEAKER] || *strP == talk._opcodes[OP_NULL]))
+			width += _surface.charWidth(*strP++);
+	}
+
+	_bounds = Common::Rect(width, height);
+		
+	if (speaker == -1) {
+		// No speaker specified, so center window on look position
+		_bounds.translate(ui._lookPos.x - width / 2, ui._lookPos.y - height / 2);
+	} else {
+		// Speaker specified, so center the window above them
+		centerWindowOnSpeaker(speaker);
+	}
+
+	render(str);
+}
+
+void WidgetText::centerWindowOnSpeaker(int speaker) {
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Common::Point pt;
+
+	bool flag = _vm->readFlags(FLAG_PLAYER_IS_HOLMES);
+	if (people[HOLMES]._type == CHARACTER && ((speaker == HOLMES && flag) || (speaker == WATSON && !flag))) {
+		// Place the window centered above the player
+		pt.x = people[HOLMES]._position.x / FIXED_INT_MULTIPLIER - _bounds.width() / 2;
+
+		int scaleVal = scene.getScaleVal(people[HOLMES]._position);
+		if (scaleVal == SCALE_THRESHOLD) {
+			pt.x += people[HOLMES].frameWidth() / 2;
+			pt.y = people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES].frameHeight() 
+				- _bounds.height() - _surface.fontHeight();
+		} else {
+			pt.x += people[HOLMES]._imageFrame->sDrawXSize(scaleVal) / 2;
+			pt.y = people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES]._imageFrame->sDrawYSize(scaleVal) 
+				- _bounds.height() - _surface.fontHeight();
+		}
+	} else {
+		pt.y = -1;
+
+		// Check each NPC to see if they are the one that is talking
+		for (int idx = 1; idx < MAX_CHARACTERS; ++idx) {
+			// WORKAROUND: Fixes an original game bug where the positioning for Watson's dialogs
+			// during conversations at the Park Lake lake scene is in the incorrect position
+			if (speaker == 1 && scene._currentScene == 30)
+				continue;
+
+			if (people[idx]._type == CHARACTER) {
+				if (!scumm_strnicmp(people[idx]._npcName.c_str(), people._characters[speaker]._portrait, 4)) {
+					// Place the window above the player
+					pt.x = people[idx]._position.x / FIXED_INT_MULTIPLIER - _bounds.width() / 2;
+
+					int scaleVal = scene.getScaleVal(people[idx]._position);
+					if (scaleVal == SCALE_THRESHOLD) {
+						pt.x += people[idx].frameWidth() / 2;
+						pt.y = people[idx]._position.y / FIXED_INT_MULTIPLIER - people[idx].frameHeight()
+							- _bounds.height() - _surface.fontHeight();
+					}
+					else {
+						pt.x += people[idx]._imageFrame->sDrawXSize(scaleVal) / 2;
+						pt.y = people[idx]._position.y / FIXED_INT_MULTIPLIER - people[idx]._imageFrame->sDrawYSize(scaleVal)
+							- _bounds.height() - _surface.fontHeight();
+					}
+
+					if (pt.y < 0)
+						pt.y = 0;
+					break;
+				}
+			}
+		}
+
+		if (pt.y == -1) {
+			for (uint idx = 0; idx < scene._bgShapes.size(); ++idx) {
+				Object &obj = scene._bgShapes[idx];
+
+				if (obj._type == ACTIVE_BG_SHAPE && !scumm_strnicmp(obj._name.c_str(), people._characters[speaker]._portrait, 4)) {
+					// Place the window centered above the character
+					pt.x = obj._position.x - _bounds.width() / 2;
+					pt.y = obj._position.y - _bounds.height() - _surface.fontHeight();
+					if (pt.y < 0)
+						pt.y = 0;
+					if (obj._scaleVal == SCALE_THRESHOLD)
+						pt.x += obj.frameWidth() / 2;
+					else
+						pt.x += obj._imageFrame->sDrawXSize(obj._scaleVal) / 2;
+
+					break;
+				}
+			}
+		}
+
+		if (pt.y == -1) {
+			pt.x = SHERLOCK_SCREEN_WIDTH / 2 - _bounds.width() / 2;
+			pt.y = SHERLOCK_SCREEN_HEIGHT / 2 - _bounds.height() / 2;
+		}
+	}
+
+	_bounds.moveTo(pt);
+}
+
+void WidgetText::render(const Common::String &str) {
+	Common::StringArray lines;
+	_remainingText = splitLines(str, lines, _bounds.width() - _surface.widestChar() * 2,
+		_bounds.height() / (_surface.fontHeight() + 1));
+
+	// Allocate a surface for the window
+	_surface.create(_bounds.width(), _bounds.height());
+	_surface.fill(TRANSPARENCY);
+
+	// Form the background for the new window
+	makeInfoArea();
+
+	int yp = 5;
+	for (int lineNum = 0; yp < (_bounds.height() - _surface.fontHeight() / 2); ++lineNum) {
+		_surface.writeString(lines[lineNum], Common::Point(_surface.widestChar(), yp), INFO_TOP);
+		yp += _surface.fontHeight() + 1;
+	}
+}
+
+/*----------------------------------------------------------------*/
+
+WidgetMessage::WidgetMessage(SherlockEngine *vm) : WidgetBase(vm) {
+	_menuCounter = 0;
+}
+
+void WidgetMessage::load(const Common::String &str, int time) {
+	Events &events = *_vm->_events;
+	Common::Point mousePos = events.mousePos();
+	_menuCounter = time;
+
+	// Set up the bounds for the dialog to be a single line
+	_bounds = Common::Rect(_surface.stringWidth(str) + _surface.widestChar() * 2 + 6, _surface.fontHeight() + 10);
+	_bounds.moveTo(mousePos.x - _bounds.width() / 2, mousePos.y - _bounds.height() / 2);
+
+	// Allocate a surface for the window
+	_surface.create(_bounds.width(), _bounds.height());
+	_surface.fill(TRANSPARENCY);
+
+	// Form the background for the new window and write the line of text
+	makeInfoArea();
+	_surface.writeString(str, Common::Point(_surface.widestChar() + 3, 5), INFO_TOP);
+}
+
+void WidgetMessage::handleEvents() {
+	Events &events = *_vm->_events;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	WidgetBase::handleEvents();
+
+	--_menuCounter;
+
+	// Check if a mouse or keypress has occurred, or the display counter has expired
+	if (events._pressed || events._released || events._rightPressed || events._rightReleased ||
+			ui._keyState.keycode || !_menuCounter) {
+		// Close the window
+		banishWindow();
+
+		// Reset cursor and switch back to standard mode
+		events.setCursor(ARROW);
+		events.clearEvents();
+		ui._key = -1;
+		ui._oldBgFound = -1;
+		ui._menuMode = STD_MODE;
+	}
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_text.h b/engines/sherlock/tattoo/widget_text.h
new file mode 100644
index 0000000000..f027bdae9f
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_text.h
@@ -0,0 +1,80 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_TATTOO_WIDGET_TEXT_H
+#define SHERLOCK_TATTOO_WIDGET_TEXT_H
+
+#include "common/scummsys.h"
+#include "sherlock/tattoo/widget_base.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+class WidgetText: public WidgetBase {
+private:
+	/**
+	 * Center the area the dialog will be drawn on above a given speaker
+	 */
+	void centerWindowOnSpeaker(int speaker);
+
+	/**
+	 * Build up the text dialog based on the previously set bounds
+	 */
+	void render(const Common::String &str);
+public:
+	Common::String _remainingText;
+public:
+	WidgetText(SherlockEngine *vm);
+	virtual ~WidgetText() {}
+
+	/**
+	 * Load the data for the text window
+	 */
+	void load(const Common::String &str, int speaker = -1);
+};
+
+class WidgetMessage : public WidgetBase {
+private:
+	int _menuCounter;
+public:
+	WidgetMessage(SherlockEngine *vm);
+	virtual ~WidgetMessage() {}
+
+	/**
+	 * Load the data for the text window
+	 */
+	void load(const Common::String &str, int time);
+
+	/**
+	 * Handle event processing
+	 */
+	virtual void handleEvents();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_tooltip.cpp b/engines/sherlock/tattoo/widget_tooltip.cpp
new file mode 100644
index 0000000000..b29f45f531
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_tooltip.cpp
@@ -0,0 +1,223 @@
+/* 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 "sherlock/tattoo/widget_tooltip.h"
+#include "sherlock/tattoo/tattoo_map.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+#define MAX_TOOLTIP_WIDTH 150
+
+void WidgetTooltipBase::draw() {
+	Screen &screen = *_vm->_screen;
+
+	// If there was a previously drawn frame in a different position that hasn't yet been erased, then erase it
+	if (_oldBounds.width() > 0 && _oldBounds != _bounds)
+		erase();
+
+	if (_bounds.width() > 0 && !_surface.empty()) {
+		restrictToScreen();
+
+		// Blit the affected area to the screen
+		screen.slamRect(_bounds);
+		
+		// Draw the widget directly onto the screen. Unlike other widgets, we don't draw to the back buffer,
+		// since nothing should be drawing on top of tooltips, so there's no need to store in the back buffer
+		screen.transBlitFrom(_surface, Common::Point(_bounds.left - screen._currentScroll.x, 
+			_bounds.top - screen._currentScroll.y));
+
+		// Store a copy of the drawn area for later erasing
+		_oldBounds = _bounds;
+	}
+}
+
+void WidgetTooltipBase::erase() {
+	Screen &screen = *_vm->_screen;
+
+	if (_oldBounds.width() > 0) {
+		// Restore the affected area from the back buffer to the screen
+		screen.slamRect(_oldBounds);
+
+		// Reset the old bounds so it won't be erased again
+		_oldBounds = Common::Rect(0, 0, 0, 0);
+	}
+}
+
+/*----------------------------------------------------------------*/
+
+WidgetTooltip::WidgetTooltip(SherlockEngine *vm) : WidgetTooltipBase (vm), _offsetY(0) {
+}
+
+void WidgetTooltip::setText(const Common::String &str) {
+	Events &events = *_vm->_events;
+	Common::Point mousePos = events.mousePos();
+	bool reset = false;
+	
+	// Make sure that the description is present
+	if (!str.empty()) {
+		int width = _surface.stringWidth(str) + 2;
+		int height = _surface.stringHeight(str) + 2;
+		Common::String line1 = str, line2 = "";
+
+		// See if we need to split it into two lines
+		if (width > MAX_TOOLTIP_WIDTH) {
+			// Go forward word by word to find out where to split the line
+			const char *s = str.c_str();
+			const char *space = nullptr;
+			int dif = 10000;
+
+			for (;;) {
+				// Find end of next word
+				s = strchr(s + 1, ' ');
+
+				if (s == nullptr) {
+					// Reached end of string
+					if (space != nullptr) {
+						line1 = Common::String(str.c_str(), space);
+						line2 = Common::String(space + 1);
+						height = _surface.stringHeight(line1) + _surface.stringHeight(line2) + 4;
+					}
+					break;
+				}
+
+				// Found space separating words, so see what width the string up to now is
+				Common::String tempLine1 = Common::String(str.c_str(), s);
+				Common::String tempLine2 = Common::String(s + 1);
+				int width1 = _surface.stringWidth(tempLine1);
+				int width2 = _surface.stringWidth(tempLine2);
+
+				// See if we've found a split point that results in a less overall width
+				if (ABS(width1 - width2) < dif) {
+					// Found a better split point
+					dif = ABS(width1 - width2);
+					space = s;
+					line1 = tempLine1;
+					line2 = tempLine2;
+				}
+			}
+		} else {
+			// No line split needed
+			height = _surface.stringHeight(str) + 2;
+		}
+
+		// Reallocate the text surface with the new size
+		_surface.create(width, height);
+		_surface.fill(TRANSPARENCY);
+
+		if (line2.empty()) {
+			// Only a single line
+			_surface.writeFancyString(str, Common::Point(0, 0), BLACK, INFO_TOP);
+		} else {
+			// Two lines to display
+			int xp, yp;
+			xp = (width - _surface.stringWidth(line1) - 2) / 2;
+			_surface.writeFancyString(line1, Common::Point(xp, 0), BLACK, INFO_TOP);
+
+			xp = (width - _surface.stringWidth(line2) - 2) / 2;
+			yp = _surface.stringHeight(line1) + 2;
+			_surface.writeFancyString(line2, Common::Point(xp, yp), BLACK, INFO_TOP);
+		}
+
+		// Set the initial display position for the tooltip text
+		int tagX = mousePos.x - width / 2;
+		int tagY = mousePos.y - height - _offsetY;
+
+		_bounds = Common::Rect(tagX, tagY, tagX + width, tagY + height);
+	} else {
+		reset = true;
+	}
+
+	if (reset && !_surface.empty()) {
+		_surface.free();
+	}
+}
+
+void WidgetTooltip::handleEvents() {
+	Events &events = *_vm->_events;
+	Common::Point mousePos = events.mousePos();
+
+	// Set the new position for the tooltip
+	int xp = mousePos.x - _bounds.width() / 2;
+	int yp = mousePos.y - _bounds.height() - _offsetY;
+
+	_bounds.moveTo(xp, yp);
+}
+
+/*----------------------------------------------------------------*/
+
+void WidgetSceneTooltip::handleEvents() {
+	Events &events = *_vm->_events;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+
+	// See if thay are pointing at a different object and we need to regenerate the tooltip text
+	if (ui._bgFound != ui._oldBgFound || (ui._bgFound != -1 && _surface.empty()) ||
+			ui._arrowZone != ui._oldArrowZone || (ui._arrowZone != -1 && _surface.empty())) {
+		// See if there is a new object to display text for
+		if ((ui._bgFound != -1 && (ui._bgFound != ui._oldBgFound || (ui._bgFound != -1 && _surface.empty()))) ||
+				(ui._arrowZone != -1 && (ui._arrowZone != ui._oldArrowZone || (ui._arrowZone != -1 && _surface.empty())))) {
+			Common::String str;
+			if (ui._bgFound != -1) {
+				// Clear the Arrow Zone fields so it won't think we're displaying an Arrow Zone cursor
+				if (scene._currentScene != OVERHEAD_MAP2)
+					ui._arrowZone = ui._oldArrowZone = -1;
+
+				// Get the description string
+				str = (ui._bgFound < 1000) ? scene._bgShapes[ui._bgFound]._description :
+					people[ui._bgFound - 1000]._description;
+
+				// WORKAORUND: On the train ride to Cambridge, don't show any tooltips
+				if (scene._currentScene == TRAIN_RIDE)
+					str = "";
+			} else {
+				// Get the exit zone description
+				str = scene._exits[ui._arrowZone]._dest;
+			}
+
+			setText(str.hasPrefix(" ") ? Common::String() : str);			
+		} else if ((ui._bgFound == -1 && ui._oldBgFound != -1) || (ui._arrowZone == -1 && ui._oldArrowZone != -1)) {
+			setText("");
+		}
+
+		ui._oldBgFound = ui._bgFound;
+	} else {
+		// Set the new position for the tooltip
+		int tagX = CLIP(mousePos.x - _bounds.width() / 2, 0, SHERLOCK_SCREEN_WIDTH - _bounds.width());
+		int tagY = MAX(mousePos.y - _bounds.height() - _offsetY, 0);
+		_bounds.moveTo(tagX, tagY);
+	}
+
+	ui._oldArrowZone = ui._arrowZone;
+
+	WidgetTooltip::handleEvents();
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_tooltip.h b/engines/sherlock/tattoo/widget_tooltip.h
new file mode 100644
index 0000000000..87f5d54f0a
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_tooltip.h
@@ -0,0 +1,89 @@
+/* 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 SHERLOCK_TATTOO_WIDGET_TOOLTIP_H
+#define SHERLOCK_TATTOO_WIDGET_TOOLTIP_H
+
+#include "common/scummsys.h"
+#include "common/rect.h"
+#include "sherlock/tattoo/widget_base.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+class WidgetTooltipBase : public WidgetBase {
+public:
+	WidgetTooltipBase(SherlockEngine *vm) : WidgetBase(vm) {}
+	virtual ~WidgetTooltipBase() {}
+
+	/**
+	 * Erase any previous display of the widget on the screen
+	 */
+	virtual void erase();
+
+	/**
+	 * Update the display of the widget on the screen
+	 */
+	virtual void draw();
+};
+
+class WidgetTooltip: public WidgetTooltipBase {
+public:
+	int _offsetY;
+public:
+	WidgetTooltip(SherlockEngine *vm);
+	virtual ~WidgetTooltip() {}
+
+	/**
+	 * Set the text for the tooltip
+	 */
+	void setText(const Common::String &str);
+
+	/**
+	 * Handle updating the tooltip state
+	 */
+	virtual void handleEvents();
+};
+
+class WidgetSceneTooltip : public WidgetTooltip {
+public:
+	WidgetSceneTooltip(SherlockEngine *vm) : WidgetTooltip(vm) {}
+
+	/**
+	 * Handle updating the tooltip state
+	 */
+	virtual void handleEvents();
+};
+
+class WidgetMapTooltip : public WidgetTooltip {
+public:
+	WidgetMapTooltip(SherlockEngine *vm) : WidgetTooltip(vm) {}
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/tattoo/widget_verbs.cpp b/engines/sherlock/tattoo/widget_verbs.cpp
new file mode 100644
index 0000000000..499afb2e79
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_verbs.cpp
@@ -0,0 +1,313 @@
+/* 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 "sherlock/tattoo/widget_verbs.h"
+#include "sherlock/tattoo/tattoo_fixed_text.h"
+#include "sherlock/tattoo/tattoo_scene.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+#include "sherlock/tattoo/tattoo_people.h"
+#include "sherlock/tattoo/tattoo.h"
+
+namespace Sherlock {
+
+namespace Tattoo {
+
+WidgetVerbs::WidgetVerbs(SherlockEngine *vm) : WidgetBase(vm) {
+	_selector = _oldSelector = -1;
+	_outsideMenu = false;
+}
+
+void WidgetVerbs::load(bool objectsOn) {
+	Events &events = *_vm->_events;
+	TattooPeople &people = *(TattooPeople *)_vm->_people;
+	Talk &talk = *_vm->_talk;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+	bool isWatson = false;
+
+	if (talk._talkToAbort)
+		return;
+
+	ui._activeObj = ui._bgFound;
+	_outsideMenu = false;
+	_verbCommands.clear();
+	_selector = _oldSelector = -1;
+
+	// Check if we need to show options for the highlighted object
+	if (objectsOn) {
+		// Set the verb list accordingly, depending on the target being a
+		// person or an object
+		if (ui._personFound) {
+			TattooPerson &person = people[ui._activeObj - 1000];
+
+			if (!scumm_strnicmp(person._npcName.c_str(), "WATS", 4))
+				isWatson = true;
+
+
+			if (scumm_strnicmp(person._examine.c_str(), "_EXIT", 5))
+				_verbCommands.push_back(FIXED(Look));
+			
+			_verbCommands.push_back(FIXED(Talk));
+
+			// Add any extra active verbs from the NPC's verb list
+			for (int idx = 0; idx < 2; ++idx) {
+				if (!person._use[idx]._verb.empty() && !person._use[idx]._verb.hasPrefix(" ") &&
+						(person._use[idx]._target.empty() || person._use[idx]._target.hasPrefix(" "))) {
+					_verbCommands.push_back(person._use[idx]._verb);
+				}
+			}
+		} else {
+			if (!scumm_strnicmp(ui._bgShape->_name.c_str(), "WATS", 4))
+				// Looking at Watson
+				isWatson = true;
+
+			if (scumm_strnicmp(ui._bgShape->_examine.c_str(), "_EXIT", 5))
+				// It's not an exit, so include Look as an option
+				_verbCommands.push_back(FIXED(Look));
+
+			if (ui._bgShape->_aType == PERSON)
+				_verbCommands.push_back(FIXED(Talk));
+
+			// Add any extra active verbs from the object's verb list
+			for (int idx = 0; idx < 6; ++idx) {
+				UseType &use = ui._bgShape->_use[idx];
+				if (!use._verb.empty() && !use._verb.hasPrefix(" ") && !use._verb.hasPrefix("*") &&
+					(use._target.empty() || use._target.hasPrefix("*") || use._target.hasPrefix(" "))) {
+					_verbCommands.push_back(use._verb);
+				}
+			}
+		}
+	}
+
+	// If clicked on Watson, have Journal as an option
+	if (isWatson)
+		_verbCommands.push_back(FIXED(Journal));
+
+	// Add the system commands
+	_verbCommands.push_back(FIXED(Inventory));
+	_verbCommands.push_back(FIXED(Options));
+
+	// Figure out the needed width to show the commands
+	int width = 0;
+	for (uint idx = 0; idx < _verbCommands.size(); ++idx)
+		width = MAX(width, _surface.stringWidth(_verbCommands[idx]));
+	width += _surface.widestChar() * 2 + 6;
+	int height = (_surface.fontHeight() + 7) * _verbCommands.size() + 3;
+
+	// Set the bounds
+	_bounds = Common::Rect(width, height);
+	_bounds.moveTo(mousePos.x - _bounds.width() / 2, mousePos.y - _bounds.height() / 2);
+	
+	// Render the window on the internal surface
+	render();
+}
+
+void WidgetVerbs::render() {
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	ImageFile &images = *ui._interfaceImages;
+
+	// Create the drawing surface
+	_surface.create(_bounds.width(), _bounds.height());
+	_surface.fill(TRANSPARENCY);
+
+	// Draw basic background
+	makeInfoArea();
+
+	// Draw the verb commands and the lines separating them
+	for (uint idx = 0; idx < _verbCommands.size(); ++idx) {
+		_surface.writeString(_verbCommands[idx], Common::Point((_bounds.width() - _surface.stringWidth(_verbCommands[idx])) / 2, 
+			(_surface.fontHeight() + 7) * idx + 5), INFO_TOP);
+
+		if (idx < (_verbCommands.size() - 1)) {
+			_surface.hLine(3, (_surface.fontHeight() + 7) * (idx + 1), _bounds.width() - 4, INFO_TOP);
+			_surface.hLine(3, (_surface.fontHeight() + 7) * (idx + 1) + 1, _bounds.width() - 4, INFO_MIDDLE);
+			_surface.hLine(3, (_surface.fontHeight() + 7) * (idx + 1) + 2, _bounds.width() - 4, INFO_BOTTOM);
+
+			_surface.transBlitFrom(images[4], Common::Point(0, (_surface.fontHeight() + 7) * (idx + 1) - 1));
+			_surface.transBlitFrom(images[5], Common::Point(_bounds.width() - images[5]._width, 
+				(_surface.fontHeight() + 7) * (idx + 1) - 1));
+		}
+	}
+}
+
+void WidgetVerbs::handleEvents() {
+	Events &events = *_vm->_events;
+	FixedText &fixedText = *_vm->_fixedText;
+	People &people = *_vm->_people;
+	TattooScene &scene = *(TattooScene *)_vm->_scene;
+	Talk &talk = *_vm->_talk;
+	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
+	Common::Point mousePos = events.mousePos();
+
+	Common::String strLook = fixedText.getText(kFixedText_Look);
+	Common::String strTalk = fixedText.getText(kFixedText_Talk);
+	Common::String strJournal = fixedText.getText(kFixedText_Journal);
+
+	checkTabbingKeys(_verbCommands.size());
+
+	// Highlight verb display as necessary
+	highlightVerbControls();
+
+	// Flag if the user has started pressing the button with the cursor outsie the menu
+	if (events._firstPress && !_bounds.contains(mousePos))
+		_outsideMenu = true;
+
+	// See if they released the mouse button
+	if (events._released || events._rightReleased) {
+		// See if they want to close the menu (they clicked outside of the menu)
+		if (!_bounds.contains(mousePos)) {
+			if (_outsideMenu) {
+				if (events._rightReleased) {
+					// Change to the item (if any) that was right-clicked on, and re-draw the verb menu
+					ui._bgFound = scene.findBgShape(mousePos);
+					ui._personFound = ui._bgFound >= 1000;
+					ui._bgShape = ui._personFound || ui._bgFound == -1 ? nullptr : &scene._bgShapes[ui._bgFound];
+
+					bool noDesc = false;
+					if (ui._personFound) {
+						if (people[ui._bgFound - 1000]._description.empty() || people[ui._bgFound - 1000]._description.hasPrefix(" "))
+							noDesc = true;
+					} else if (ui._bgFound != -1) {
+						if (ui._bgShape->_description.empty() || ui._bgShape->_description.hasPrefix(" "))
+							noDesc = true;
+					} else {
+						noDesc = true;
+					}
+
+					// Call the Routine to turn on the Commands for this Object
+					load(!noDesc);
+				} else {
+					// Close the window and clear the events
+					banishWindow();
+					events.clearEvents();
+
+					// Reset the active UI mode
+					ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+				}
+			}
+		} else if (_bounds.contains(mousePos) && _selector != -1) {
+			// Mouse is within the menu
+			// Erase the menu
+			banishWindow();
+			events.clearEvents();
+
+			// See if they are activating the Look Command
+			if (!_verbCommands[_selector].compareToIgnoreCase(strLook)) {
+				ui._bgFound = ui._activeObj;
+				if (ui._activeObj >= 1000) {
+					ui._personFound = true;
+				} else {
+					ui._personFound = false;
+					ui._bgShape = &scene._bgShapes[ui._activeObj];
+				}
+
+				ui.lookAtObject();
+
+			} else if (!_verbCommands[_selector].compareToIgnoreCase(strTalk)) {
+				// Talk command is being activated
+				talk.initTalk(ui._activeObj);
+				ui._activeObj = -1;
+			
+			} else if (!_verbCommands[_selector].compareToIgnoreCase(strJournal)) {
+				ui.doJournal();
+
+				// See if we're in a Lab Table scene
+				ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+			} else if (_selector >= ((int)_verbCommands.size() - 2)) {
+				switch (_selector - (int)_verbCommands.size() + 2) {
+				case 0:
+					// Inventory
+					ui.doInventory(2);
+					break;
+
+				case 1:
+					// Options
+					ui.doControls();
+					break;
+
+				default:
+					ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+					break;
+				}
+			} else {
+				// If they have selected anything else, process it
+				people[HOLMES].gotoStand();
+
+				if (ui._activeObj < 1000) {
+					for (int idx = 0; idx < 6; ++idx) {
+						if (!_verbCommands[_selector].compareToIgnoreCase(scene._bgShapes[ui._activeObj]._use[idx]._verb)) {
+							// See if they are Picking this object up
+							if (!scene._bgShapes[ui._activeObj]._use[idx]._target.compareToIgnoreCase("*PICKUP"))
+								ui.pickUpObject(ui._activeObj);
+							else
+								ui.checkAction(scene._bgShapes[ui._activeObj]._use[idx], ui._activeObj);
+						}
+					}
+				} else {
+					for (int idx = 0; idx < 2; ++idx) {
+						if (!_verbCommands[_selector].compareToIgnoreCase(people[ui._activeObj - 1000]._use[idx]._verb))
+							ui.checkAction(people[ui._activeObj - 1000]._use[idx], ui._activeObj);
+					}
+				}
+
+				ui._activeObj = -1;
+				if (ui._menuMode != MESSAGE_MODE) {
+					// See if we're in a Lab Table Room
+					ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+				}
+			}
+		}
+	} else if (ui._keyState.keycode == Common::KEYCODE_ESCAPE) {
+		// User closing the menu with the ESC key
+		banishWindow();
+		ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
+	}
+}
+
+void WidgetVerbs::highlightVerbControls() {
+	Events &events = *_vm->_events;
+	Screen &screen = *_vm->_screen;
+	Common::Point mousePos = events.mousePos();
+
+	// Get highlighted verb
+	_selector = -1;
+	Common::Rect bounds = _bounds;
+	bounds.grow(-3);
+	if (bounds.contains(mousePos))
+		_selector = (mousePos.y - bounds.top) / (screen.fontHeight() + 7);
+
+	// See if a new verb is being pointed at
+	if (_selector != _oldSelector) {
+		// Redraw the verb list
+		for (int idx = 0; idx < (int)_verbCommands.size(); ++idx) {
+			byte color = (idx == _selector) ? (byte)COMMAND_HIGHLIGHTED : (byte)INFO_TOP;
+			_surface.writeString(_verbCommands[idx], Common::Point((_bounds.width() - screen.stringWidth(_verbCommands[idx])) / 2,
+				(screen.fontHeight() + 7) * idx + 5), color);
+		}
+
+		_oldSelector = _selector;
+	}
+}
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/tattoo/widget_verbs.h b/engines/sherlock/tattoo/widget_verbs.h
new file mode 100644
index 0000000000..ce67842409
--- /dev/null
+++ b/engines/sherlock/tattoo/widget_verbs.h
@@ -0,0 +1,72 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef SHERLOCK_TATTOO_WIDGET_VERBS_H
+#define SHERLOCK_TATTOO_WIDGET_VERBS_H
+
+#include "common/scummsys.h"
+#include "common/rect.h"
+#include "common/str-array.h"
+#include "sherlock/tattoo/widget_base.h"
+
+namespace Sherlock {
+
+class SherlockEngine;
+
+namespace Tattoo {
+
+class WidgetVerbs: public WidgetBase {
+private:
+	int _selector, _oldSelector;
+	bool _outsideMenu;
+
+	/**
+	 * Highlights the controls for the verb list
+	 */
+	void highlightVerbControls();
+
+	/**
+	 * Renders the window on an internal surface for later drawing on-screen
+	 */
+	void render();
+public:
+	Common::StringArray _verbCommands;
+public:
+	WidgetVerbs(SherlockEngine *vm);
+	virtual ~WidgetVerbs() {}
+
+	/**
+	 * Turns on the menu with all the verbs that are available for the given object
+	 */
+	void load(bool objectsOn);
+
+	/**
+	 * Process input for the dialog
+	 */
+	virtual void handleEvents();
+};
+
+} // End of namespace Tattoo
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sherlock/user_interface.cpp b/engines/sherlock/user_interface.cpp
new file mode 100644
index 0000000000..bb0667d66a
--- /dev/null
+++ b/engines/sherlock/user_interface.cpp
@@ -0,0 +1,209 @@
+/* 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 "sherlock/user_interface.h"
+#include "sherlock/scalpel/scalpel.h"
+#include "sherlock/scalpel/scalpel_user_interface.h"
+#include "sherlock/tattoo/tattoo.h"
+#include "sherlock/tattoo/tattoo_user_interface.h"
+
+namespace Sherlock {
+
+UserInterface *UserInterface::init(SherlockEngine *vm) {
+	if (vm->getGameID() == GType_SerratedScalpel)
+		return new Scalpel::ScalpelUserInterface(vm);
+	else
+		return new Tattoo::TattooUserInterface(vm);
+}
+
+UserInterface::UserInterface(SherlockEngine *vm) : _vm(vm) {
+	_menuMode = STD_MODE;
+	_menuCounter = 0;
+	_infoFlag = false;
+	_windowOpen = false;
+	_endKeyActive = true;
+	_invLookFlag = 0;
+	_slideWindows = true;
+	_helpStyle = false;
+	_windowBounds = Common::Rect(0, CONTROLS_Y1, SHERLOCK_SCREEN_WIDTH - 1, SHERLOCK_SCREEN_HEIGHT - 1);
+	_lookScriptFlag = false;
+	_exitZone = -1;
+
+	_bgFound = _oldBgFound = -1;
+	_key = _oldKey = '\0';
+	_selector = _oldSelector = -1;
+	_temp = _oldTemp = 0;
+	_temp1 = 0;
+	_lookHelp = 0;
+}
+
+void UserInterface::checkAction(ActionType &action, int objNum, FixedTextActionId fixedTextActionId) {
+	Events &events = *_vm->_events;
+	FixedText &fixedText = *_vm->_fixedText;
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	Screen &screen = *_vm->_screen;
+	Talk &talk = *_vm->_talk;
+	Point32 pt(-1, -1);
+
+	if (action._useFlag)
+		// Automatically set the given flag
+		_vm->setFlags(action._useFlag);
+
+	if (IS_SERRATED_SCALPEL && objNum >= 1000)
+		// Ignore actions done on characters
+		return;
+
+	if (IS_SERRATED_SCALPEL && !action._cAnimSpeed) {
+		// Invalid action, to print error message
+		_infoFlag = true;
+		clearInfo();
+		Common::String errorMessage = fixedText.getActionMessage(fixedTextActionId, action._cAnimNum);
+		screen.print(Common::Point(0, INFO_LINE + 1), COL_INFO_FOREGROUND, "%s", errorMessage.c_str());
+		_infoFlag = true;
+
+		// Set how long to show the message
+		_menuCounter = 30;
+	} else {
+		BaseObject *obj;
+		if (objNum >= 1000)
+			obj = &people[objNum - 1000];
+		else
+			obj = &scene._bgShapes[objNum];
+
+		int cAnimNum;
+		if (action._cAnimNum == 0)
+			// Really a 10
+			cAnimNum = 9;
+		else
+			cAnimNum = action._cAnimNum - 1;
+
+		int dir = -1;
+		if (action._cAnimNum != 99) {
+			CAnim &anim = scene._cAnim[cAnimNum];
+
+			if (action._cAnimNum != 99) {
+				if (action._cAnimSpeed & REVERSE_DIRECTION) {
+					pt = anim._teleport[0];
+					dir = anim._teleport[0]._facing;
+				} else {
+					pt = anim._goto[0];
+					dir = anim._goto[0]._facing;
+				}
+			}
+		} else {
+			pt = Point32(-1, -1);
+			dir = -1;
+		}
+
+		// Has a value, so do action
+		// Show wait cursor whilst walking to object and doing action
+		events.setCursor(WAIT);
+		bool printed = false;
+
+		for (int nameIdx = 0; nameIdx < NAMES_COUNT; ++nameIdx) {
+			if (action._names[nameIdx].hasPrefix("*") && action._names[nameIdx].size() >= 2
+					&& toupper(action._names[nameIdx][1]) == 'W') {
+				if (obj->checkNameForCodes(Common::String(action._names[nameIdx].c_str() + 2), fixedTextActionId)) {
+					if (!talk._talkToAbort)
+						printed = true;
+				}
+			}
+		}
+
+		bool doCAnim = true;
+		for (int nameIdx = 0; nameIdx < NAMES_COUNT; ++nameIdx) {
+			if (action._names[nameIdx].hasPrefix("*") && action._names[nameIdx].size() >= 2) {
+				char ch = toupper(action._names[nameIdx][1]);
+
+				if (ch == 'T' || ch == 'B') {
+					printed = true;
+					if (pt.x != -1)
+						// Holmes needs to walk to object before the action is done
+						people[HOLMES].walkToCoords(pt, dir);
+
+					if (!talk._talkToAbort) {
+						// Ensure Holmes is on the exact intended location
+						people[HOLMES]._position = pt;
+						people[HOLMES]._sequenceNumber = dir;
+						people[HOLMES].gotoStand();
+
+						talk.talkTo(action._names[nameIdx].c_str() + 2);
+						if (ch == 'T')
+							doCAnim = false;
+					}
+				}
+			}
+		}
+
+		if (doCAnim && !talk._talkToAbort) {
+			if (pt.x != -1)
+				// Holmes needs to walk to object before the action is done
+				people[HOLMES].walkToCoords(pt, dir);
+		}
+
+		for (int nameIdx = 0; nameIdx < NAMES_COUNT; ++nameIdx) {
+			if (action._names[nameIdx].hasPrefix("*") && action._names[nameIdx].size() >= 2
+					&& toupper(action._names[nameIdx][1]) == 'F') {
+				if (obj->checkNameForCodes(action._names[nameIdx].c_str() + 2, fixedTextActionId)) {
+					if (!talk._talkToAbort)
+						printed = true;
+				}
+			}
+		}
+
+		if (doCAnim && !talk._talkToAbort && action._cAnimNum != 99)
+			scene.startCAnim(cAnimNum, action._cAnimSpeed);
+
+		if (!talk._talkToAbort) {
+			for (int nameIdx = 0; nameIdx < NAMES_COUNT && !talk._talkToAbort; ++nameIdx) {
+				if (obj->checkNameForCodes(action._names[nameIdx], fixedTextActionId)) {
+					if (!talk._talkToAbort)
+						printed = true;
+				}
+			}
+
+			// Unless we're leaving the scene, print a "Done" message unless the printed flag has been set
+			if (IS_SERRATED_SCALPEL && scene._goToScene != 1 && !printed && !talk._talkToAbort) {
+				_infoFlag = true;
+				clearInfo();
+				screen.print(Common::Point(0, INFO_LINE + 1), COL_INFO_FOREGROUND, "Done...");
+
+				// Set how long to show the message
+				_menuCounter = 30;
+			}
+		}
+	}
+
+	// Reset cursor back to arrow
+	events.setCursor(ARROW);
+}
+
+void UserInterface::reset() {
+	_bgFound = _oldBgFound = -1;
+	_oldKey = -1;
+	_oldTemp = _temp = -1;
+	_exitZone = -1;
+}
+
+
+} // End of namespace Sherlock
diff --git a/engines/sherlock/user_interface.h b/engines/sherlock/user_interface.h
new file mode 100644
index 0000000000..c16c9f5d11
--- /dev/null
+++ b/engines/sherlock/user_interface.h
@@ -0,0 +1,142 @@
+/* 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 SHERLOCK_UI_H
+#define SHERLOCK_UI_H
+
+#include "common/scummsys.h"
+#include "common/events.h"
+#include "sherlock/surface.h"
+#include "sherlock/objects.h"
+#include "sherlock/resources.h"
+#include "sherlock/fixed_text.h"
+
+namespace Sherlock {
+
+#define CONTROLS_Y  138
+#define CONTROLS_Y1 151
+
+enum MenuMode {
+	STD_MODE		=  0,
+	LOOK_MODE		=  1,
+	MOVE_MODE		=  2,
+	TALK_MODE		=  3,
+	PICKUP_MODE		=  4,
+	OPEN_MODE		=  5,
+	CLOSE_MODE		=  6,
+	INV_MODE		=  7,
+	USE_MODE		=  8,
+	GIVE_MODE		=  9,
+	JOURNAL_MODE	= 10,
+	FILES_MODE		= 11,
+	SETUP_MODE		= 12,
+
+	// Rose Tattoo specific
+	LAB_MODE		= 20,
+	MESSAGE_MODE	= 21,
+	VERB_MODE		= 22,
+	OPTION_MODE		= 23,
+	QUIT_MODE		= 24,
+	FOOLSCAP_MODE	= 25,
+	PASSWORD_MODE	= 26
+};
+
+class UserInterface {
+protected:
+	SherlockEngine *_vm;
+
+	UserInterface(SherlockEngine *vm);
+public:
+	MenuMode _menuMode;
+	int _menuCounter;
+	bool _infoFlag;
+	bool _windowOpen;
+	bool _endKeyActive;
+	int _invLookFlag;
+	bool _slideWindows;
+	bool _helpStyle;
+	Common::Rect _windowBounds;
+	bool _lookScriptFlag;
+	int _bgFound, _oldBgFound;
+	int _exitZone;
+
+	// TODO: Not so sure these should be in the base class. May want to refactor them to SherlockEngine, or refactor
+	// various Scalpel dialogs to keep their own private state of key/selections
+	signed char _key, _oldKey;
+	int _selector, _oldSelector;
+	int _temp, _oldTemp;
+	int _temp1;
+	int _lookHelp;
+public:
+	static UserInterface *init(SherlockEngine *vm);
+	virtual ~UserInterface() {}
+
+	/**
+	 * Called for OPEN, CLOSE, and MOVE actions are being done
+	 */
+	void checkAction(ActionType &action, int objNum, FixedTextActionId fixedTextActionId = kFixedTextAction_Invalid);
+public:
+	/**
+	 * Resets the user interface
+	 */
+	virtual void reset();
+
+	/**
+	 * Draw the user interface onto the screen's back buffers
+	 */	
+	virtual void drawInterface(int bufferNum = 3) {}
+
+	/**
+	 * Main input handler for the user interface
+	 */
+	virtual void handleInput() {}
+
+	/**
+	 * Displays a passed window by gradually scrolling it vertically on-screen
+	 */
+	virtual void summonWindow(const Surface &bgSurface, bool slideUp = true) {}
+
+	/**
+	 * Slide the window stored in the back buffer onto the screen
+	 */
+	virtual void summonWindow(bool slideUp = true, int height = CONTROLS_Y) {}
+
+	/**
+	 * Close a currently open window
+	 * @param flag	0 = slide old window down, 1 = slide prior UI back up
+	 */
+	virtual void banishWindow(bool slideUp = true) {}
+
+	/**
+	 * Clears the info line of the screen
+	 */
+	virtual void clearInfo() {}
+
+	/**
+	 * Clear any active text window
+	 */
+	virtual void clearWindow() {}
+};
+
+} // End of namespace Sherlock
+
+#endif
diff --git a/engines/sky/music/adlibchannel.cpp b/engines/sky/music/adlibchannel.cpp
index 8400fef6eb..c7acb9b6c1 100644
--- a/engines/sky/music/adlibchannel.cpp
+++ b/engines/sky/music/adlibchannel.cpp
@@ -29,7 +29,7 @@
 
 namespace Sky {
 
-AdLibChannel::AdLibChannel(FM_OPL *opl, uint8 *pMusicData, uint16 startOfData) {
+AdLibChannel::AdLibChannel(OPL::OPL *opl, uint8 *pMusicData, uint16 startOfData) {
 	_opl = opl;
 	_musicData = pMusicData;
 	_channelData.loopPoint = startOfData;
@@ -45,6 +45,8 @@ AdLibChannel::AdLibChannel(FM_OPL *opl, uint8 *pMusicData, uint16 startOfData) {
 	_channelData.frequency = 0;
 	_channelData.instrumentData = NULL;
 
+	_musicVolume = 128;
+
 	uint16 instrumentDataLoc;
 
 	if (SkyEngine::_systemVars.gameVersion == 109) {
@@ -86,7 +88,7 @@ bool AdLibChannel::isActive() {
 }
 
 void AdLibChannel::updateVolume(uint16 pVolume) {
-	// Do nothing. The mixer handles the music volume for us.
+	_musicVolume = pVolume;
 }
 
 /*	This class uses the same area for the register mirror as the original
@@ -95,7 +97,7 @@ void AdLibChannel::updateVolume(uint16 pVolume) {
 */
 void AdLibChannel::setRegister(uint8 regNum, uint8 value) {
 	if (_adlibRegMirror[regNum] != value) {
-		OPLWriteReg (_opl, regNum, value);
+		_opl->writeReg(regNum, value);
 		_adlibRegMirror[regNum] = value;
 	}
 }
@@ -208,6 +210,8 @@ void AdLibChannel::setupChannelVolume(uint8 volume) {
 	uint32 resVol = ((volume + 1) * (_channelData.instrumentData->totOutLev_Op2 + 1)) << 1;
 	resVol &= 0xFFFF;
 	resVol *= (_channelData.channelVolume + 1) << 1;
+	resVol >>= 8;
+	resVol *= _musicVolume << 1;
 	resVol >>= 16;
 	assert(resVol < 0x81);
 	resultOp = ((_channelData.instrumentData->scalingLevel << 6) & 0xC0) | _opOutputTable[resVol];
@@ -216,6 +220,8 @@ void AdLibChannel::setupChannelVolume(uint8 volume) {
 		resVol = ((volume + 1) * (_channelData.instrumentData->totOutLev_Op1 + 1)) << 1;
 		resVol &= 0xFFFF;
 		resVol *= (_channelData.channelVolume + 1) << 1;
+		resVol >>= 8;
+		resVol *= _musicVolume << 1;
 		resVol >>= 16;
 	} else
 		resVol = _channelData.instrumentData->totOutLev_Op1;
diff --git a/engines/sky/music/adlibchannel.h b/engines/sky/music/adlibchannel.h
index 80dae93b2c..4504e3b570 100644
--- a/engines/sky/music/adlibchannel.h
+++ b/engines/sky/music/adlibchannel.h
@@ -60,14 +60,15 @@ typedef struct {
 
 class AdLibChannel : public ChannelBase {
 public:
-	AdLibChannel (FM_OPL *opl, uint8 *pMusicData, uint16 startOfData);
+	AdLibChannel (OPL::OPL *opl, uint8 *pMusicData, uint16 startOfData);
 	virtual ~AdLibChannel();
 	virtual uint8 process(uint16 aktTime);
 	virtual void updateVolume(uint16 pVolume);
 	virtual bool isActive();
 private:
-	FM_OPL *_opl;
+	OPL::OPL *_opl;
 	uint8 *_musicData;
+	uint16 _musicVolume;
 	AdLibChannelType _channelData;
 
 	InstrumentStruct *_instruments;
diff --git a/engines/sky/music/adlibmusic.cpp b/engines/sky/music/adlibmusic.cpp
index dd64c5bc81..be5e7b2353 100644
--- a/engines/sky/music/adlibmusic.cpp
+++ b/engines/sky/music/adlibmusic.cpp
@@ -22,6 +22,7 @@
 
 
 #include "common/endian.h"
+#include "common/textconsole.h"
 
 #include "sky/music/adlibmusic.h"
 #include "sky/music/adlibchannel.h"
@@ -32,44 +33,21 @@ namespace Sky {
 
 AdLibMusic::AdLibMusic(Audio::Mixer *pMixer, Disk *pDisk) : MusicBase(pMixer, pDisk) {
 	_driverFileBase = 60202;
-	_sampleRate = pMixer->getOutputRate();
 
-	_opl = makeAdLibOPL(_sampleRate);
+	_opl = OPL::Config::create();
+	if (!_opl || !_opl->init())
+		error("Failed to create OPL");
 
-	_mixer->playStream(Audio::Mixer::kMusicSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
+	_opl->start(new Common::Functor0Mem<void, AdLibMusic>(this, &AdLibMusic::onTimer), 50);
 }
 
 AdLibMusic::~AdLibMusic() {
-	OPLDestroy(_opl);
-	_mixer->stopHandle(_soundHandle);
+	delete _opl;
 }
 
-int AdLibMusic::readBuffer(int16 *data, const int numSamples) {
-	if (_musicData == NULL) {
-		// no music loaded
-		memset(data, 0, numSamples * sizeof(int16));
-	} else if ((_currentMusic == 0) || (_numberOfChannels == 0)) {
-		// music loaded but not played as of yet
-		memset(data, 0, numSamples * sizeof(int16));
-		// poll anyways as pollMusic() can activate the music
+void AdLibMusic::onTimer() {
+	if (_musicData != NULL)
 		pollMusic();
-		_nextMusicPoll = _sampleRate / 50;
-	} else {
-		uint32 render;
-		uint remaining = numSamples;
-		while (remaining) {
-			render = (remaining > _nextMusicPoll) ? _nextMusicPoll : remaining;
-			remaining -= render;
-			_nextMusicPoll -= render;
-			YM3812UpdateOne(_opl, data, render);
-			data += render;
-			if (_nextMusicPoll == 0) {
-				pollMusic();
-				_nextMusicPoll = _sampleRate / 50;
-			}
-		}
-	}
-	return numSamples;
 }
 
 void AdLibMusic::setupPointers() {
@@ -87,7 +65,6 @@ void AdLibMusic::setupPointers() {
 		_musicDataLoc = READ_LE_UINT16(_musicData + 0x1201);
 		_initSequence = _musicData + 0xE91;
 	}
-	_nextMusicPoll = 0;
 }
 
 void AdLibMusic::setupChannels(uint8 *channelData) {
@@ -102,26 +79,15 @@ void AdLibMusic::setupChannels(uint8 *channelData) {
 void AdLibMusic::startDriver() {
 	uint16 cnt = 0;
 	while (_initSequence[cnt] || _initSequence[cnt + 1]) {
-		OPLWriteReg (_opl, _initSequence[cnt], _initSequence[cnt + 1]);
+		_opl->writeReg(_initSequence[cnt], _initSequence[cnt + 1]);
 		cnt += 2;
 	}
 }
 
 void AdLibMusic::setVolume(uint16 param) {
 	_musicVolume = param;
-	_mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, 2 * param);
-}
-
-bool AdLibMusic::isStereo() const {
-	return false;
-}
-
-bool AdLibMusic::endOfData() const {
-	return false;
-}
-
-int AdLibMusic::getRate() const {
-	return _sampleRate;
+	for (uint8 cnt = 0; cnt < _numberOfChannels; cnt++)
+		_channels[cnt]->updateVolume(_musicVolume);
 }
 
 } // End of namespace Sky
diff --git a/engines/sky/music/adlibmusic.h b/engines/sky/music/adlibmusic.h
index 886eef026e..7b51f2d3a0 100644
--- a/engines/sky/music/adlibmusic.h
+++ b/engines/sky/music/adlibmusic.h
@@ -25,32 +25,32 @@
 
 #include "sky/music/musicbase.h"
 #include "audio/audiostream.h"
-#include "audio/fmopl.h"
+
+namespace OPL {
+class OPL;
+}
 
 namespace Sky {
 
-class AdLibMusic : public Audio::AudioStream, public MusicBase {
+class AdLibMusic : public MusicBase {
 public:
 	AdLibMusic(Audio::Mixer *pMixer, Disk *pDisk);
 	~AdLibMusic();
 
 	// AudioStream API
-	int readBuffer(int16 *buffer, const int numSamples);
-	bool isStereo() const;
-	bool endOfData() const;
-	int getRate() const;
 	virtual void setVolume(uint16 param);
 
 private:
-	FM_OPL *_opl;
-	Audio::SoundHandle _soundHandle;
+	OPL::OPL *_opl;
 	uint8 *_initSequence;
-	uint32 _sampleRate, _nextMusicPoll;
+	uint32 _sampleRate;
 	virtual void setupPointers();
 	virtual void setupChannels(uint8 *channelData);
 	virtual void startDriver();
 
 	void premixerCall(int16 *buf, uint len);
+
+	void onTimer();
 };
 
 } // End of namespace Sky
diff --git a/engines/sword25/fmv/movieplayer.cpp b/engines/sword25/fmv/movieplayer.cpp
index 5d7dcf2506..eb0f0390dc 100644
--- a/engines/sword25/fmv/movieplayer.cpp
+++ b/engines/sword25/fmv/movieplayer.cpp
@@ -123,7 +123,7 @@ void MoviePlayer::update() {
 		if (_decoder.endOfVideo()) {
 			// Movie complete, so unload the movie
 			unloadMovie();
-		} else {
+		} else if (_decoder.needsUpdate()) {
 			const Graphics::Surface *s = _decoder.decodeNextFrame();
 			if (s) {
 				// Transfer the next frame
diff --git a/engines/sword25/util/double_serialization.cpp b/engines/sword25/util/double_serialization.cpp
index 73da296e40..13fa42b6be 100644
--- a/engines/sword25/util/double_serialization.cpp
+++ b/engines/sword25/util/double_serialization.cpp
@@ -33,7 +33,7 @@ SerializedDouble encodeDouble(double value) {
 	double significand = frexp(value, &exponent);
 
 	// Shift the the first part of the significand into the integer range
-	double shiftedsignificandPart = ldexp(abs(significand), 32);
+	double shiftedsignificandPart = ldexp(fabs(significand), 32);
 	uint32 significandOne = uint32(floor(shiftedsignificandPart));
 
 	// Shift the remainder of the significand into the integer range
diff --git a/engines/tinsel/music.cpp b/engines/tinsel/music.cpp
index 8a7305f63b..2a9804263a 100644
--- a/engines/tinsel/music.cpp
+++ b/engines/tinsel/music.cpp
@@ -27,6 +27,8 @@
 #include "audio/audiostream.h"
 #include "audio/mididrv.h"
 #include "audio/midiparser.h"
+// Miles Audio for Discworld 1
+#include "audio/miles.h"
 #include "audio/decoders/adpcm.h"
 
 #include "backends/audiocd/audiocd.h"
@@ -373,8 +375,81 @@ void DeleteMidiBuffer() {
 	g_midiBuffer.pDat = NULL;
 }
 
-MidiMusicPlayer::MidiMusicPlayer() {
-	MidiPlayer::createDriver();
+MidiMusicPlayer::MidiMusicPlayer(TinselEngine *vm) {
+	_driver = NULL;
+	_milesAudioMode = false;
+	bool milesAudioEnabled = false;
+
+	if (vm->getPlatform() == Common::kPlatformDOS) {
+		// Enable Miles Audio for DOS only
+		milesAudioEnabled = true;
+	}
+
+	if ((vm->getGameId() == GID_DW1) && (milesAudioEnabled)) {
+		// Discworld 1 (DOS) uses Miles Audio 3
+		// use our own Miles Audio drivers
+		// 
+		// It seems that there are multiple versions of Discworld 1
+		//
+		// Version 1:
+		// Has SAMPLE.AD for AdLib and SAMPLE.OPL for OPL-3
+		// Timbre files are inside a subdirectory of the CD called "/drivers". Main game files are in
+		// another subdirectory, which means the user has to copy those files over.
+		// Installer script copies all drivers directly to harddrive without name changes
+		//
+		// Version 2:
+		// Has FAT.OPL only (gets copied by the installer into MIDPAK.AD or MIDPAK.OPL)
+		// Timbre file is inside subdirectory "drivers" right in the main game directory.
+		// Installer copies FAT.OPL to MIDPAK.AD all the time, even when user selected AWE32
+		//
+		// Neither have timbre data for MT32
+
+		::MidiDriver::DeviceHandle dev = ::MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_GM);
+		::MusicType musicType = ::MidiDriver::getMusicType(dev);
+		Common::File fileClass;
+
+		switch (musicType) {
+		case MT_ADLIB:
+			if (fileClass.exists("FAT.OPL")) {
+				// Version 2: fat.opl, may be in drivers-subdirectory
+				_driver = Audio::MidiDriver_Miles_AdLib_create("", "FAT.OPL");
+			} else {
+				if (fileClass.exists("MIDPAK.AD")) {
+					// Version 2: drivers got installed and fat.opl got copied over by the user
+					_driver = Audio::MidiDriver_Miles_AdLib_create("MIDPAK.AD", "");
+				} else {
+					if ((fileClass.exists("SAMPLE.AD")) || (fileClass.exists("SAMPLE.OPL"))) {
+						// Version 1: sample.ad / sample.opl, have to be copied over by the user for this version
+						_driver = Audio::MidiDriver_Miles_AdLib_create("SAMPLE.AD", "SAMPLE.OPL");
+					} else {
+						error("MILES-ADLIB: timbre file not found (may be called FAT.OPL, MIDPAK.AD, SAMPLE.AD or SAMPLE.OPL, may be in a subdirectory)");
+					}
+				}
+			}
+			break;
+		case MT_MT32:
+			// Discworld 1 doesn't have a MT32 timbre file
+			_driver = Audio::MidiDriver_Miles_MT32_create("");
+			break;
+		case MT_GM:
+			if (ConfMan.getBool("native_mt32")) {
+				_driver = Audio::MidiDriver_Miles_MT32_create("");
+				musicType = MT_MT32;
+			}
+			break;
+		default:
+			break;
+		}
+		if (!_driver) {
+			// nothing got created yet? -> create default driver
+			MidiPlayer::createDriver();
+		} else {
+			_milesAudioMode = true;
+		}
+
+	} else {
+		MidiPlayer::createDriver();
+	}
 
 	int ret = _driver->open();
 	if (ret == 0) {
@@ -394,6 +469,11 @@ void MidiMusicPlayer::setVolume(int volume) {
 }
 
 void MidiMusicPlayer::send(uint32 b) {
+	if (_milesAudioMode) {
+		_driver->send(b);
+		return;
+	}
+
 	Audio::MidiPlayer::send(b);
 
 	byte channel = (byte)(b & 0x0F);
diff --git a/engines/tinsel/music.h b/engines/tinsel/music.h
index 0a78c39a76..422d80ae30 100644
--- a/engines/tinsel/music.h
+++ b/engines/tinsel/music.h
@@ -60,7 +60,7 @@ void dumpMusic();
 
 class MidiMusicPlayer : public Audio::MidiPlayer {
 public:
-	MidiMusicPlayer();
+	MidiMusicPlayer(TinselEngine *vm);
 
 	virtual void setVolume(int volume);
 
@@ -77,6 +77,8 @@ public:
 	// means. The default is 120.
 	uint32 getBaseTempo()	{ return _driver ? (109 * _driver->getBaseTempo()) / 120 : 0; }
 
+	bool _milesAudioMode;
+
 private:
 	void playXMIDI(uint32 size, bool loop);
 	void playSEQ(uint32 size, bool loop);
diff --git a/engines/tinsel/tinsel.cpp b/engines/tinsel/tinsel.cpp
index 57d8432f0e..6dc8e3bb35 100644
--- a/engines/tinsel/tinsel.cpp
+++ b/engines/tinsel/tinsel.cpp
@@ -885,12 +885,15 @@ void TinselEngine::initializePath(const Common::FSNode &gamePath) {
 	} else {
 		// Add DW2 subfolder to search path in case user is running directly from the CDs
 		SearchMan.addSubDirectoryMatching(gamePath, "dw2");
+
+		// Location of Miles audio files (sample.ad and sample.opl) in Discworld 1
+		SearchMan.addSubDirectoryMatching(gamePath, "drivers");
 		Engine::initializePath(gamePath);
 	}
 }
 
 Common::Error TinselEngine::run() {
-	_midiMusic = new MidiMusicPlayer();
+	_midiMusic = new MidiMusicPlayer(this);
 	_pcmMusic = new PCMMusicPlayer();
 	_sound = new SoundManager(this);
 	_bmv = new BMVPlayer();
diff --git a/engines/toltecs/music.cpp b/engines/toltecs/music.cpp
index e4e067de39..97d8b1aea2 100644
--- a/engines/toltecs/music.cpp
+++ b/engines/toltecs/music.cpp
@@ -21,6 +21,7 @@
  */
 
 #include "audio/midiparser.h"
+#include "audio/miles.h"
 #include "common/textconsole.h"
 
 #include "toltecs/toltecs.h"
@@ -30,20 +31,47 @@
 namespace Toltecs {
 
 MusicPlayer::MusicPlayer(bool isGM) : _isGM(isGM), _buffer(NULL) {
-	MidiPlayer::createDriver();
+	MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_MIDI | MDT_ADLIB | MDT_PREFER_GM);
+	MusicType musicType = MidiDriver::getMusicType(dev);
+
+	switch (musicType) {
+	case MT_ADLIB:
+		_milesAudioMode = true;
+		_driver = Audio::MidiDriver_Miles_AdLib_create("SAMPLE.AD", "SAMPLE.OPL");
+		break;
+	case MT_MT32:
+		// Not recommended since it sounds awful, but apparently the
+		// original sounded just as bad. I guess MT-32 support was
+		// added by default, not because anyone actually put any work
+		// into it.
+		_milesAudioMode = true;
+		_driver = Audio::MidiDriver_Miles_MT32_create("");
+		break;
+	default:
+		_milesAudioMode = false;
+		MidiPlayer::createDriver();
+		break;
+	}
 
 	int ret = _driver->open();
 	if (ret == 0) {
-		if (_nativeMT32)
-			_driver->sendMT32Reset();
-		else
-			_driver->sendGMReset();
+		if (musicType != MT_ADLIB) {
+			if (musicType == MT_MT32 || _nativeMT32)
+				_driver->sendMT32Reset();
+			else
+				_driver->sendGMReset();
+		}
 
 		_driver->setTimerCallback(this, &timerCallback);
 	}
 }
 
 void MusicPlayer::send(uint32 b) {
+	if (_milesAudioMode) {
+		_driver->send(b);
+		return;
+	}
+
 	if ((b & 0xF0) == 0xC0 && !_isGM && !_nativeMT32) {
 		b = (b & 0xFFFF00FF) | MidiDriver::_mt32ToGm[(b >> 8) & 0xFF] << 8;
 	}
diff --git a/engines/toltecs/music.h b/engines/toltecs/music.h
index e6dc3dd146..25d67e9334 100644
--- a/engines/toltecs/music.h
+++ b/engines/toltecs/music.h
@@ -47,6 +47,7 @@ protected:
 
 private:
 	byte *_buffer;
+	bool _milesAudioMode;
 };
 
 class Music : public MusicPlayer {
diff --git a/engines/tony/mpal/mpal.cpp b/engines/tony/mpal/mpal.cpp
index c813b354b0..89cc28130d 100644
--- a/engines/tony/mpal/mpal.cpp
+++ b/engines/tony/mpal/mpal.cpp
@@ -709,6 +709,10 @@ void ActionThread(CORO_PARAM, const void *param) {
 		CORO_SLEEP(1);
 	}
 
+	// WORKAROUND: User interface sometimes remaining disabled after capturing guard on Ferris wheel
+	if (_ctx->item->_nObj == 3601 && _ctx->item->_dwRes == 9)
+		g_vm->getEngine()->enableInput();
+
 	globalDestroy(_ctx->item);
 	_ctx->item = NULL;
 
diff --git a/engines/tony/window.cpp b/engines/tony/window.cpp
index 3b3687419b..d312d58091 100644
--- a/engines/tony/window.cpp
+++ b/engines/tony/window.cpp
@@ -28,7 +28,7 @@
 
 #include "common/scummsys.h"
 #include "graphics/surface.h"
-#include "util.h"
+#include "engines/util.h"
 #include "tony/window.h"
 #include "tony/game.h"
 #include "tony/tony.h"
diff --git a/engines/toon/anim.cpp b/engines/toon/anim.cpp
index ec23fea186..4788ba61a9 100644
--- a/engines/toon/anim.cpp
+++ b/engines/toon/anim.cpp
@@ -150,10 +150,12 @@ void Animation::drawFrame(Graphics::Surface &surface, int32 frame, int16 xx, int
 	if (_numFrames == 0)
 		return;
 
+	int16 dataFrame = frame;
+
 	if (_frames[frame]._ref != -1)
-		frame = _frames[frame]._ref;
+		dataFrame = _frames[frame]._ref;
 
-	if (!_frames[frame]._data)
+	if (!_frames[dataFrame]._data)
 		return;
 
 	int16 rectX = _frames[frame]._x2 - _frames[frame]._x1;
@@ -194,7 +196,7 @@ void Animation::drawFrame(Graphics::Surface &surface, int32 frame, int16 xx, int
 		return;
 
 	int32 destPitch = surface.pitch;
-	uint8 *srcRow = _frames[frame]._data + offsX + (_frames[frame]._x2 - _frames[frame]._x1) * offsY;
+	uint8 *srcRow = _frames[dataFrame]._data + offsX + (_frames[frame]._x2 - _frames[frame]._x1) * offsY;
 	uint8 *curRow = (uint8 *)surface.getBasePtr(xx + _x1 + _frames[frame]._x1 + offsX, yy + _frames[frame]._y1 + _y1 + offsY);
 	for (int16 y = 0; y < rectY; y++) {
 		uint8 *cur = curRow;
@@ -216,8 +218,12 @@ void Animation::drawFrameWithMask(Graphics::Surface &surface, int32 frame, int16
 
 void Animation::drawFrameWithMaskAndScale(Graphics::Surface &surface, int32 frame, int16 xx, int16 yy, int32 zz, Picture *mask, int32 scale) {
 	debugC(5, kDebugAnim, "drawFrameWithMaskAndScale(surface, %d, %d, %d, %d, mask, %d)", frame, xx, yy, zz, scale);
+	
+	int16 dataFrame = frame;
+
 	if (_frames[frame]._ref != -1)
-		frame = _frames[frame]._ref;
+		dataFrame = _frames[frame]._ref;
+
 	int16 rectX = _frames[frame]._x2 - _frames[frame]._x1;
 	int16 rectY = _frames[frame]._y2 - _frames[frame]._y1;
 
@@ -235,7 +241,7 @@ void Animation::drawFrameWithMaskAndScale(Graphics::Surface &surface, int32 fram
 
 	int32 destPitch = surface.pitch;
 	int32 destPitchMask = mask->getWidth();
-	uint8 *c = _frames[frame]._data;
+	uint8 *c = _frames[dataFrame]._data;
 	uint8 *curRow = (uint8 *)surface.getPixels();
 	uint8 *curRowMask = mask->getDataPtr();
 
@@ -287,9 +293,6 @@ int16 Animation::getFrameWidth(int32 frame) {
 	if ((frame < 0) || (frame >= _numFrames))
 		return 0;
 
-	if (_frames[frame]._ref != -1)
-		frame = _frames[frame]._ref;
-
 	return _frames[frame]._x2 - _frames[frame]._x1;
 }
 
@@ -298,9 +301,6 @@ int16 Animation::getFrameHeight(int32 frame) {
 	if (frame < 0 || frame >= _numFrames)
 		return 0;
 
-	if (_frames[frame]._ref != -1)
-		frame = _frames[frame]._ref;
-
 	return _frames[frame]._y2 - _frames[frame]._y1;
 }
 
@@ -323,8 +323,10 @@ void Animation::drawFontFrame(Graphics::Surface &surface, int32 frame, int16 xx,
 	if (_numFrames == 0)
 		return;
 
+	int16 dataFrame = frame;
+
 	if (_frames[frame]._ref != -1)
-		frame = _frames[frame]._ref;
+		dataFrame = _frames[frame]._ref;
 
 	int16 rectX = _frames[frame]._x2 - _frames[frame]._x1;
 	int16 rectY = _frames[frame]._y2 - _frames[frame]._y1;
@@ -345,7 +347,7 @@ void Animation::drawFontFrame(Graphics::Surface &surface, int32 frame, int16 xx,
 		return;
 
 	int32 destPitch = surface.pitch;
-	uint8 *c = _frames[frame]._data;
+	uint8 *c = _frames[dataFrame]._data;
 	uint8 *curRow = (uint8 *)surface.getBasePtr(xx + _x1 + _frames[frame]._x1, yy + _frames[frame]._y1 + _y1);
 	for (int16 y = 0; y < rectY; y++) {
 		unsigned char *cur = curRow;
diff --git a/engines/toon/character.cpp b/engines/toon/character.cpp
index 686fe99beb..3d7beeeafe 100644
--- a/engines/toon/character.cpp
+++ b/engines/toon/character.cpp
@@ -226,6 +226,11 @@ bool Character::walkTo(int16 newPosX, int16 newPosY) {
 					}
 
 					setFacing(getFacingFromDirection(smoothDx, smoothDy));
+					if (_currentWalkStamp != localWalkStamp) {
+						// another walkTo was started in setFacing, we need to cancel this one.
+						return false;
+					}
+
 					playWalkAnim(0, 0);
 				}
 
diff --git a/engines/toon/font.cpp b/engines/toon/font.cpp
index ab941e5de9..9b08e432fc 100644
--- a/engines/toon/font.cpp
+++ b/engines/toon/font.cpp
@@ -99,7 +99,7 @@ void FontRenderer::renderText(int16 x, int16 y, const Common::String &origText,
 		} else {
 			curChar = textToFont(curChar);
 			_currentFont->drawFontFrame(_vm->getMainSurface(), curChar, curX, curY, _currentFontColor);
-			curX = curX + _currentFont->getFrameWidth(curChar) - 1;
+			curX = curX + MAX<int32>(_currentFont->getFrameWidth(curChar) - 2, 0);
 			height = MAX<int32>(height, _currentFont->getFrameHeight(curChar));
 		}
 		text++;
@@ -138,8 +138,8 @@ void FontRenderer::computeSize(const Common::String &origText, int16 *retX, int1
 			// really tell how far it will stick out. For now,
 			// assume we only need to take the lower bound into
 			// consideration.
-			Common::Rect charRect = _currentFont->getFrameRect(curChar);
-			lastLineHeight = MAX(lastLineHeight, charRect.bottom);
+			//Common::Rect charRect = _currentFont->getFrameRect(curChar);
+			lastLineHeight = MAX(lastLineHeight, _currentFont->getHeight());
 		}
 		text++;
 	}
diff --git a/engines/toon/toon.cpp b/engines/toon/toon.cpp
index 2f5051c157..9e2905f454 100644
--- a/engines/toon/toon.cpp
+++ b/engines/toon/toon.cpp
@@ -210,6 +210,9 @@ void ToonEngine::parseInput() {
 			if (event.kbd.keycode == Common::KEYCODE_s && !hasModifier) {
 				_audioManager->muteSfx(!_audioManager->isSfxMuted());
 			}
+			if (event.kbd.keycode == Common::KEYCODE_F1 && !hasModifier && !_gameState->_inMenu) {
+				showOptions();
+			}
 
 			if (event.kbd.flags & Common::KBD_ALT) {
 				int slotNum = event.kbd.keycode - (event.kbd.keycode >= Common::KEYCODE_KP0 ? Common::KEYCODE_KP0 : Common::KEYCODE_0);
@@ -255,7 +258,7 @@ void ToonEngine::parseInput() {
 		}
 	}
 
-	if (!_gameState->_inConversation && !_gameState->_mouseHidden && !_gameState->_inInventory) {
+	if (!_gameState->_inConversation && !_gameState->_mouseHidden && !_gameState->_inInventory && !_gameState->_inMenu) {
 		selectHotspot();
 		clickEvent();
 	}
@@ -576,7 +579,29 @@ enum MainMenuMasks {
 	MAINMENUMASK_EVERYWHERE = 3
 };
 
-struct MainMenuFile {
+enum OptionMenuSelections {
+	OPTIONMENUHOTSPOT_NONE					= 0,
+	OPTIONMENUHOTSPOT_PLAY					= 1,
+	OPTIONMENUHOTSPOT_QUIT					= 2,
+	OPTIONMENUHOTSPOT_TEXT					= 3,
+	OPTIONMENUHOTSPOT_TEXTSPEED				= 4,
+	OPTIONMENUHOTSPOT_VOLUMESFX				= 5,
+	OPTIONMENUHOTSPOT_VOLUMESFXSLIDER		= 6,
+	OPTIONMENUHOTSPOT_VOLUMEMUSIC			= 7,
+	OPTIONMENUHOTSPOT_VOLUMEMUSICSLIDER		= 8,
+	OPTIONMENUHOTSPOT_VOLUMEVOICE			= 9,
+	OPTIONMENUHOTSPOT_VOLUMEVOICESLIDER		= 10,
+	OPTIONMENUHOTSPOT_SPEAKERBUTTON			= 11,
+	OPTIONMENUHOTSPOT_SPEAKERLEVER			= 12,
+	OPTIONMENUHOTSPOT_VIDEO_MODE			= 13
+};
+
+enum OptionMenuMasks {
+	OPTIONMENUMASK_EVERYWHERE = 1
+};
+
+
+struct MenuFile {
 	int menuMask;
 	int id;
 	const char *animationFile;
@@ -584,7 +609,7 @@ struct MainMenuFile {
 };
 
 #define MAINMENU_ENTRYCOUNT 12
-static const MainMenuFile mainMenuFiles[] = {
+static const MenuFile mainMenuFiles[] = {
 	{ MAINMENUMASK_BASE,       MAINMENUHOTSPOT_START,        "STARTBUT.CAF", 0 }, // "Start" button
 	{ MAINMENUMASK_BASE,       MAINMENUHOTSPOT_INTRO,        "INTROBUT.CAF", 0 }, // "Intro" button
 	{ MAINMENUMASK_BASE,       MAINMENUHOTSPOT_LOADGAME,     "LOADBUT.CAF",  0 }, // "Load Game" button
@@ -600,7 +625,38 @@ static const MainMenuFile mainMenuFiles[] = {
 	{ MAINMENUMASK_HOTKEYS,    MAINMENUHOTSPOT_HOTKEYSCLOSE, "HOTKEYS.CAF",  0 }  // Hotkeys display - clicking on it will close hotkeys
 };
 
-struct MainMenuEntry {
+#define OPTIONMENU_ENTRYCOUNT 27
+static const MenuFile optionMenuFiles[] = {
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_PLAY,        "PLAYBUTN.CAF", 0 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_QUIT,        "QUITBUTN.CAF", 0 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_VIDEO_MODE,        "VIDMODE.CAF", 0 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_TEXTSPEED,        "TXTSPEED.CAF", 0 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_TEXT,        "TEXTDIAL.CAF", 0}, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_VOLUMESFX,        "SFXBUTN.CAF", 0 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_VOLUMESFXSLIDER,        "SFXSLDR.CAF", 0 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_VOLUMEVOICE,        "VOICEBTN.CAF", 0 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_VOLUMEVOICESLIDER,        "VOICESLD.CAF", 0 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_VOLUMEMUSIC,        "MUSICBTN.CAF", 0 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_VOLUMEMUSICSLIDER,        "MUSICSLD.CAF", 0 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_SPEAKERBUTTON,        "XTRABUTN.CAF", 0 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_SPEAKERLEVER,        "XTRALEVR.CAF", 0}, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "ANTENNAL.CAF", 6 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "ANTENNAR.CAF", 6 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "BIGREDL.CAF", 6 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "BIGREDR.CAF", 6 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "GRIDLTEL.CAF", 6 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "GRIDLTER.CAF", 6 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "LSPEAKR.CAF", 0 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "RSPEAKR.CAF", 0 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "STARLITL.CAF", 6 }, // "Start" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "STARLITR.CAF", 6 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "CHASE1.CAF", 6 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "CHASE2.CAF", 6 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "CHASE3.CAF", 6 }, // "Intro" button
+	{ OPTIONMENUMASK_EVERYWHERE,       OPTIONMENUHOTSPOT_NONE,        "CHASE4.CAF", 6 } // "Intro" button
+};
+
+struct MenuEntry {
 	int menuMask;
 	int id;
 	Animation *animation;
@@ -608,15 +664,291 @@ struct MainMenuEntry {
 	int animateOnFrame;
 	int animateCurFrame;
 	int activeFrame;
+	bool playOnce;
 };
 
+bool ToonEngine::showOptions() {
+
+	storePalette();
+	fadeOut(5);
+	Picture* optionPicture = new Picture(this);
+	optionPicture->loadPicture("OPTIONS.CPS");
+	optionPicture->setupPalette();
+	flushPalette(true);
+
+	int16 oldScrollValue = _gameState->_currentScrollValue;
+	_gameState->_currentScrollValue = 0;
+
+	bool oldMouseHidden = _gameState->_mouseHidden;
+	_gameState->_mouseHidden = false;
+
+	MenuEntry entries[OPTIONMENU_ENTRYCOUNT];
+
+	for (int entryNr = 0; entryNr < OPTIONMENU_ENTRYCOUNT; entryNr++) {
+		entries[entryNr].menuMask = optionMenuFiles[entryNr].menuMask;
+		entries[entryNr].id = optionMenuFiles[entryNr].id;
+		entries[entryNr].animation = new Animation(this);
+		entries[entryNr].animation->loadAnimation(optionMenuFiles[entryNr].animationFile);
+		if (entries[entryNr].id != OPTIONMENUHOTSPOT_NONE)
+			entries[entryNr].rect = entries[entryNr].animation->getRect();
+		entries[entryNr].animateOnFrame = optionMenuFiles[entryNr].animateOnFrame;
+		entries[entryNr].animateCurFrame = 0;
+		entries[entryNr].activeFrame = 0;
+		entries[entryNr].playOnce = false;
+	}
+
+	entries[10].activeFrame = _audioManager->_mixer->getVolumeForSoundType(Audio::Mixer::kMusicSoundType) * (entries[10].animation->_numFrames - 1) / 256;
+	entries[8].activeFrame = _audioManager->_mixer->getVolumeForSoundType(Audio::Mixer::kSpeechSoundType) * (entries[8].animation->_numFrames - 1) / 256;
+	entries[6].activeFrame = _audioManager->_mixer->getVolumeForSoundType(Audio::Mixer::kSFXSoundType) * (entries[6].animation->_numFrames - 1) / 256;
+
+	entries[9].activeFrame = _audioManager->isMusicMuted() ? 0 : 3;
+	entries[7].activeFrame = _audioManager->isVoiceMuted() ? 0 : 3;
+	entries[5].activeFrame = _audioManager->isSfxMuted() ? 0 : 3;
+
+	entries[2].activeFrame = entries[2].animation->_numFrames - 1;
+
+	if (!_showConversationText) {
+		entries[4].activeFrame = 4;		
+	} else if (_useAlternativeFont) {
+		entries[4].activeFrame = 8;
+	} else {
+		entries[4].activeFrame = 0;
+	}
+
+	setCursor(0);
+
+	int menuMask = OPTIONMENUMASK_EVERYWHERE;
+	int ratioX = 0;
+	bool doExit = false;
+	bool exitGame = false;
+	_gameState->_inMenu = true;
+	dirtyAllScreen();
+	_firstFrame = true;
+
+	while (!doExit) {
+
+		int clickingOn = OPTIONMENUHOTSPOT_NONE;
+		int clickingOnSprite = 0;
+		int clickRelease = false;
+
+		while (!clickRelease) {
+
+			if (_dirtyAll) {
+				optionPicture->draw(*_mainSurface, 0, 0, 0, 0);
+				addDirtyRect(0, 0, TOON_SCREEN_WIDTH, TOON_SCREEN_HEIGHT);
+			} else {
+				optionPicture->drawWithRectList(*_mainSurface, 0, 0, 0, 0, _dirtyRects);
+			}
+			clearDirtyRects();
+
+			for (int entryNr = 0; entryNr < OPTIONMENU_ENTRYCOUNT; entryNr++) {
+				if (entries[entryNr].menuMask & menuMask) {
+					if (entries[entryNr].animateOnFrame) {
+						entries[entryNr].animateCurFrame++;
+						if (entries[entryNr].animateOnFrame <= entries[entryNr].animateCurFrame) {
+							entries[entryNr].activeFrame++;
+							if (entries[entryNr].activeFrame >= entries[entryNr].animation->_numFrames) {
+								entries[entryNr].activeFrame = 0;
+								if (entries[entryNr].playOnce) {
+									entries[entryNr].animateOnFrame = 0;
+									entries[entryNr].playOnce = false;
+								}
+								if (entryNr == 20 && entries[entryNr].animateOnFrame > 0) {
+									playSFX(-3, 128);
+								}
+							}
+							entries[entryNr].animateCurFrame = 0;
+						}
+					}
+					int32 frameNr = entries[entryNr].activeFrame;
+					entries[entryNr].animation->drawFrame(*_mainSurface, frameNr, 0, 0);
+				}
+			}
+
+			parseInput();
+
+			copyToVirtualScreen(true);
+			if (_firstFrame) {
+				_firstFrame = false;
+				fadeIn(5);
+			}
+			_system->delayMillis(17);
+
+			if (_mouseButton & 1) {
+				// left mouse button pushed down
+				clickingOn = OPTIONMENUHOTSPOT_NONE;
+				for (int entryNr = 0; entryNr < OPTIONMENU_ENTRYCOUNT; entryNr++) {
+					if (entries[entryNr].menuMask & menuMask) {
+						if (entries[entryNr].id != OPTIONMENUHOTSPOT_NONE) {
+							if (entries[entryNr].rect.contains(_mouseX, _mouseY)) {
+								clickingOn = entries[entryNr].id;
+								clickingOnSprite = entryNr;
+								ratioX = (_mouseX - entries[entryNr].rect.left) * 256 / entries[entryNr].rect.width();
+							}
+						}
+					}
+				}
+			} else {
+				// left mouse button released/not pushed down
+				if (clickingOn != OPTIONMENUHOTSPOT_NONE)
+					clickRelease = true;
+			}
+
+			// handle sliders
+			if (clickingOn == OPTIONMENUHOTSPOT_VOLUMEMUSICSLIDER) {
+				entries[clickingOnSprite].activeFrame = ratioX * (entries[clickingOnSprite].animation->_numFrames) / 256;
+				int vol = entries[clickingOnSprite].activeFrame * 256 / entries[clickingOnSprite].animation->_numFrames; 
+				_audioManager->_mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, vol);
+			}
+
+			if (clickingOn == OPTIONMENUHOTSPOT_VOLUMEVOICESLIDER) {
+				entries[clickingOnSprite].activeFrame = ratioX * (entries[clickingOnSprite].animation->_numFrames) / 256;
+				int vol = entries[clickingOnSprite].activeFrame * 256 / entries[clickingOnSprite].animation->_numFrames; 
+				_audioManager->_mixer->setVolumeForSoundType(Audio::Mixer::kSpeechSoundType, vol);
+			}
+
+			if (clickingOn == OPTIONMENUHOTSPOT_VOLUMESFXSLIDER) {
+				entries[clickingOnSprite].activeFrame = ratioX * (entries[clickingOnSprite].animation->_numFrames) / 256;
+				int vol = entries[clickingOnSprite].activeFrame * 256 / entries[clickingOnSprite].animation->_numFrames; 
+				_audioManager->_mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, vol);
+			}
+
+			if (clickingOn == OPTIONMENUHOTSPOT_TEXTSPEED) {
+				entries[clickingOnSprite].activeFrame = ratioX * (entries[clickingOnSprite].animation->_numFrames) / 256;
+			}
+
+			if (clickingOn == OPTIONMENUHOTSPOT_PLAY) {
+				entries[0].activeFrame = entries[0].animation->_numFrames - 1;
+			} else {
+				entries[0].activeFrame = 0;
+			}
+
+			if (clickingOn == OPTIONMENUHOTSPOT_QUIT) {
+				entries[1].activeFrame = entries[1].animation->_numFrames - 1;
+			} else {
+				entries[1].activeFrame = 0;
+			}
+
+			if (_shouldQuit) {
+				clickingOn = OPTIONMENUHOTSPOT_NONE;
+				clickRelease = true;
+				doExit = true;
+			}
+		}
+
+		if (clickingOn == OPTIONMENUHOTSPOT_VOLUMEMUSIC) {
+			if (entries[9].activeFrame == 0) {
+				entries[9].activeFrame = 3;
+				_audioManager->muteMusic(false);
+			} else {
+				entries[9].activeFrame = 0;
+				_audioManager->muteMusic(true);
+			}
+			playSFX(-7, 128);
+		}
+
+		if (clickingOn == OPTIONMENUHOTSPOT_VOLUMEVOICE) {
+			if (entries[7].activeFrame == 0) {
+				entries[7].activeFrame = 3;
+				_audioManager->muteVoice(false);
+			} else {
+				entries[7].activeFrame = 0;
+				_audioManager->muteVoice(true);
+			}
+			playSFX(-7, 128);
+		}
+
+		if (clickingOn == OPTIONMENUHOTSPOT_VOLUMESFX) {
+			if (entries[5].activeFrame == 0) {
+				entries[5].activeFrame = 3;
+				_audioManager->muteSfx(false);
+			} else {
+				entries[5].activeFrame = 0;
+				_audioManager->muteSfx(true);
+			}
+			playSFX(-7, 128);
+		}
+
+		if (clickingOn == OPTIONMENUHOTSPOT_SPEAKERBUTTON) {
+			entries[11].animateOnFrame = 4;
+			entries[11].playOnce = true;
+
+			entries[19].animateOnFrame = 4;
+			entries[19].playOnce = true;
+
+			playSFX(-10, 128);
+			_audioManager->playVoice(316, true);
+		}
+
+		if (clickingOn == OPTIONMENUHOTSPOT_SPEAKERLEVER) {
+
+			entries[12].activeFrame = 1 - entries[12].activeFrame;
+			if(entries[12].activeFrame == 1) {
+				entries[20].animateOnFrame = 4;
+				entries[20].playOnce = false;
+				playSFX(-3, 128);
+			} else {
+				entries[20].playOnce = true;
+			}
+			playSFX(-9, 128);
+		}
+
+		if (clickingOn == OPTIONMENUHOTSPOT_TEXT) {
+
+			if (entries[4].activeFrame == 0) {
+				_showConversationText = false;
+				entries[4].activeFrame = 4;
+			} else if (entries[4].activeFrame == 4) {
+				_showConversationText = true;
+				setFont(true);
+				entries[4].activeFrame = 8;
+			} else if(entries[4].activeFrame == 8) {
+				_showConversationText = true;
+				setFont(false);
+				entries[4].activeFrame = 0;
+			}
+
+			playSFX(-9, 128);
+		}
+
+		// don't allow change to video mode
+		if (clickingOn == OPTIONMENUHOTSPOT_VIDEO_MODE) {
+			playSoundWrong();
+		}
+
+		if (clickingOn == OPTIONMENUHOTSPOT_PLAY) {
+			doExit = true;
+			exitGame = false;
+			_audioManager->playSFX(10, 128, true);
+		}
+
+		if (clickingOn == OPTIONMENUHOTSPOT_QUIT) {
+			doExit = true;
+			exitGame = true;
+			_shouldQuit = true;
+			_audioManager->playSFX(10, 128, true);
+		}
+	}
+
+	fadeOut(5);
+	_gameState->_mouseHidden = oldMouseHidden;
+	_gameState->_inMenu = false;
+	_firstFrame = true;
+	_gameState->_currentScrollValue = oldScrollValue;
+	
+	restorePalette();
+	dirtyAllScreen();
+
+	return exitGame;
+}
+
 bool ToonEngine::showMainmenu(bool &loadedGame) {
 	Picture *mainmenuPicture = new Picture(this);
 	mainmenuPicture->loadPicture("TITLESCR.CPS");
 	mainmenuPicture->setupPalette();
 	flushPalette(false);
 
-	MainMenuEntry entries[MAINMENU_ENTRYCOUNT];
+	MenuEntry entries[MAINMENU_ENTRYCOUNT];
 
 	for (int entryNr = 0; entryNr < MAINMENU_ENTRYCOUNT; entryNr++) {
 		entries[entryNr].menuMask = mainMenuFiles[entryNr].menuMask;
@@ -630,7 +962,7 @@ bool ToonEngine::showMainmenu(bool &loadedGame) {
 		entries[entryNr].activeFrame = 0;
 	}
 
-	setCursor(1);
+	setCursor(0);
 
 	bool doExit = false;
 	bool exitGame = false;
@@ -822,6 +1154,7 @@ ToonEngine::ToonEngine(OSystem *syst, const ADGameDescription *gameDescription)
 	_inventoryPicture = NULL;
 	_currentMask = NULL;
 	_showConversationText = true;
+	_useAlternativeFont = false;
 	_isDemo = _gameDescription->flags & ADGF_DEMO;
 
 	DebugMan.addDebugChannel(kDebugAnim, "Anim", "Animation debug level");
@@ -1452,7 +1785,7 @@ int32 ToonEngine::runEventScript(int32 x, int32 y, int32 mode, int32 id, int32 s
 	_currentScriptRegion++;
 
 	_script->start(status, 1);
-	while (_script->run(status))
+	while (_script->run(status) && !_shouldQuit)
 		waitForScriptStep();
 
 	_currentScriptRegion--;
@@ -1853,6 +2186,17 @@ void ToonEngine::initFonts() {
 
 	_fontEZ = new Animation(this);
 	_fontEZ->loadAnimation("EZFONT.CAF");
+
+	setFont(false);
+}
+
+void ToonEngine::setFont(bool alternative) {
+	if (alternative) {
+		_currentFont = _fontEZ;
+	} else {
+		_currentFont = _fontToon;
+	}
+	_useAlternativeFont = alternative;
 }
 
 void ToonEngine::drawInfoLine() {
@@ -1870,7 +2214,7 @@ void ToonEngine::drawInfoLine() {
 		}
 		if (infoTool) {
 			_fontRenderer->setFontColor(0xc8, 0xdd, 0xe3);
-			_fontRenderer->setFont(_fontToon);
+			_fontRenderer->setFont(_currentFont);
 			_fontRenderer->renderText(320 + _gameState->_currentScrollValue, 398, infoTool, 5);
 		}
 	}
@@ -1998,6 +2342,8 @@ int32 ToonEngine::simpleCharacterTalk(int32 dialogid) {
 		_audioManager->playVoice(myId, false);
 	} else {
 		myId = _genericTexts->getId(dialogid - 1000);
+		if (myId == -1)
+			return 0;
 		_audioManager->playVoice(myId, true);
 	}
 
@@ -2936,7 +3282,7 @@ Character *ToonEngine::getCharacterById(int32 charId) {
 void ToonEngine::drawConversationLine() {
 	if (_currentTextLine && _showConversationText) {
 		_fontRenderer->setFontColorByCharacter(_currentTextLineCharacterId);
-		_fontRenderer->setFont(_fontToon);
+		_fontRenderer->setFont(_currentFont);
 		_fontRenderer->renderMultiLineText(_currentTextLineX, _currentTextLineY, _currentTextLine, 0);
 	}
 }
diff --git a/engines/toon/toon.h b/engines/toon/toon.h
index 6903e5de57..f419d491c6 100644
--- a/engines/toon/toon.h
+++ b/engines/toon/toon.h
@@ -111,6 +111,7 @@ public:
 	Common::Error run();
 	GUI::Debugger *getDebugger() { return _console; }
 	bool showMainmenu(bool &loadedGame);
+	bool showOptions();
 	void init();
 	bool loadToonDat();
 	char **loadTextsVariants(Common::File &in);
@@ -122,6 +123,7 @@ public:
 	void parseInput();
 	void initChapter();
 	void initFonts();
+	void setFont(bool alternative);
 	void loadScene(int32 SceneId, bool forGameLoad = false);
 	void exitScene();
 	void loadCursor();
@@ -421,6 +423,7 @@ protected:
 	FontRenderer *_fontRenderer;
 	Animation *_fontToon;
 	Animation *_fontEZ;
+	Animation *_currentFont;
 
 	AudioManager *_audioManager;
 
@@ -431,6 +434,7 @@ protected:
 	bool _firstFrame;
 	bool _isDemo;
 	bool _showConversationText;
+	bool _useAlternativeFont;
 	bool _needPaletteFlush;
 private:
 	ToonConsole *_console;
diff --git a/engines/tsage/blue_force/blueforce_scenes8.cpp b/engines/tsage/blue_force/blueforce_scenes8.cpp
index 6855fd41b9..337e73dad0 100644
--- a/engines/tsage/blue_force/blueforce_scenes8.cpp
+++ b/engines/tsage/blue_force/blueforce_scenes8.cpp
@@ -964,9 +964,10 @@ Scene810::Scene810(): SceneExt() {
 }
 
 void Scene810::synchronize(Serializer &s) {
+	int dummy = 0;
 	SceneExt::synchronize(s);
 	s.syncAsSint16LE(_fieldA70);
-	s.syncAsSint16LE(_fieldA72);
+	s.syncAsSint16LE(dummy);
 	s.syncAsSint16LE(_fieldA74);
 }
 
@@ -2220,6 +2221,7 @@ Scene840::Scene840(): PalettedScene() {
 	_field1AC2 = 0;
 	_field1AC4 = 0;
 	_field1AC6 = (BF_GLOBALS._dayNumber > 3) ? 1 : 0;
+	_field1ABA = 0;
 }
 
 void Scene840::synchronize(Serializer &s) {
diff --git a/engines/tsage/blue_force/blueforce_scenes8.h b/engines/tsage/blue_force/blueforce_scenes8.h
index 140327e85d..09de14f150 100644
--- a/engines/tsage/blue_force/blueforce_scenes8.h
+++ b/engines/tsage/blue_force/blueforce_scenes8.h
@@ -229,7 +229,7 @@ public:
 	Exit _exit;
 	ASoundExt _sound1;
 	Rect _rect1, _rect2, _rect3;
-	int _fieldA70, _fieldA72, _fieldA74;
+	int _fieldA70, _fieldA74;
 
 	Scene810();
 	virtual void synchronize(Serializer &s);
diff --git a/engines/tsage/blue_force/blueforce_scenes9.cpp b/engines/tsage/blue_force/blueforce_scenes9.cpp
index 53000d6997..5ba82a4714 100644
--- a/engines/tsage/blue_force/blueforce_scenes9.cpp
+++ b/engines/tsage/blue_force/blueforce_scenes9.cpp
@@ -3521,7 +3521,7 @@ void Scene935::Action1::signal() {
 		scene->_visualSpeaker.removeText();
 		scene->_visualSpeaker._textPos.y = scene->_sceneBounds.top + 80;
 		scene->_visualSpeaker._color1 = 252;
-		scene->_visualSpeaker._color1 = 251;
+		scene->_visualSpeaker._color2 = 251;
 		scene->_visualSpeaker.setText("Jake! Hide in the closet!");
 		setDelay(3);
 		break;
@@ -3538,7 +3538,7 @@ void Scene935::Action1::signal() {
 		scene->_visualSpeaker.removeText();
 		scene->_visualSpeaker._textPos.y = scene->_sceneBounds.top + 150;
 		scene->_visualSpeaker._color1 = 250;
-		scene->_visualSpeaker._color1 = 249;
+		scene->_visualSpeaker._color2 = 249;
 		scene->_visualSpeaker.setText("Jake! Hide in the closet!");
 		setDelay(3);
 		break;
diff --git a/engines/tsage/core.cpp b/engines/tsage/core.cpp
index f35aa583e2..d4068c25c9 100644
--- a/engines/tsage/core.cpp
+++ b/engines/tsage/core.cpp
@@ -56,6 +56,9 @@ InvObject::InvObject(int sceneNumber, int rlbNum, int cursorNum, CursorType curs
 	_bounds = s.getBounds();
 
 	DEALLOCATE(imgData);
+	_visage = 0;
+	_strip = 0;
+	_frame = 0;
 }
 
 InvObject::InvObject(int visage, int strip, int frame) {
@@ -1462,7 +1465,7 @@ void ScenePalette::fade(const byte *adjustData, bool fullAdjust, int percent) {
 			adjustData += 3;
 	}
 
-	// Set the altered pale4tte
+	// Set the altered palette
 	g_system->getPaletteManager()->setPalette((const byte *)&tempPalette[0], 0, 256);
 	GLOBALS._screenSurface.updateScreen();
 }
@@ -1518,7 +1521,7 @@ void ScenePalette::changeBackground(const Rect &bounds, FadeMode fadeMode) {
 	}
 
 	Rect tempRect = bounds;
-	if (g_vm->getGameID() != GType_Ringworld)
+	if (g_vm->getGameID() != GType_Ringworld && g_vm->getGameID() != GType_Sherlock1)
 		tempRect.setHeight(T2_GLOBALS._interfaceY);
 
 	g_globals->_screenSurface.copyFrom(g_globals->_sceneManager._scene->_backSurface,
@@ -2803,7 +2806,7 @@ void SceneObject::updateScreen() {
 	srcRect.right = ((srcRect.right + 3) / 4) * 4;
 	srcRect.clip(g_globals->_sceneManager._scene->_sceneBounds);
 
-	if (g_vm->getGameID() != GType_Ringworld) {
+	if (g_vm->getGameID() != GType_Ringworld && g_vm->getGameID() != GType_Sherlock1) {
 		if (T2_GLOBALS._uiElements._visible)
 			srcRect.bottom = MIN<int16>(srcRect.bottom, T2_GLOBALS._interfaceY);
 	}
diff --git a/engines/tsage/detection.cpp b/engines/tsage/detection.cpp
index 9d61b4d182..388967931d 100644
--- a/engines/tsage/detection.cpp
+++ b/engines/tsage/detection.cpp
@@ -62,6 +62,7 @@ static const PlainGameDescriptor tSageGameTitles[] = {
 	{ "ringworld", "Ringworld: Revenge of the Patriarch" },
 	{ "blueforce", "Blue Force" },
 	{ "ringworld2", "Return to Ringworld" },
+	{ "sherlock-logo", "The Lost Files of Sherlock Holmes (Logo)" },
 	{ 0, 0 }
 };
 
diff --git a/engines/tsage/detection_tables.h b/engines/tsage/detection_tables.h
index da283a27e7..109ac353e6 100644
--- a/engines/tsage/detection_tables.h
+++ b/engines/tsage/detection_tables.h
@@ -185,6 +185,23 @@ static const tSageGameDescription gameDescriptions[] = {
 		GType_Ringworld2,
 		GF_CD | GF_ALT_REGIONS | GF_DEMO
 	},
+#ifdef TSAGE_SHERLOCK_ENABLED
+	// The Lost Files of Sherlock Holmes - The Case of the Serrated Scalpel (Logo)
+	{
+		{
+			"sherlock-logo",
+			"",
+			AD_ENTRY1s("sf3.rlb", "153f9b93eda4e95578e31be30e69b5e5", 50419),
+			Common::EN_ANY,
+			Common::kPlatformDOS,
+			ADGF_NO_FLAGS,
+			GUIO0()
+		},
+		GType_Sherlock1,
+		GF_FLOPPY
+	},
+#endif
+
 	{ AD_TABLE_END_MARKER, 0, 0 }
 };
 
diff --git a/engines/tsage/globals.cpp b/engines/tsage/globals.cpp
index e75febfdbc..b880f35007 100644
--- a/engines/tsage/globals.cpp
+++ b/engines/tsage/globals.cpp
@@ -27,6 +27,7 @@
 #include "tsage/ringworld/ringworld_logic.h"
 #include "tsage/ringworld2/ringworld2_logic.h"
 #include "tsage/ringworld2/ringworld2_scenes0.h"
+#include "tsage/sherlock/sherlock_logo.h"
 #include "tsage/staticres.h"
 
 namespace TsAGE {
@@ -156,6 +157,15 @@ Globals::Globals() : _dialogCenter(160, 140), _gfxManagerInstance(_screenSurface
 		_game = new Ringworld2::Ringworld2Game();
 		_sceneHandler = new Ringworld2::SceneHandlerExt();
 		break;
+#ifdef TSAGE_SHERLOCK_ENABLED
+	case GType_Sherlock1:
+		_inventory = nullptr;
+		_sceneHandler = new Sherlock::SherlockSceneHandler();
+		_game = new Sherlock::SherlockLogo();
+		break;
+#endif
+	default:
+		break;
 	}
 
 }
diff --git a/engines/tsage/graphics.cpp b/engines/tsage/graphics.cpp
index ce24c76290..156503fb51 100644
--- a/engines/tsage/graphics.cpp
+++ b/engines/tsage/graphics.cpp
@@ -1289,7 +1289,8 @@ void GfxManager::setDefaults() {
 
 	_font._edgeSize = Common::Point(1, 1);
 	_font._colors = g_globals->_fontColors;
-	_font.setFontNumber(g_globals->_gfxFontNumber);
+	if (g_globals->_gfxFontNumber >= 0)
+		_font.setFontNumber(g_globals->_gfxFontNumber);
 }
 
 void GfxManager::activate() {
diff --git a/engines/tsage/graphics.h b/engines/tsage/graphics.h
index d65d0bcf8b..25f7aea8cd 100644
--- a/engines/tsage/graphics.h
+++ b/engines/tsage/graphics.h
@@ -20,8 +20,8 @@
  *
  */
 
-#ifndef RING_GRAPHICS_H
-#define RING_GRAPHICS_H
+#ifndef TSAGE_GRAPHICS_H
+#define TSAGE_GRAPHICS_H
 
 #include "tsage/events.h"
 #include "tsage/saveload.h"
diff --git a/engines/tsage/module.mk b/engines/tsage/module.mk
index d62f398c20..e23b157a95 100644
--- a/engines/tsage/module.mk
+++ b/engines/tsage/module.mk
@@ -47,6 +47,7 @@ MODULE_OBJS := \
 	ringworld2/ringworld2_vampire.o \
 	saveload.o \
 	scenes.o \
+	sherlock/sherlock_logo.o \
 	sound.o \
 	staticres.o \
 	tsage.o \
diff --git a/engines/tsage/resources.h b/engines/tsage/resources.h
index a7536a3c2d..7aa0c49dd4 100644
--- a/engines/tsage/resources.h
+++ b/engines/tsage/resources.h
@@ -20,8 +20,8 @@
  *
  */
 
-#ifndef RING_RESOURCES_H
-#define RING_RESOURCES_H
+#ifndef TSAGE_RESOURCES_H
+#define TSAGE_RESOURCES_H
 
 #include "common/scummsys.h"
 #include "common/array.h"
diff --git a/engines/tsage/ringworld/ringworld_scenes3.cpp b/engines/tsage/ringworld/ringworld_scenes3.cpp
index d8556c691e..a515224964 100644
--- a/engines/tsage/ringworld/ringworld_scenes3.cpp
+++ b/engines/tsage/ringworld/ringworld_scenes3.cpp
@@ -494,7 +494,7 @@ void Scene2100::Action1::signal() {
 			setDelay(1);
 		else {
 			setAction(&scene->_sequenceManager, this, 2102, &g_globals->_player, NULL);
-			scene->_sitFl = 0;
+			scene->_sitFl = false;
 		}
 		break;
 	case 1: {
@@ -1548,6 +1548,7 @@ Scene2100::Scene2100() :
 	_area3._pt = Common::Point(200, 75);
 	_area4.setup(2153, 1, 1, OBJECT_TRANSLATOR);
 	_area4._pt = Common::Point(237, 77);
+	_sitFl = false;
 }
 
 void Scene2100::postInit(SceneObjectList *OwnerList) {
@@ -1688,7 +1689,7 @@ void Scene2100::postInit(SceneObjectList *OwnerList) {
 	g_globals->_player._moveDiff.x = 4;
 	g_globals->_player.changeZoom(-1);
 	g_globals->_player.disableControl();
-	_sitFl = 0;
+	_sitFl = false;
 
 	switch (g_globals->_sceneManager._previousScene) {
 	case 2120:
@@ -1824,7 +1825,7 @@ void Scene2100::postInit(SceneObjectList *OwnerList) {
 		g_globals->_player.fixPriority(152);
 		g_globals->_player.setStrip(2);
 
-		_sitFl = 1;
+		_sitFl = true;
 
 		_object4.postInit();
 		_object4.setVisage(2102);
@@ -1858,7 +1859,7 @@ void Scene2100::postInit(SceneObjectList *OwnerList) {
 			g_globals->_player.fixPriority(152);
 			g_globals->_player.setStrip(2);
 
-			_sitFl = 1;
+			_sitFl = true;
 			setAction(&_action16);
 		}
 		break;
@@ -1932,12 +1933,12 @@ void Scene2100::stripCallback(int v) {
 void Scene2100::signal() {
 	switch (_sceneMode) {
 	case 2101:
-		_sitFl = 1;
+		_sitFl = true;
 		g_globals->_player._uiEnabled = true;
 		g_globals->_events.setCursor(CURSOR_USE);
 		break;
 	case 2102:
-		_sitFl = 0;
+		_sitFl = false;
 		g_globals->_player.enableControl();
 		break;
 	case 2103:
@@ -5789,6 +5790,7 @@ Scene2320::Scene2320() :
 	_area3._pt = Common::Point(200, 75);
 	_area4.setup(2153, 1, 1, 10);
 	_area4._pt = Common::Point(237, 77);
+	_hotspotPtr = nullptr;
 }
 
 void Scene2320::postInit(SceneObjectList *OwnerList) {
diff --git a/engines/tsage/ringworld/ringworld_scenes3.h b/engines/tsage/ringworld/ringworld_scenes3.h
index a371f800b9..752b6acd48 100644
--- a/engines/tsage/ringworld/ringworld_scenes3.h
+++ b/engines/tsage/ringworld/ringworld_scenes3.h
@@ -283,7 +283,7 @@ public:
 	Action15 _action15;
 	Action16 _action16;
 	Action17 _action17;
-	int _sitFl;
+	bool _sitFl;
 	SceneArea _area1, _area2, _area3, _area4;
 
 	Scene2100();
diff --git a/engines/tsage/sherlock/sherlock_logo.cpp b/engines/tsage/sherlock/sherlock_logo.cpp
new file mode 100644
index 0000000000..e27ce76576
--- /dev/null
+++ b/engines/tsage/sherlock/sherlock_logo.cpp
@@ -0,0 +1,359 @@
+/* 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.
+ *
+ */
+
+#ifdef TSAGE_SHERLOCK_ENABLED
+#include "tsage/sherlock/sherlock_logo.h"
+#include "tsage/scenes.h"
+#include "tsage/tsage.h"
+
+namespace TsAGE {
+
+namespace Sherlock {
+
+void SherlockLogo::start() {
+	GLOBALS._gfxFontNumber = -1;
+	GLOBALS.gfxManager().setDefaults();
+
+	// Start the demo's single scene
+	g_globals->_sceneManager.changeScene(1);
+
+	g_globals->_events.setCursor(CURSOR_NONE);
+}
+
+Scene *SherlockLogo::createScene(int sceneNumber) {
+	// The demo only has a single scene, so ignore the scene number and always return it
+	return new SherlockLogoScene();
+}
+
+bool SherlockLogo::canLoadGameStateCurrently() {
+	return false;
+}
+
+bool SherlockLogo::canSaveGameStateCurrently() {
+	return false;
+}
+
+void SherlockLogo::processEvent(Event &event) {
+	if (event.eventType == EVENT_BUTTON_DOWN || (event.eventType == EVENT_KEYPRESS &&
+			event.kbd.keycode == Common::KEYCODE_ESCAPE))
+		quitGame();
+}
+
+void SherlockLogo::quitGame() {
+	g_vm->quitGame();
+}
+
+/*--------------------------------------------------------------------------*/
+
+void SherlockSceneHandler::postInit(SceneObjectList *OwnerList) {
+	_delayTicks = 2;
+
+	GLOBALS._soundManager.postInit();
+	GLOBALS._soundManager.buildDriverList(true);
+	GLOBALS._soundManager.installConfigDrivers();
+
+	GLOBALS._sceneManager.setNewScene(10);
+	GLOBALS._game->start();
+}
+
+/*--------------------------------------------------------------------------*/
+
+void Object::setVisage(const Common::String &name) {
+	int visageNum = atoi(name.c_str());
+	SceneObject::setVisage(visageNum);
+}
+
+/*--------------------------------------------------------------------------*/
+
+void SherlockLogoScene::Action1::signal() {
+	SherlockLogoScene &scene = *(SherlockLogoScene *)GLOBALS._sceneManager._scene;
+
+	switch (_actionIndex++) {
+	case 0:
+		// Load scene palette
+		GLOBALS._scenePalette.loadPalette(1111);
+		GLOBALS._scenePalette.loadPalette(1);
+		GLOBALS._scenePalette.refresh();
+		setDelay(1);
+		break;
+
+	case 1:
+		// Fade in the spotlight background
+		GLOBALS._scenePalette.addFader(scene._palette1._palette, 256, 6, this);
+		break;
+
+	case 2:
+		// First half of square, circle, and triangle bouncing
+		scene._object1.postInit();
+		scene._object1.setVisage("0016.vis");
+		scene._object1._strip = 1;
+		scene._object1._frame = 1;
+		scene._object1.setPosition(Common::Point(169, 107));
+		scene._object1.changeZoom(100);
+		scene._object1._numFrames = 7;
+		scene._object1.animate(ANIM_MODE_5, this);
+		break;
+
+	case 3:
+		// Remainder of bouncing square, circle, and triangle coming to rest
+		scene._object1._strip = 2;
+		scene._object1._frame = 1;
+		scene._object1.changeZoom(100);
+		scene._object1.animate(ANIM_MODE_4, 11, 1, this);
+		break;
+
+	case 4:
+		// Fade out background without fading out the shapes
+		GLOBALS._scenePalette.addFader(scene._palette2._palette, 256, 6, this);
+		break;
+
+	case 5:
+		scene._backSurface.fillRect(scene._sceneBounds, 0);
+		scene._gfxManager2.activate();
+		scene._gfxManager2.fillRect(scene._sceneBounds, 0);
+		scene._gfxManager2.deactivate();
+		//word_2B4AA = 3;
+		setDelay(10);
+		break;
+
+	case 6:
+		GLOBALS._scenePalette.loadPalette(12);
+		GLOBALS._scenePalette.refresh();
+		setDelay(1);
+		break;
+
+	case 7:
+		// Animation of shapes expanding upwards to form larger EA logo
+		scene._object1.setVisage("0012.vis");
+		scene._object1._strip = 1;
+		scene._object1._frame = 1;
+		scene._object1.changeZoom(100);
+		scene._object1.setPosition(Common::Point(170, 142));
+		scene._object1._numFrames = 7;
+		scene._object1.animate(ANIM_MODE_5, (const void *)nullptr);
+		ADD_MOVER(scene._object1, 158, 71);
+		break;
+
+	case 8:
+		GLOBALS._scenePalette.addFader(scene._palette3._palette, 256, 40, this);
+		break;
+
+	case 9:
+		// Show 'Electronic Arts' company name
+		scene._object2.postInit(nullptr);
+		scene._object2.setVisage("0014.vis");
+		scene._object2._strip = 1;
+		scene._object2._frame = 1;
+		scene._object2.setPosition(Common::Point(152, 98));
+		scene._object2.changeZoom(100);
+		scene._object2.animate(ANIM_MODE_NONE, (const void *)nullptr);
+		setDelay(120);
+		break;
+
+	case 10:
+		// Remainder of steps is positioning and sizing hand cursorin an arc
+		scene._object3.postInit();
+		scene._object3.setVisage("0018.vis");
+		scene._object3._strip = 1;
+		scene._object3._frame = 1;
+		scene._object3.setPosition(Common::Point(33, 91));
+		scene._object3.changeZoom(100);
+		scene._object3.animate(ANIM_MODE_NONE, (const void *)nullptr);
+		setDelay(5);
+		break;
+
+	case 11:
+		scene._object3._frame = 2;
+		scene._object3.setPosition(Common::Point(44, 124));
+		setDelay(5);
+		break;
+
+	case 12:
+		scene._object3._frame = 3;
+		scene._object3.setPosition(Common::Point(64, 153));
+		setDelay(5);
+		break;
+
+	case 13:
+		scene._object3._frame = 4;
+		scene._object3.setPosition(Common::Point(87, 174));
+		setDelay(5);
+		break;
+
+	case 14:
+		scene._object3._frame = 5;
+		scene._object3.setPosition(Common::Point(114, 191));
+		setDelay(5);
+		break;
+
+	case 15:
+		scene._object3._frame = 6;
+		scene._object3.setPosition(Common::Point(125, 184));
+		setDelay(5);
+		break;
+
+	case 16:
+		scene._object3._frame = 7;
+		scene._object3.setPosition(Common::Point(154, 187));
+		setDelay(5);
+		break;
+
+	case 17:
+		scene._object3._frame = 8;
+		scene._object3.setPosition(Common::Point(181, 182));
+		setDelay(5);
+		break;
+
+	case 18:
+		scene._object3._frame = 9;
+		scene._object3.setPosition(Common::Point(191, 167));
+		setDelay(5);
+		break;
+
+	case 19:
+		scene._object3._frame = 10;
+		scene._object3.setPosition(Common::Point(190, 150));
+		setDelay(5);
+		break;
+
+	case 20:
+		scene._object3._frame = 11;
+		scene._object3.setPosition(Common::Point(182, 139));
+		setDelay(5);
+		break;
+
+	case 21:
+		scene._object3._frame = 11;
+		scene._object3.setPosition(Common::Point(170, 130));
+		setDelay(5);
+		break;
+
+	case 22:
+		scene._object3._frame = 11;
+		scene._object3.setPosition(Common::Point(158, 121));
+		setDelay(8);
+		break;
+
+	case 23:
+		// Show a highlighting of the company name
+		scene._object3.hide();
+		scene._object4.show();
+		scene._object4.setPosition(Common::Point(155, 94));
+		setDelay(8);
+		break;
+
+	case 24:
+		scene._object4._frame = 2;
+		scene._object4.setPosition(Common::Point(155, 94));
+		setDelay(8);
+		break;
+
+	case 25:
+		scene._object2.remove();
+		setDelay(1);
+		break;
+
+	case 26:
+		scene._object4._frame = 3;
+		scene._object4.setPosition(Common::Point(155, 94));
+		setDelay(8);
+		break;
+
+	case 27:
+		scene._object4._frame = 4;
+		scene._object4.setPosition(Common::Point(155, 94));
+		setDelay(8);
+		break;
+		break;
+
+	case 28:
+		scene._object4._frame = 5;
+		scene._object4.setPosition(Common::Point(155, 94));
+		setDelay(8);
+		break;
+		break;
+
+	case 29:
+		scene._object4._frame = 6;
+		scene._object4.setPosition(Common::Point(155, 94));
+		setDelay(8);
+		break;
+		break;
+
+	case 30:
+		scene._object4._frame = 7;
+		scene._object4.setPosition(Common::Point(155, 94));
+		setDelay(8);
+		break;
+		break;
+
+	case 31:
+		scene._object4._frame = 8;
+		scene._object4.setPosition(Common::Point(155, 94));
+		setDelay(8);
+		break;
+
+	case 32:
+		setDelay(180);
+		break;
+
+	default:
+		scene.finish();
+		remove();
+		break;
+	}
+}
+
+/*--------------------------------------------------------------------------*/
+
+void SherlockLogoScene::postInit(SceneObjectList *OwnerList) {
+	loadScene(10);
+	Scene::postInit(OwnerList);
+
+	_palette1.loadPalette(1111);
+	_palette1.loadPalette(10);
+	_palette2.loadPalette(1111);
+	_palette2.loadPalette(1);
+	_palette3.loadPalette(1111);
+	_palette3.loadPalette(14);
+
+	_object4.postInit();
+	_object4.setVisage("0019.vis");
+	_object4._strip = 1;
+	_object4._frame = 1;
+	_object4.setPosition(Common::Point(155, 94));
+	_object4.changeZoom(100);
+	_object4.animate(ANIM_MODE_NONE, (const void *)nullptr);
+	_object4.hide();
+
+	setAction(&_action1);
+}
+
+void SherlockLogoScene::finish() {
+	g_vm->quitGame();
+}
+
+} // End of namespace Sherlock
+
+} // End of namespace TsAGE
+
+#endif
diff --git a/engines/tsage/sherlock/sherlock_logo.h b/engines/tsage/sherlock/sherlock_logo.h
new file mode 100644
index 0000000000..01b5b7f75f
--- /dev/null
+++ b/engines/tsage/sherlock/sherlock_logo.h
@@ -0,0 +1,80 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifdef TSAGE_SHERLOCK_ENABLED
+#ifndef TSAGE_SHERLOCK_LOGO_H
+#define TSAGE_SHERLOCK_LOGO_H
+
+#include "common/scummsys.h"
+#include "tsage/events.h"
+#include "tsage/core.h"
+#include "tsage/scenes.h"
+#include "tsage/globals.h"
+#include "tsage/sound.h"
+
+namespace TsAGE {
+
+namespace Sherlock {
+
+using namespace TsAGE;
+
+class Object : public SceneObject {
+public:
+	void setVisage(const Common::String &name);
+};
+
+class SherlockLogo: public Game {
+public:
+	virtual void start();
+	virtual Scene *createScene(int sceneNumber);
+	virtual void quitGame();
+	virtual void processEvent(Event &event);
+	virtual bool canSaveGameStateCurrently();
+	virtual bool canLoadGameStateCurrently();
+};
+
+class SherlockSceneHandler : public SceneHandler {
+public:
+	virtual void postInit(SceneObjectList *OwnerList);
+};
+
+class SherlockLogoScene: public Scene {
+	class Action1 : public Action {
+	public:
+		virtual void signal();
+	};
+public:
+	ScenePalette _palette1, _palette2, _palette3;
+	Object _object1, _object2, _object3, _object4;
+	Action1 _action1;
+	GfxManager _gfxManager2;
+
+	virtual void postInit(SceneObjectList *OwnerList = NULL);
+	void finish();
+};
+
+} // End of namespace Sherlock
+
+} // End of namespace TsAGE
+
+#endif
+#endif
diff --git a/engines/tsage/sound.cpp b/engines/tsage/sound.cpp
index b95b614f09..0d3fb55dd3 100644
--- a/engines/tsage/sound.cpp
+++ b/engines/tsage/sound.cpp
@@ -20,9 +20,9 @@
  *
  */
 
+#include "audio/fmopl.h"
 #include "audio/decoders/raw.h"
 #include "common/config-manager.h"
-#include "audio/decoders/raw.h"
 #include "audio/audiostream.h"
 #include "tsage/core.h"
 #include "tsage/globals.h"
@@ -2743,17 +2743,9 @@ AdlibSoundDriver::AdlibSoundDriver(): SoundDriver() {
 	_groupData._pData = &adlib_group_data[0];
 
 	_mixer = g_vm->_mixer;
-	_sampleRate = _mixer->getOutputRate();
 	_opl = OPL::Config::create();
 	assert(_opl);
-	_opl->init(_sampleRate);
-
-	_samplesTillCallback = 0;
-	_samplesTillCallbackRemainder = 0;
-	_samplesPerCallback = getRate() / CALLBACKS_PER_SECOND;
-	_samplesPerCallbackRemainder = getRate() % CALLBACKS_PER_SECOND;
-
-	_mixer->playStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
+	_opl->init();
 
 	Common::fill(_channelVoiced, _channelVoiced + ADLIB_CHANNEL_COUNT, false);
 	memset(_channelVolume, 0, ADLIB_CHANNEL_COUNT * sizeof(int));
@@ -2772,11 +2764,12 @@ AdlibSoundDriver::AdlibSoundDriver(): SoundDriver() {
 		_channelVoiced[i] = false;
 		_pitchBlend[i] = 0;
 	}
+
+	_opl->start(new Common::Functor0Mem<void, AdlibSoundDriver>(this, &AdlibSoundDriver::onTimer), CALLBACKS_PER_SECOND);
 }
 
 AdlibSoundDriver::~AdlibSoundDriver() {
 	DEALLOCATE(_patchData);
-	_mixer->stopHandle(_soundHandle);
 	delete _opl;
 }
 
@@ -3019,33 +3012,12 @@ void AdlibSoundDriver::setFrequency(int channel) {
 		((dataWord >> 8) & 3) | (var2 << 2));
 }
 
-int AdlibSoundDriver::readBuffer(int16 *buffer, const int numSamples) {
+void AdlibSoundDriver::onTimer() {
 	Common::StackLock slock1(SoundManager::sfManager()._serverDisabledMutex);
 	Common::StackLock slock2(SoundManager::sfManager()._serverSuspendedMutex);
 
-	int32 samplesLeft = numSamples;
-	memset(buffer, 0, sizeof(int16) * numSamples);
-	while (samplesLeft) {
-		if (!_samplesTillCallback) {
-			SoundManager::sfUpdateCallback(NULL);
-			flush();
-
-			_samplesTillCallback = _samplesPerCallback;
-			_samplesTillCallbackRemainder += _samplesPerCallbackRemainder;
-			if (_samplesTillCallbackRemainder >= CALLBACKS_PER_SECOND) {
-				_samplesTillCallback++;
-				_samplesTillCallbackRemainder -= CALLBACKS_PER_SECOND;
-			}
-		}
-
-		int32 render = MIN<int>(samplesLeft, _samplesTillCallback);
-		samplesLeft -= render;
-		_samplesTillCallback -= render;
-
-		_opl->readBuffer(buffer, render);
-		buffer += render;
-	}
-	return numSamples;
+	SoundManager::sfUpdateCallback(NULL);
+	flush();
 }
 
 /*--------------------------------------------------------------------------*/
diff --git a/engines/tsage/sound.h b/engines/tsage/sound.h
index 49558b4bca..68755a48c8 100644
--- a/engines/tsage/sound.h
+++ b/engines/tsage/sound.h
@@ -27,12 +27,15 @@
 #include "common/mutex.h"
 #include "common/queue.h"
 #include "audio/audiostream.h"
-#include "audio/fmopl.h"
 #include "audio/mixer.h"
 #include "common/list.h"
 #include "tsage/saveload.h"
 #include "tsage/core.h"
 
+namespace OPL {
+class OPL;
+}
+
 namespace TsAGE {
 
 class Sound;
@@ -446,21 +449,15 @@ public:
 
 #define ADLIB_CHANNEL_COUNT 9
 
-class AdlibSoundDriver: public SoundDriver, Audio::AudioStream {
+class AdlibSoundDriver: public SoundDriver {
 private:
 	GroupData _groupData;
 	Audio::Mixer *_mixer;
-	FM_OPL *_opl;
-	Audio::SoundHandle _soundHandle;
-	int _sampleRate;
+	OPL::OPL *_opl;
 	byte _portContents[256];
 	const byte *_patchData;
 	int _masterVolume;
 	Common::Queue<RegisterValue> _queue;
-	int _samplesTillCallback;
-	int _samplesTillCallbackRemainder;
-	int _samplesPerCallback;
-	int _samplesPerCallbackRemainder;
 
 	bool _channelVoiced[ADLIB_CHANNEL_COUNT];
 	int _channelVolume[ADLIB_CHANNEL_COUNT];
@@ -495,13 +492,8 @@ public:
 	virtual void proc38(int channel, int cmd, int value);
 	virtual void setPitch(int channel, int pitchBlend);
 
-	// AudioStream interface
-	virtual int readBuffer(int16 *buffer, const int numSamples);
-	virtual bool isStereo() const { return false; }
-	virtual bool endOfData() const { return false; }
-	virtual int getRate() const { return _sampleRate; }
-
-	void update(int16 *buf, int len);
+private:
+	void onTimer();
 };
 
 class SoundBlasterDriver: public SoundDriver {
diff --git a/engines/tsage/tsage.cpp b/engines/tsage/tsage.cpp
index 0b882d5cbf..b94b82f423 100644
--- a/engines/tsage/tsage.cpp
+++ b/engines/tsage/tsage.cpp
@@ -44,11 +44,12 @@ TSageEngine::TSageEngine(OSystem *system, const tSageGameDescription *gameDesc)
 			_debugger = new DemoDebugger();
 		else
 			_debugger = new RingworldDebugger();
-	}
-	else if (g_vm->getGameID() == GType_BlueForce)
+	} else if (g_vm->getGameID() == GType_BlueForce)
 		_debugger = new BlueForceDebugger();
 	else if (g_vm->getGameID() == GType_Ringworld2)
 		_debugger = new Ringworld2Debugger();
+	else if (g_vm->getGameID() == GType_Sherlock1)
+		_debugger = new DemoDebugger();
 }
 
 Common::Error TSageEngine::init() {
@@ -110,6 +111,13 @@ void TSageEngine::initialize() {
 
 		// Reset all global variables
 		R2_GLOBALS.reset();
+	} else if (g_vm->getGameID() == GType_Sherlock1) {
+#ifdef TSAGE_SHERLOCK_ENABLED
+		g_resourceManager->addLib("SF3.RLB");
+		g_globals = new Globals();
+	
+		return;
+#endif
 	}
 
 	g_globals->gfxManager().setDefaults();
diff --git a/engines/tsage/tsage.h b/engines/tsage/tsage.h
index ea4f5da6ea..667a8daa59 100644
--- a/engines/tsage/tsage.h
+++ b/engines/tsage/tsage.h
@@ -42,7 +42,8 @@ namespace TsAGE {
 enum {
 	GType_Ringworld = 0,
 	GType_BlueForce = 1,
-	GType_Ringworld2 = 2
+	GType_Ringworld2 = 2,
+	GType_Sherlock1 = 5
 };
 
 enum {
diff --git a/engines/tucker/staticres.cpp b/engines/tucker/staticres.cpp
index b884851d7e..b9f6a6efee 100644
--- a/engines/tucker/staticres.cpp
+++ b/engines/tucker/staticres.cpp
@@ -329,8 +329,13 @@ static const SoundSequenceData _soundDataSeq19_20[] = {
 	{   53,  2,  14, 100, 1 }, {   78,  2,   0, 100, 2 }, {   80,  0,   0, 100, 4 },
 };
 
+// I've been told that there are versions of the game that don't play the
+// "introdub" music (130) for the first scene of the intro. The English "Euro
+// power pack" release does however, and I see no harm in doing it for every
+// version here. The volume is just a guess, though.
+
 const SoundSequenceDataList AnimationSequencePlayer::_soundSeqDataList[] = {
-	{   0,   0, 14, 10, 58, _soundDataSeq3_4 },
+	{ 130,  80, 14, 10, 58, _soundDataSeq3_4 },
 	{   0,   0, 14,  5, 60, _soundDataSeq9_10 },
 	{   0,   0, 14,  9, 48, _soundDataSeq21_20 },
 	{   1,  80, 14,  4, 25, _soundDataSeq13_14 },
@@ -471,6 +476,7 @@ const char *const AnimationSequencePlayer::_audioFileNamesTable[] = {
 	"rdfx38.wav",
 	"rdfx8.wav",
 	"rdfx9.wav",
+	"introdub.raw",
 };
 
 } // namespace Tucker
diff --git a/engines/tucker/tucker.h b/engines/tucker/tucker.h
index a423915a5f..3bbf6a57f5 100644
--- a/engines/tucker/tucker.h
+++ b/engines/tucker/tucker.h
@@ -246,6 +246,15 @@ private:
 };
 
 inline int scaleMixerVolume(int volume, int max = 100) {
+	if (volume > max) {
+		// This happens for instance for Bud's line, "Is that the
+		// great mystery invention you had hidden away?" in the intro,
+		// which is played at volume 110 out of 100. This made it very
+		// hard to hear. I'm not sure if this was a bug in the original
+		// game, or if it had the ability to amplify sounds.
+		warning("scaleMixerVolume: Adjusting volume %d to %d", volume, max);
+		volume = max;
+	}
 	return volume * Audio::Mixer::kMaxChannelVolume / max;
 }
 
diff --git a/engines/voyeur/events.cpp b/engines/voyeur/events.cpp
index 7ce7351e65..34ef507ad3 100644
--- a/engines/voyeur/events.cpp
+++ b/engines/voyeur/events.cpp
@@ -76,7 +76,7 @@ EventsManager::EventsManager(VoyeurEngine *vm) : _intPtr(_gameData),
 
 	_leftClick = _rightClick = false;
 	_mouseClicked = _newMouseClicked = false;
-	_newLeftClick = _newRightClick = false;;
+	_newLeftClick = _newRightClick = false;
 
 	_videoDead = 0;
 
@@ -403,7 +403,7 @@ void EventsManager::vDoCycleInt() {
 					int palIndex = READ_LE_UINT16(pSrc);
 					pPal[palIndex * 3] = pSrc[3];
 					pPal[palIndex * 3 + 1] = pSrc[4];
-					pPal[palIndex * 3 + 1] = pSrc[5];
+					pPal[palIndex * 3 + 2] = pSrc[5];
 					pSrc += 6;
 
 					if ((int16)READ_LE_UINT16(pSrc) >= 0) {
diff --git a/engines/voyeur/files_threads.cpp b/engines/voyeur/files_threads.cpp
index 0615c67ba0..53eb5ce3c5 100644
--- a/engines/voyeur/files_threads.cpp
+++ b/engines/voyeur/files_threads.cpp
@@ -1082,6 +1082,7 @@ int ThreadResource::doApt() {
 		break;
 	case 2:
 		_vm->_voy->_aptLoadMode = 142;
+		break;
 	case 5:
 		_vm->_voy->_aptLoadMode = 141;
 		break;
diff --git a/engines/wintermute/base/base_file_manager.cpp b/engines/wintermute/base/base_file_manager.cpp
index 58684b66a0..05830ffcd8 100644
--- a/engines/wintermute/base/base_file_manager.cpp
+++ b/engines/wintermute/base/base_file_manager.cpp
@@ -227,7 +227,7 @@ bool BaseFileManager::registerPackages() {
 
 			// Again, make the parent's name all lowercase to avoid any case
 			// issues.
-			Common::String parentName = fileIt->getParent().getName();
+			Common::String parentName = it->getName();
 			parentName.toLowercase();
 
 			// Avoid registering all the language files
diff --git a/engines/wintermute/base/base_keyboard_state.cpp b/engines/wintermute/base/base_keyboard_state.cpp
index 0babc07586..f672c83d39 100644
--- a/engines/wintermute/base/base_keyboard_state.cpp
+++ b/engines/wintermute/base/base_keyboard_state.cpp
@@ -262,41 +262,92 @@ bool BaseKeyboardState::isCurrentPrintable() const {
 }
 
 //////////////////////////////////////////////////////////////////////////
+enum VKeyCodes {
+	kVkReturn     = 13,
+
+	kVkEscape     = 27,
+
+	kVkSpace      = 32,
+	kVkEnd        = 35,
+	kVkHome       = 36,
+	kVkLeft       = 37,
+	kVkUp         = 38,
+	kVkRight      = 39,
+	kVkDown       = 40,
+
+	kVkF1         = 112,
+	kVkF2         = 113,
+	kVkF3         = 114,
+	kVkF4         = 115,
+	kVkF5         = 116,
+	kVkF6         = 117,
+	kVkF7         = 118,
+	kVkF8         = 119,
+	kVkF9         = 120,
+	kVkF10        = 121,
+	kVkF11        = 122,
+	kVkF12        = 123
+
+};
+
+//////////////////////////////////////////////////////////////////////////
 uint32 BaseKeyboardState::keyCodeToVKey(Common::Event *event) {
+	// todo
 	if (event->type != Common::EVENT_KEYDOWN) {
 		return 0;
 	}
 
 	switch (event->kbd.keycode) {
+	case Common::KEYCODE_RETURN:
 	case Common::KEYCODE_KP_ENTER:
-		return Common::KEYCODE_RETURN;
+		return kVkReturn;
+	case Common::KEYCODE_ESCAPE:
+		return kVkEscape;
+	case Common::KEYCODE_SPACE:
+		return kVkSpace;
+	case Common::KEYCODE_END:
+		return kVkEnd;
+	case Common::KEYCODE_HOME:
+		return kVkHome;
+	case Common::KEYCODE_LEFT:
+		return kVkLeft;
+	case Common::KEYCODE_RIGHT:
+		return kVkRight;
+	case Common::KEYCODE_UP:
+		return kVkUp;
+	case Common::KEYCODE_DOWN:
+		return kVkDown;
+	case Common::KEYCODE_F1:
+		return kVkF1;
+	case Common::KEYCODE_F2:
+		return kVkF2;
+	case Common::KEYCODE_F3:
+		return kVkF3;
+	case Common::KEYCODE_F4:
+		return kVkF4;
+	case Common::KEYCODE_F5:
+		return kVkF5;
+	case Common::KEYCODE_F6:
+		return kVkF6;
+	case Common::KEYCODE_F7:
+		return kVkF7;
+	case Common::KEYCODE_F8:
+		return kVkF8;
+	case Common::KEYCODE_F9:
+		return kVkF9;
+	case Common::KEYCODE_F10:
+		return kVkF10;
+	case Common::KEYCODE_F11:
+		return kVkF11;
+	case Common::KEYCODE_F12:
+		return kVkF12;
 	default:
-		return (uint32)event->kbd.ascii;
+		warning("Key not handled: %d '%c'", event->kbd.keycode, event->kbd.keycode);
+		return event->kbd.keycode;
+		break;
 	}
-}
 
-enum VKeyCodes {
-	kVkEscape = 27,
-	kVkSpace  = 32,
-	kVkHome   = 36,
-	kVkLeft   = 37,
-	kVkUp     = 38,
-	kVkRight  = 39,
-	kVkDown   = 40,
-
-	kVkF1     = 112,
-	kVkF2     = 113,
-	kVkF3     = 114,
-	kVkF4     = 115,
-	kVkF5     = 116,
-	kVkF6     = 117,
-	kVkF7     = 118,
-	kVkF8     = 119,
-	kVkF9     = 120,
-	kVkF10    = 121,
-	kVkF11    = 122,
-	kVkF12    = 123
-};
+}
 
 //////////////////////////////////////////////////////////////////////////
 Common::KeyCode BaseKeyboardState::vKeyToKeyCode(uint32 vkey) {
diff --git a/engines/wintermute/base/base_keyboard_state.h b/engines/wintermute/base/base_keyboard_state.h
index c74bd5b0f7..32680b34c1 100644
--- a/engines/wintermute/base/base_keyboard_state.h
+++ b/engines/wintermute/base/base_keyboard_state.h
@@ -67,7 +67,7 @@ private:
 	bool _currentControl;
 
 	uint8 *_keyStates;
-	uint32 keyCodeToVKey(Common::Event *event);
+	uint32 keyCodeToVKey(Common::Event *event); //TODO, add more mappings
 	Common::KeyCode vKeyToKeyCode(uint32 vkey); //TODO, reimplement using ScummVM-backend
 };
 
diff --git a/engines/wintermute/base/base_script_holder.cpp b/engines/wintermute/base/base_script_holder.cpp
index 8383657239..5b1c961479 100644
--- a/engines/wintermute/base/base_script_holder.cpp
+++ b/engines/wintermute/base/base_script_holder.cpp
@@ -302,7 +302,7 @@ bool BaseScriptHolder::addScript(const char *filename) {
 	for (uint32 i = 0; i < _scripts.size(); i++) {
 		if (scumm_stricmp(_scripts[i]->_filename, filename) == 0) {
 			if (_scripts[i]->_state != SCRIPT_FINISHED) {
-				BaseEngine::LOG(0, "BaseScriptHolder::AddScript - trying to add script '%s' mutiple times (obj: '%s')", filename, getName());
+				BaseEngine::LOG(0, "BaseScriptHolder::AddScript - trying to add script '%s' multiple times (obj: '%s')", filename, getName());
 				return STATUS_OK;
 			}
 		}
diff --git a/engines/wintermute/base/file/base_file.cpp b/engines/wintermute/base/file/base_file.cpp
index 2927c908e2..4589721e7e 100644
--- a/engines/wintermute/base/file/base_file.cpp
+++ b/engines/wintermute/base/file/base_file.cpp
@@ -57,7 +57,7 @@ bool BaseFile::isEOF() {
 Common::SeekableReadStream *BaseFile::getMemStream() {
 	uint32 oldPos = getPos();
 	seek(0);
-	byte *data = new byte[getSize()];
+	byte *data = (byte *)malloc(getSize());
 	read(data, getSize());
 	seek(oldPos);
 	Common::MemoryReadStream *memStream = new Common::MemoryReadStream(data, getSize(), DisposeAfterUse::YES);
diff --git a/engines/wintermute/base/gfx/base_surface.cpp b/engines/wintermute/base/gfx/base_surface.cpp
index f8b96b5baf..3aa500b224 100644
--- a/engines/wintermute/base/gfx/base_surface.cpp
+++ b/engines/wintermute/base/gfx/base_surface.cpp
@@ -75,11 +75,6 @@ bool BaseSurface::displayHalfTrans(int x, int y, Rect32 rect) {
 }
 
 //////////////////////////////////////////////////////////////////////////
-bool BaseSurface::displayTransform(int x, int y, Rect32 rect, Rect32 newRect, const Graphics::TransformStruct &transform) {
-	return displayTransform(x, y, rect, newRect, transform);
-}
-
-//////////////////////////////////////////////////////////////////////////
 bool BaseSurface::create(int width, int height) {
 	return STATUS_FAILED;
 }
diff --git a/engines/wintermute/debugger.cpp b/engines/wintermute/debugger.cpp
index a313314a8b..5b617d9db9 100644
--- a/engines/wintermute/debugger.cpp
+++ b/engines/wintermute/debugger.cpp
@@ -42,7 +42,7 @@ bool Console::Cmd_ShowFps(int argc, const char **argv) {
 		if (Common::String(argv[1]) == "true") {
 			_engineRef->_game->setShowFPS(true);
 		} else if (Common::String(argv[1]) == "false") {
-			_engineRef->_game->setShowFPS(false);;
+			_engineRef->_game->setShowFPS(false);
 		}
 	}
 	return true;
diff --git a/engines/wintermute/detection_tables.h b/engines/wintermute/detection_tables.h
index 4e3320159a..25a01766e4 100644
--- a/engines/wintermute/detection_tables.h
+++ b/engines/wintermute/detection_tables.h
@@ -140,9 +140,18 @@ static const WMEGameDescription gameDescriptions[] = {
 	// Five Lethal Demons
 	WME_WINENTRY("5ld", "", 
 		WME_ENTRY1s("data.dcp", "1037a77cbd001e0644898addc022322c", 15407750), Common::EN_ANY, ADGF_UNSTABLE, LATEST_VERSION),
-	// Five Magical Amulets
+	// Five Magical Amulets (Czech)
 	WME_WINENTRY("5ma", "", 
-		WME_ENTRY1s("data.dcp", "0134e92bcd5fd2837df3971087e96067", 163316498), Common::EN_ANY, ADGF_UNSTABLE, WME_1_7_0),
+		WME_ENTRY2s("czech.dcp", "7b2515a8ceb955c72bc14f0f1fca869e", 184,
+					"data.dcp", "0134e92bcd5fd2837df3971087e96067", 163316498), Common::CZ_CZE, ADGF_UNSTABLE, WME_1_7_0),
+	// Five Magical Amulets (English)
+	WME_WINENTRY("5ma", "",
+		WME_ENTRY2s("english.dcp", "2f97bca09260ba23b645da9f0855ce7f", 893681,
+					"data.dcp", "0134e92bcd5fd2837df3971087e96067", 163316498), Common::EN_ANY, ADGF_UNSTABLE, WME_1_7_0),
+	// Five Magical Amulets (Polish)
+	WME_WINENTRY("5ma", "",
+		WME_ENTRY2s("polish.dcp", "bb877d48795471a17f25b0b5109100d1", 1132197,
+					"data.dcp", "0134e92bcd5fd2837df3971087e96067", 163316498), Common::PL_POL, ADGF_UNSTABLE, WME_1_7_0),
 	// Actual Destination
 	WME_WINENTRY("actualdest", "", 
 		WME_ENTRY1s("data.dcp", "6926f44b26f21ceb1d840eaab9aeb510", 9081740), Common::EN_ANY, ADGF_UNSTABLE, LATEST_VERSION),
@@ -334,6 +343,22 @@ static const WMEGameDescription gameDescriptions[] = {
 	// Oknytt
 	WME_WINENTRY("oknytt", "Version 1.0", 
 		WME_ENTRY1s("data.dcp", "6456cf8f429905c83f07509f9da536dd", 109502959), Common::EN_ANY, ADGF_UNSTABLE, LATEST_VERSION),
+	// Oknytt (Version 1.13 English) (These are detected along with d_sounds.dcp to avoid mass-detecting in the languages-subfolder.)
+	WME_WINENTRY("oknytt", "Version 1.13",
+		WME_ENTRY2s("english.dcp", "d2afd722c78cfe66b7d4250d11f6ae16", 293274135,
+					"d_sounds.dcp", "7d04dff8ca11174486bd4b7a80fdcabb", 154943401), Common::EN_ANY, ADGF_UNSTABLE, LATEST_VERSION),
+	// Oknytt (Version 1.13 German)
+	WME_WINENTRY("oknytt", "Version 1.13",
+		WME_ENTRY2s("german.dcp", "0fc6401d8d76b04f6da49206ecafa0dc", 304292574,
+					"d_sounds.dcp", "7d04dff8ca11174486bd4b7a80fdcabb", 154943401), Common::DE_DEU, ADGF_UNSTABLE, LATEST_VERSION),
+	// Oknytt (Version 1.13 Russian)
+	WME_WINENTRY("oknytt", "Version 1.13",
+		WME_ENTRY2s("russian.dcp", "dd24a1c0b36a82e2b02fb6c1050d4aad", 362681669,
+					"d_sounds.dcp", "7d04dff8ca11174486bd4b7a80fdcabb", 154943401), Common::RU_RUS, ADGF_UNSTABLE, LATEST_VERSION),
+	// Oknytt (Version 1.13 Spanish)
+	WME_WINENTRY("oknytt", "Version 1.13",
+		WME_ENTRY2s("spanish.dcp", "10c46152cb29581671f3b6b7c229c957", 319406572,
+					"d_sounds.dcp", "7d04dff8ca11174486bd4b7a80fdcabb", 154943401), Common::ES_ESP, ADGF_UNSTABLE, LATEST_VERSION),
 	// Night Train Demo
 	WME_WINENTRY("nighttrain", "", 
 		WME_ENTRY1s("data.dcp", "5a027ef84b083a730c9a4c85ec1d3a32", 131760816), Common::EN_ANY, ADGF_UNSTABLE | ADGF_DEMO, LATEST_VERSION),
diff --git a/engines/wintermute/utils/convert_utf.cpp b/engines/wintermute/utils/convert_utf.cpp
index 7ebc011d01..cdb48103d0 100644
--- a/engines/wintermute/utils/convert_utf.cpp
+++ b/engines/wintermute/utils/convert_utf.cpp
@@ -55,8 +55,6 @@ static const UTF32 halfMask = 0x3FFUL;
 #define UNI_SUR_HIGH_END    (UTF32)0xDBFF
 #define UNI_SUR_LOW_START   (UTF32)0xDC00
 #define UNI_SUR_LOW_END     (UTF32)0xDFFF
-#define false      0
-#define true        1
 
 /* --------------------------------------------------------------------- */
 
@@ -311,7 +309,7 @@ ConversionResult ConvertUTF16toUTF8(
  * definition of UTF-8 goes up to 4-byte sequences.
  */
 
-static Boolean isLegalUTF8(const UTF8 *source, int length) {
+static bool isLegalUTF8(const UTF8 *source, int length) {
 	UTF8 a;
 	const UTF8 *srcptr = source + length;
 	switch (length) {
@@ -356,7 +354,7 @@ static Boolean isLegalUTF8(const UTF8 *source, int length) {
  * Exported function to return whether a UTF-8 sequence is legal or not.
  * This is not used here; it's just exported.
  */
-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
+bool isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
 	int length = trailingBytesForUTF8[*source] + 1;
 	if (source + length > sourceEnd) {
 		return false;
diff --git a/engines/wintermute/utils/convert_utf.h b/engines/wintermute/utils/convert_utf.h
index a5f34456f5..d2e54f4af4 100644
--- a/engines/wintermute/utils/convert_utf.h
+++ b/engines/wintermute/utils/convert_utf.h
@@ -96,7 +96,6 @@ namespace Wintermute {
 typedef uint32  UTF32;  /* at least 32 bits */
 typedef uint16  UTF16;  /* at least 16 bits */
 typedef uint8   UTF8;   /* typically 8 bits */
-typedef uint8   Boolean; /* 0 or 1 */
 
 /* Some fundamental constants */
 #define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
@@ -141,7 +140,7 @@ ConversionResult ConvertUTF32toUTF16(
 	const UTF32 **sourceStart, const UTF32 *sourceEnd,
 	UTF16 **targetStart, UTF16 *targetEnd, ConversionFlags flags);
 
-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
+bool isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
 
 } // End of namespace Wintermute
 
diff --git a/engines/zvision/POTFILES b/engines/zvision/POTFILES
index 48e2782648..61cf42ded2 100644
--- a/engines/zvision/POTFILES
+++ b/engines/zvision/POTFILES
@@ -1 +1 @@
-engines/zvision/detection.cpp
+engines/zvision/detection_tables.h
diff --git a/engines/zvision/configure.engine b/engines/zvision/configure.engine
index 02e31943af..226870c3fd 100644
--- a/engines/zvision/configure.engine
+++ b/engines/zvision/configure.engine
@@ -1,3 +1,3 @@
 # This file is included from the main "configure" script
 # add_engine [name] [desc] [build-by-default] [subengines] [base games] [deps]
-add_engine zvision "ZVision" no "" "" "freetype2 16bit"
+add_engine zvision "Z-Vision" yes "" "" "freetype2 16bit"
diff --git a/engines/zvision/core/clock.h b/engines/zvision/core/clock.h
index cbf52be560..ae8c968111 100644
--- a/engines/zvision/core/clock.h
+++ b/engines/zvision/core/clock.h
@@ -67,14 +67,14 @@ public:
 	}
 
 	/**
-	 * Pause the clock. Any future delta times will take this pause into account.
-	 * Has no effect if the clock is already paused.
-	 */
+	* Un-pause the clock.
+	* Has no effect if the clock is already un-paused.
+	*/
 	void start();
 
 	/**
-	 * Un-pause the clock.
-	 * Has no effect if the clock is already un-paused.
+	 * Pause the clock. Any future delta times will take this pause into account.
+	 * Has no effect if the clock is already paused.
 	 */
 	void stop();
 };
diff --git a/engines/zvision/core/console.cpp b/engines/zvision/core/console.cpp
index 65821b1702..336541d82a 100644
--- a/engines/zvision/core/console.cpp
+++ b/engines/zvision/core/console.cpp
@@ -54,6 +54,8 @@ Console::Console(ZVision *engine) : GUI::Debugger(), _engine(engine) {
 	registerCmd("dumpfile", WRAP_METHOD(Console, cmdDumpFile));
 	registerCmd("dumpfiles", WRAP_METHOD(Console, cmdDumpFiles));
 	registerCmd("dumpimage", WRAP_METHOD(Console, cmdDumpImage));
+	registerCmd("statevalue", WRAP_METHOD(Console, cmdStateValue));
+	registerCmd("stateflag", WRAP_METHOD(Console, cmdStateFlag));
 }
 
 bool Console::cmdLoadVideo(int argc, const char **argv) {
@@ -204,7 +206,7 @@ bool Console::cmdLocation(int argc, const char **argv) {
 	Common::String scrFile = Common::String::format("%c%c%c%c.scr", curLocation.world, curLocation.room, curLocation.node, curLocation.view);
 	debugPrintf("Current location: world '%c', room '%c', node '%c', view '%c', offset %d, script %s\n",
 				curLocation.world, curLocation.room, curLocation.node, curLocation.view, curLocation.offset, scrFile.c_str());
-	
+
 	if (argc != 6) {
 		debugPrintf("Use %s <char: world> <char: room> <char:node> <char:view> <int: x offset> to change your location\n", argv[0]);
 		return true;
@@ -263,7 +265,8 @@ bool Console::cmdDumpFiles(int argc, const char **argv) {
 		debugPrintf("Dumping %s\n", fileName.c_str());
 
 		in = iter->_value.arch->createReadStreamForMember(iter->_value.name);
-		dumpFile(in, fileName.c_str());
+		if (in)
+			dumpFile(in, fileName.c_str());
 		delete in;
 	}
 
@@ -272,7 +275,7 @@ bool Console::cmdDumpFiles(int argc, const char **argv) {
 
 bool Console::cmdDumpImage(int argc, const char **argv) {
 	if (argc != 2) {
-		debugPrintf("Use %s <TGA/TGZ name> to dump a ZVision TGA/TGZ image into a regular BMP image\n", argv[0]);
+		debugPrintf("Use %s <TGA/TGZ name> to dump a Z-Vision TGA/TGZ image into a regular BMP image\n", argv[0]);
 		return true;
 	}
 
@@ -328,4 +331,40 @@ bool Console::cmdDumpImage(int argc, const char **argv) {
 	return true;
 }
 
+bool Console::cmdStateValue(int argc, const char **argv) {
+	if (argc < 2) {
+		debugPrintf("Use %s <valuenum> to show the value of a state variable\n", argv[0]);
+		debugPrintf("Use %s <valuenum> <newvalue> to set the value of a state variable\n", argv[0]);
+		return true;
+	}
+
+	int valueNum = atoi(argv[1]);
+	int newValue = (argc > 2) ? atoi(argv[2]) : -1;
+
+	if (argc == 2)
+		debugPrintf("[%d] = %d\n", valueNum, _engine->getScriptManager()->getStateValue(valueNum));
+	else if (argc == 3)
+		_engine->getScriptManager()->setStateValue(valueNum, newValue);
+
+	return true;
+}
+
+bool Console::cmdStateFlag(int argc, const char **argv) {
+	if (argc < 2) {
+		debugPrintf("Use %s <flagnum> to show the value of a state flag\n", argv[0]);
+		debugPrintf("Use %s <flagnum> <newvalue> to set the value of a state flag\n", argv[0]);
+		return true;
+	}
+
+	int valueNum = atoi(argv[1]);
+	int newValue = (argc > 2) ? atoi(argv[2]) : -1;
+
+	if (argc == 2)
+		debugPrintf("[%d] = %d\n", valueNum, _engine->getScriptManager()->getStateFlag(valueNum));
+	else if (argc == 3)
+		_engine->getScriptManager()->setStateFlag(valueNum, newValue);
+
+	return true;
+}
+
 } // End of namespace ZVision
diff --git a/engines/zvision/core/console.h b/engines/zvision/core/console.h
index ffce87869f..ac834185a0 100644
--- a/engines/zvision/core/console.h
+++ b/engines/zvision/core/console.h
@@ -48,6 +48,8 @@ private:
 	bool cmdDumpFile(int argc, const char **argv);
 	bool cmdDumpFiles(int argc, const char **argv);
 	bool cmdDumpImage(int argc, const char **argv);
+	bool cmdStateValue(int argc, const char **argv);
+	bool cmdStateFlag(int argc, const char **argv);
 };
 
 } // End of namespace ZVision
diff --git a/engines/zvision/core/events.cpp b/engines/zvision/core/events.cpp
index 7804130e2a..cc1c00b6d0 100644
--- a/engines/zvision/core/events.cpp
+++ b/engines/zvision/core/events.cpp
@@ -93,6 +93,11 @@ void ZVision::shortKeys(Common::Event event) {
 }
 
 void ZVision::cheatCodes(uint8 key) {
+	Location loc = _scriptManager->getCurrentLocation();
+	// Do not process cheat codes while in the game menus
+	if (loc.world == 'g' && loc.room == 'j')
+		return;
+
 	pushKeyToCheatBuf(key);
 
 	if (getGameId() == GID_GRANDINQUISITOR) {
@@ -146,9 +151,8 @@ void ZVision::cheatCodes(uint8 key) {
 		}
 
 		if (checkCode("HELLOSAILOR")) {
-			Location loc = _scriptManager->getCurrentLocation();
 			Audio::AudioStream *soundStream;
-			if (loc.world == 'v' && loc.room == 'b' && loc.node == '1' && loc.view == '0') {
+			if (loc == "vb10") {
 				soundStream = makeRawZorkStream("v000hpta.raw", this);
 			} else {
 				soundStream = makeRawZorkStream("v000hnta.raw", this);
@@ -336,7 +340,7 @@ void ZVision::onMouseMove(const Common::Point &pos) {
 					mspeed = 25;
 				}
 				_mouseVelocity  = MIN(((Common::Rational(mspeed, ROTATION_SCREEN_EDGE_OFFSET) * (clippedPos.x - _workingWindow.left)) - mspeed).toInt(), -1);
-				
+
 
 				_cursorManager->changeCursor(CursorIndex_Left);
 				cursorWasChanged = true;
diff --git a/engines/zvision/detection.cpp b/engines/zvision/detection.cpp
index 1295f76705..f44e653c2a 100644
--- a/engines/zvision/detection.cpp
+++ b/engines/zvision/detection.cpp
@@ -24,8 +24,9 @@
 
 #include "base/plugins.h"
 
+#include "engines/advancedDetector.h"
+
 #include "zvision/zvision.h"
-#include "zvision/detection.h"
 #include "zvision/file/save_manager.h"
 #include "zvision/scripting/script_manager.h"
 
@@ -36,198 +37,39 @@
 
 namespace ZVision {
 
-uint32 ZVision::getFeatures() const {
-	return _gameDescription->desc.flags;
-}
+struct ZVisionGameDescription {
+	ADGameDescription desc;
+	ZVisionGameId gameId;
+};
 
+ZVisionGameId ZVision::getGameId() const {
+	return _gameDescription->gameId;
+}
 Common::Language ZVision::getLanguage() const {
 	return _gameDescription->desc.language;
 }
+uint32 ZVision::getFeatures() const {
+	return _gameDescription->desc.flags;
+}
 
 } // End of namespace ZVision
 
-static const PlainGameDescriptor zVisionGames[] = {
-	{"zvision",  "ZVision Game"},
-	{"znemesis", "Zork Nemesis: The Forbidden Lands"},
-	{"zgi",      "Zork: Grand Inquisitor"},
-	{0, 0}
-};
-
-namespace ZVision {
-
-#define GAMEOPTION_ORIGINAL_SAVELOAD          GUIO_GAMEOPTIONS1
-#define GAMEOPTION_DOUBLE_FPS                 GUIO_GAMEOPTIONS2
-#define GAMEOPTION_ENABLE_VENUS               GUIO_GAMEOPTIONS3
-#define GAMEOPTION_DISABLE_ANIM_WHILE_TURNING GUIO_GAMEOPTIONS4
-#define GAMEOPTION_USE_HIRES_MPEG_MOVIES      GUIO_GAMEOPTIONS5
-
-static const ZVisionGameDescription gameDescriptions[] = {
-
-	{
-		// Zork Nemesis English version
-		{
-			"znemesis",
-			0,
-			AD_ENTRY1s("CSCR.ZFS", "88226e51a205d2e50c67a5237f3bd5f2", 2397741),
-			Common::EN_ANY,
-			Common::kPlatformDOS,
-			ADGF_NO_FLAGS,
-			GUIO4(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_ENABLE_VENUS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
-		},
-		GID_NEMESIS
-	},
-
-	{
-		// Zork Nemesis French version
-		{
-			"znemesis",
-			0,
-			AD_ENTRY1s("CSCR.ZFS", "f04113357b4748c13efcb58b4629887c", 2577873),
-			Common::FR_FRA,
-			Common::kPlatformDOS,
-			ADGF_NO_FLAGS,
-			GUIO4(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_ENABLE_VENUS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
-		},
-		GID_NEMESIS
-	},
-
-	{
-		// Zork Nemesis English demo version
-		{
-			"znemesis",
-			"Demo",
-			AD_ENTRY1s("SCRIPTS.ZFS", "64f1e881394e9462305104f99513c833", 380539),
-			Common::EN_ANY,
-			Common::kPlatformWindows,
-			ADGF_DEMO,
-			GUIO4(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_ENABLE_VENUS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
-		},
-		GID_NEMESIS
-	},
-
-	{
-		// Zork Grand Inquisitor English CD version
-		{
-			"zgi",
-			"CD",
-			AD_ENTRY1s("SCRIPTS.ZFS", "81efd40ecc3d22531e211368b779f17f", 8336944),
-			Common::EN_ANY,
-			Common::kPlatformWindows,
-			ADGF_NO_FLAGS,
-			GUIO3(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
-		},
-		GID_GRANDINQUISITOR
-	},
-
-	{
-		// Zork Grand Inquisitor English DVD version
-		{
-			"zgi",
-			"DVD",
-			AD_ENTRY1s("SCRIPTS.ZFS", "03157a3399513bfaaf8dc6d5ab798b36", 8433326),
-			Common::EN_ANY,
-			Common::kPlatformWindows,
-			ADGF_NO_FLAGS,
-			GUIO4(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING, GAMEOPTION_USE_HIRES_MPEG_MOVIES)
-		},
-		GID_GRANDINQUISITOR
-	},
-
-	{
-		// Zork Grand Inquisitor English demo version
-		{
-			"zgi",
-			"Demo",
-			AD_ENTRY1s("SCRIPTS.ZFS", "71a2494fd2fb999347deb13401e9b998", 304239),
-			Common::EN_ANY,
-			Common::kPlatformWindows,
-			ADGF_DEMO,
-			GUIO3(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
-		},
-		GID_GRANDINQUISITOR
-	},
-
-	{
-		AD_TABLE_END_MARKER,
-		GID_NONE
-	}
-};
-
-} // End of namespace ZVision
-
-static const char *directoryGlobs[] = {
-	"znemscr",
-	0
-};
-
-static const ADExtraGuiOptionsMap optionsList[] = {
-	{
-		GAMEOPTION_ORIGINAL_SAVELOAD,
-		{
-			_s("Use original save/load screens"),
-			_s("Use the original save/load screens, instead of the ScummVM ones"),
-			"originalsaveload",
-			false
-		}
-	},
-
-	{
-		GAMEOPTION_DOUBLE_FPS,
-		{
-			_s("Double FPS"),
-			_s("Increase game FPS from 30 to 60"),
-			"doublefps",
-			false
-		}
-	},
-
-	{
-		GAMEOPTION_ENABLE_VENUS,
-		{
-			_s("Enable Venus"),
-			_s("Enable the Venus help system"),
-			"venusenabled",
-			true
-		}
-	},
-
-	{
-		GAMEOPTION_DISABLE_ANIM_WHILE_TURNING,
-		{
-			_s("Disable animation while turning"),
-			_s("Disable animation while turning in panoramic mode"),
-			"noanimwhileturning",
-			false
-		}
-	},
-
-	{
-		GAMEOPTION_USE_HIRES_MPEG_MOVIES,
-		{
-			_s("Use the hires MPEG movies"),
-			_s("Use the hires MPEG movies of the DVD version, instead of the lowres AVI ones"),
-			"mpegmovies",
-			true
-		}
-	},
-
-	AD_EXTRA_GUI_OPTIONS_TERMINATOR
-};
+#include "zvision/detection_tables.h"
 
 class ZVisionMetaEngine : public AdvancedMetaEngine {
 public:
-	ZVisionMetaEngine() : AdvancedMetaEngine(ZVision::gameDescriptions, sizeof(ZVision::ZVisionGameDescription), zVisionGames, optionsList) {
+	ZVisionMetaEngine() : AdvancedMetaEngine(ZVision::gameDescriptions, sizeof(ZVision::ZVisionGameDescription), ZVision::zVisionGames, ZVision::optionsList) {
 		_maxScanDepth = 2;
-		_directoryGlobs = directoryGlobs;
+		_directoryGlobs = ZVision::directoryGlobs;
 		_singleid = "zvision";
 	}
 
 	virtual const char *getName() const {
-		return "ZVision";
+		return "Z-Vision";
 	}
 
 	virtual const char *getOriginalCopyright() const {
-		return "ZVision Activision (C) 1996";
+		return "Z-Vision (C) 1996 Activision";
 	}
 
 	virtual bool hasFeature(MetaEngineFeature f) const;
diff --git a/engines/zvision/detection_tables.h b/engines/zvision/detection_tables.h
new file mode 100644
index 0000000000..06bc58ee7f
--- /dev/null
+++ b/engines/zvision/detection_tables.h
@@ -0,0 +1,277 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef ZVISION_DETECTION_TABLES_H
+#define ZVISION_DETECTION_TABLES_H
+
+namespace ZVision {
+
+static const PlainGameDescriptor zVisionGames[] = {
+	{ "zvision", "Z-Vision Game" },
+	{ "znemesis", "Zork Nemesis: The Forbidden Lands" },
+	{ "zgi", "Zork: Grand Inquisitor" },
+	{ 0, 0 }
+};
+
+static const char *directoryGlobs[] = {
+	"znemscr",
+	0
+};
+
+#define GAMEOPTION_ORIGINAL_SAVELOAD          GUIO_GAMEOPTIONS1
+#define GAMEOPTION_DOUBLE_FPS                 GUIO_GAMEOPTIONS2
+#define GAMEOPTION_ENABLE_VENUS               GUIO_GAMEOPTIONS3
+#define GAMEOPTION_DISABLE_ANIM_WHILE_TURNING GUIO_GAMEOPTIONS4
+#define GAMEOPTION_USE_HIRES_MPEG_MOVIES      GUIO_GAMEOPTIONS5
+
+static const ADExtraGuiOptionsMap optionsList[] = {
+
+	{
+		GAMEOPTION_ORIGINAL_SAVELOAD,
+		{
+			_s("Use original save/load screens"),
+			_s("Use the original save/load screens instead of the ScummVM interface"),
+			"originalsaveload",
+			false
+		}
+	},
+
+	{
+		GAMEOPTION_DOUBLE_FPS,
+		{
+			_s("Double FPS"),
+			_s("Increase framerate from 30 to 60 FPS"),
+			"doublefps",
+			false
+		}
+	},
+
+	{
+		GAMEOPTION_ENABLE_VENUS,
+		{
+			_s("Enable Venus"),
+			_s("Enable the Venus help system"),
+			"venusenabled",
+			true
+		}
+	},
+
+	{
+		GAMEOPTION_DISABLE_ANIM_WHILE_TURNING,
+		{
+			_s("Disable animation while turning"),
+			_s("Disable animation while turning in panorama mode"),
+			"noanimwhileturning",
+			false
+		}
+	},
+
+	{
+		GAMEOPTION_USE_HIRES_MPEG_MOVIES,
+		{
+			_s("Use high resolution MPEG video"),
+			_s("Use MPEG video from the DVD version, instead of lower resolution AVI"),
+			"mpegmovies",
+			true
+		}
+	},
+
+	AD_EXTRA_GUI_OPTIONS_TERMINATOR
+};
+
+static const ZVisionGameDescription gameDescriptions[] = {
+
+	{
+		// Zork Nemesis English version
+		{
+			"znemesis",
+			0,
+			AD_ENTRY1s("CSCR.ZFS", "88226e51a205d2e50c67a5237f3bd5f2", 2397741),
+			Common::EN_ANY,
+			Common::kPlatformDOS,
+			ADGF_NO_FLAGS,
+			GUIO4(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_ENABLE_VENUS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
+		},
+		GID_NEMESIS
+	},
+
+	{
+		// Zork Nemesis French version
+		{
+			"znemesis",
+			0,
+			{
+				{ "CSCR.ZFS", 0, "f04113357b4748c13efcb58b4629887c", 2577873 },
+				{ "NEMESIS.STR", 0, "333bcb17bbb7f57cae742fbbe44f56f3", 9219 },
+				AD_LISTEND
+			},
+			Common::FR_FRA,
+			Common::kPlatformDOS,
+			ADGF_NO_FLAGS,
+			GUIO4(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_ENABLE_VENUS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
+		},
+		GID_NEMESIS
+	},
+
+	{
+		// Zork Nemesis German version
+		{
+			"znemesis",
+			0,
+			{
+				{ "CSCR.ZFS", 0, "f04113357b4748c13efcb58b4629887c", 2577873 },
+				{ "NEMESIS.STR", 0, "3d1a12b907751653866cffc6d4dfb331", 9505 },
+				AD_LISTEND
+			},
+			Common::DE_DEU,
+			Common::kPlatformDOS,
+			ADGF_NO_FLAGS,
+			GUIO4(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_ENABLE_VENUS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
+		},
+		GID_NEMESIS
+	},
+
+	{
+		// Zork Nemesis Italian version
+		{
+			"znemesis",
+			0,
+			{
+				{ "CSCR.ZFS", 0, "f04113357b4748c13efcb58b4629887c", 2577873 },
+				{ "NEMESIS.STR", 0, "7c568feca8d9f9ae855c47183612c305", 9061 },
+				AD_LISTEND
+			},
+			Common::IT_ITA,
+			Common::kPlatformDOS,
+			ADGF_NO_FLAGS,
+			GUIO4(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_ENABLE_VENUS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
+		},
+		GID_NEMESIS
+	},
+
+	{
+		// Zork Nemesis English demo version
+		{
+			"znemesis",
+			"Demo",
+			AD_ENTRY1s("SCRIPTS.ZFS", "64f1e881394e9462305104f99513c833", 380539),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			GUIO4(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_ENABLE_VENUS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
+		},
+		GID_NEMESIS
+	},
+
+	{
+		// Zork Grand Inquisitor English CD version
+		{
+			"zgi",
+			"CD",
+			AD_ENTRY1s("SCRIPTS.ZFS", "81efd40ecc3d22531e211368b779f17f", 8336944),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			GUIO3(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
+		},
+		GID_GRANDINQUISITOR
+	},
+
+	{
+		// Zork Grand Inquisitor French CD version, reported by ulrichh on IRC
+		{
+			"zgi",
+			"CD",
+			AD_ENTRY1s("SCRIPTS.ZFS", "4d1ec4ade7ecc9ee9ec591d43ca3d213", 8338133),
+			Common::FR_FRA,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			GUIO3(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
+		},
+		GID_GRANDINQUISITOR
+	},
+
+	{
+		// Zork Grand Inquisitor German CD version, reported by breit in bug #6760
+		{
+			"zgi",
+			"CD",
+			AD_ENTRY1s("SCRIPTS.ZFS", "b7ac7e331b9b7f884590b0b325b560c8", 8338133),
+			Common::DE_DEU,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			GUIO3(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
+		},
+		GID_GRANDINQUISITOR
+	},
+
+	{
+		// Zork Grand Inquisitor Spanish CD version, reported by dianiu in bug #6764
+		{
+			"zgi",
+			"CD",
+			AD_ENTRY1s("SCRIPTS.ZFS", "5cdc4b99c1134053af135aae71326fd1", 8338141),
+			Common::ES_ESP,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			GUIO3(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
+		},
+		GID_GRANDINQUISITOR
+	},
+
+	{
+		// Zork Grand Inquisitor English DVD version
+		{
+			"zgi",
+			"DVD",
+			AD_ENTRY1s("SCRIPTS.ZFS", "03157a3399513bfaaf8dc6d5ab798b36", 8433326),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_NO_FLAGS,
+			GUIO4(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING, GAMEOPTION_USE_HIRES_MPEG_MOVIES)
+		},
+		GID_GRANDINQUISITOR
+	},
+
+	{
+		// Zork Grand Inquisitor English demo version
+		{
+			"zgi",
+			"Demo",
+			AD_ENTRY1s("SCRIPTS.ZFS", "71a2494fd2fb999347deb13401e9b998", 304239),
+			Common::EN_ANY,
+			Common::kPlatformWindows,
+			ADGF_DEMO,
+			GUIO3(GAMEOPTION_ORIGINAL_SAVELOAD, GAMEOPTION_DOUBLE_FPS, GAMEOPTION_DISABLE_ANIM_WHILE_TURNING)
+		},
+		GID_GRANDINQUISITOR
+	},
+
+	{
+		AD_TABLE_END_MARKER,
+		GID_NONE
+	}
+};
+
+} // End of namespace ZVision
+
+#endif
diff --git a/engines/zvision/file/lzss_read_stream.cpp b/engines/zvision/file/lzss_read_stream.cpp
index 6f27eaa765..ca10af7d72 100644
--- a/engines/zvision/file/lzss_read_stream.cpp
+++ b/engines/zvision/file/lzss_read_stream.cpp
@@ -31,8 +31,9 @@ LzssReadStream::LzssReadStream(Common::SeekableReadStream *source)
 	  // It's convention to set the starting cursor position to blockSize - 16
 	  _windowCursor(0x0FEE),
 	  _eosFlag(false) {
-	// Clear the window to null
-	memset(_window, 0, BLOCK_SIZE);
+	// All values up to _windowCursor inits by 0x20
+	memset(_window, 0x20, _windowCursor);
+	memset(_window + _windowCursor, 0, BLOCK_SIZE - _windowCursor);
 }
 
 uint32 LzssReadStream::decompressBytes(byte *destination, uint32 numberOfBytes) {
diff --git a/engines/zvision/file/save_manager.cpp b/engines/zvision/file/save_manager.cpp
index fb9cceecbe..d169679e28 100644
--- a/engines/zvision/file/save_manager.cpp
+++ b/engines/zvision/file/save_manager.cpp
@@ -130,12 +130,27 @@ void SaveManager::writeSaveGameHeader(Common::OutSaveFile *file, const Common::S
 	file->writeSint16LE(td.tm_min);
 }
 
-Common::Error SaveManager::loadGame(uint slot) {
-	Common::SeekableReadStream *saveFile = getSlotFile(slot);
-	if (saveFile == 0) {
-		return Common::kPathDoesNotExist;
+Common::Error SaveManager::loadGame(int slot) {
+	Common::SeekableReadStream *saveFile = NULL;
+
+	if (slot >= 0) {
+		saveFile = getSlotFile(slot);
+	} else {
+		saveFile = _engine->getSearchManager()->openFile("r.svr");
+		if (!saveFile) {
+			Common::File *restoreFile = new Common::File();
+			if (!restoreFile->open("r.svr")) {
+				delete restoreFile;
+				return Common::kPathDoesNotExist;
+			}
+
+			saveFile = restoreFile;
+		}
 	}
 
+	if (!saveFile)
+		return Common::kPathDoesNotExist;
+
 	// Read the header
 	SaveGameHeader header;
 	if (!readSaveGameHeader(saveFile, header)) {
@@ -150,6 +165,27 @@ Common::Error SaveManager::loadGame(uint slot) {
 	if (header.thumbnail)
 		delete header.thumbnail;
 
+	if (_engine->getGameId() == GID_NEMESIS && scriptManager->getCurrentLocation() == "tv2f") {
+		// WORKAROUND for script bug #6793: location tv2f (stairs) has two states:
+		// one at the top of the stairs, and one at the bottom. When the player
+		// goes to the bottom of the stairs, the screen changes, and hotspot
+		// 4652 (exit opposite the stairs) is enabled. However, the variable that
+		// controls the state (2408) is reset when the player goes down the stairs.
+		// Furthermore, the room's initialization script disables the stair exit
+		// control (4652). This leads to an impossible situation, where all the
+		// exit controls are disabled, and the player can't more anywhere. Thus,
+		// when loading a game in that room, we check for that impossible
+		// situation, which only occurs after the player has moved down the stairs,
+		// and fix it here by setting the correct background, and enabling the
+		// stair exit hotspot.
+		if ((scriptManager->getStateFlag(2411) & Puzzle::DISABLED) &&
+			(scriptManager->getStateFlag(2408) & Puzzle::DISABLED) &&
+			(scriptManager->getStateFlag(4652) & Puzzle::DISABLED)) {
+			_engine->getRenderManager()->setBackgroundImage("tv2fb21c.tga");
+			scriptManager->unsetStateFlag(4652, Puzzle::DISABLED);
+		}
+	}
+
 	return Common::kNoError;
 }
 
@@ -169,7 +205,7 @@ bool SaveManager::readSaveGameHeader(Common::InSaveFile *in, SaveGameHeader &hea
 		return true;
 	}
 	if (tag != SAVEGAME_ID) {
-		warning("File is not a ZVision save file. Aborting load");
+		warning("File is not a Z-Vision save file. Aborting load");
 		return false;
 	}
 
diff --git a/engines/zvision/file/save_manager.h b/engines/zvision/file/save_manager.h
index d3f6aaaedc..9e816373ea 100644
--- a/engines/zvision/file/save_manager.h
+++ b/engines/zvision/file/save_manager.h
@@ -91,7 +91,7 @@ public:
 	 *
 	 * @param slot    The save slot to load. Must be [1, 20]
 	 */
-	Common::Error loadGame(uint slot);
+	Common::Error loadGame(int slot);
 
 	Common::SeekableReadStream *getSlotFile(uint slot);
 	bool readSaveGameHeader(Common::SeekableReadStream *in, SaveGameHeader &header);
diff --git a/engines/zvision/file/search_manager.cpp b/engines/zvision/file/search_manager.cpp
index 9f709dd0a1..821b85b053 100644
--- a/engines/zvision/file/search_manager.cpp
+++ b/engines/zvision/file/search_manager.cpp
@@ -184,6 +184,16 @@ bool SearchManager::loadZix(const Common::String &name) {
 			if (path.size() && path.hasSuffix("/"))
 				path.deleteLastChar();
 
+			// Handle paths in case-sensitive file systems (bug #6775)
+			if (path.size()) {
+				for (Common::List<Common::String>::iterator it = _dirList.begin(); it != _dirList.end(); ++it) {
+					if (path.equalsIgnoreCase(*it)) {
+						path = *it;
+						break;
+					}
+				}
+			}
+
 			if (path.matchString("*.zfs", true)) {
 				arc = new ZfsArchive(path);
 			} else {
diff --git a/engines/zvision/graphics/cursors/cursor_manager.cpp b/engines/zvision/graphics/cursors/cursor_manager.cpp
index 1e048efedf..eeab18f4ba 100644
--- a/engines/zvision/graphics/cursors/cursor_manager.cpp
+++ b/engines/zvision/graphics/cursors/cursor_manager.cpp
@@ -124,31 +124,30 @@ void CursorManager::cursorDown(bool pushed) {
 }
 
 void CursorManager::changeCursor(int id) {
-	int _id = id;
-
-	if (_item &&
-	        (_id == CursorIndex_Active ||
-	         _id == CursorIndex_Idle ||
-	         _id == CursorIndex_HandPu)) {
-
-		if (_id == CursorIndex_Idle)
-			_id = CursorIndex_ItemIdle;
-		else
-			_id = CursorIndex_ItemAct;
+	if (_item && (id == CursorIndex_Active ||
+	              id == CursorIndex_Idle ||
+	              id == CursorIndex_HandPu)) {
+		if (id == CursorIndex_Idle) {
+			id = CursorIndex_ItemIdle;
+		} else {
+			id = CursorIndex_ItemAct;
+		}
 	}
 
-	if (_currentCursor != _id ||
-	        ((_id == CursorIndex_ItemAct || _id == CursorIndex_ItemIdle) && _lastitem != _item)) {
-		_currentCursor = _id;
+	if (_currentCursor != id || ((id == CursorIndex_ItemAct || id == CursorIndex_ItemIdle) && _lastitem != _item)) {
+		_currentCursor = id;
 		_lastitem = _item;
 		changeCursor(_cursors[_currentCursor][_cursorIsPushed]);
 	}
 }
 
 int CursorManager::getCursorId(const Common::String &name) {
-	for (int i = 0; i < NUM_CURSORS; i++)
-		if (name.equals(_cursorNames[i]))
+	for (int i = 0; i < NUM_CURSORS; i++) {
+		if (name.equals(_cursorNames[i])) {
 			return i;
+		}
+	}
+
 	return CursorIndex_Idle;
 }
 
diff --git a/engines/zvision/graphics/effects/fog.cpp b/engines/zvision/graphics/effects/fog.cpp
index 32a01915d3..7b65f60f24 100644
--- a/engines/zvision/graphics/effects/fog.cpp
+++ b/engines/zvision/graphics/effects/fog.cpp
@@ -142,9 +142,9 @@ void FogFx::update() {
 
 		for (uint8 i = 0; i < 31; i++) {
 			float perc = (float)i / 31.0;
-			uint8 cr = (float)_r * perc;
-			uint8 cg = (float)_g * perc;
-			uint8 cb = (float)_b * perc;
+			uint8 cr = (uint8)((float)_r * perc);
+			uint8 cg = (uint8)((float)_g * perc);
+			uint8 cb = (uint8)((float)_b * perc);
 			_colorMap[i] = _engine->_resourcePixelFormat.RGBToColor(cr << 3, cg << 3, cb << 3);
 		}
 	}
diff --git a/engines/zvision/graphics/effects/wave.cpp b/engines/zvision/graphics/effects/wave.cpp
index cec631611b..d2887b3112 100644
--- a/engines/zvision/graphics/effects/wave.cpp
+++ b/engines/zvision/graphics/effects/wave.cpp
@@ -54,7 +54,7 @@ WaveFx::WaveFx(ZVision *engine, uint32 key, Common::Rect region, bool ported, in
 				int16 dx = (x - quarterWidth);
 				int16 dy = (y - quarterHeight);
 
-				_ampls[i][x + y * _halfWidth] = ampl * sin(sqrt(dx * dx / (float)centerX + dy * dy / (float)centerY) / (-waveln * 3.1415926) + phase);
+				_ampls[i][x + y * _halfWidth] = (int8)(ampl * sin(sqrt(dx * dx / (float)centerX + dy * dy / (float)centerY) / (-waveln * 3.1415926) + phase));
 			}
 		phase += spd;
 	}
diff --git a/engines/zvision/graphics/render_manager.cpp b/engines/zvision/graphics/render_manager.cpp
index a1cc8ac53c..f978ef7844 100644
--- a/engines/zvision/graphics/render_manager.cpp
+++ b/engines/zvision/graphics/render_manager.cpp
@@ -42,28 +42,25 @@ namespace ZVision {
 RenderManager::RenderManager(ZVision *engine, uint32 windowWidth, uint32 windowHeight, const Common::Rect workingWindow, const Graphics::PixelFormat pixelFormat, bool doubleFPS)
 	: _engine(engine),
 	  _system(engine->_system),
-	  _workingWidth(workingWindow.width()),
-	  _workingHeight(workingWindow.height()),
-	  _screenCenterX(_workingWidth / 2),
-	  _screenCenterY(_workingHeight / 2),
+	  _screenCenterX(_workingWindow.width() / 2),
+	  _screenCenterY(_workingWindow.height() / 2),
 	  _workingWindow(workingWindow),
 	  _pixelFormat(pixelFormat),
 	  _backgroundWidth(0),
 	  _backgroundHeight(0),
 	  _backgroundOffset(0),
-	  _renderTable(_workingWidth, _workingHeight),
-	  _doubleFPS(doubleFPS) {
+	  _renderTable(_workingWindow.width(), _workingWindow.height()),
+	  _doubleFPS(doubleFPS),
+	  _subid(0) {
 
-	_backgroundSurface.create(_workingWidth, _workingHeight, _pixelFormat);
-	_effectSurface.create(_workingWidth, _workingHeight, _pixelFormat);
-	_warpedSceneSurface.create(_workingWidth, _workingHeight, _pixelFormat);
+	_backgroundSurface.create(_workingWindow.width(), _workingWindow.height(), _pixelFormat);
+	_effectSurface.create(_workingWindow.width(), _workingWindow.height(), _pixelFormat);
+	_warpedSceneSurface.create(_workingWindow.width(), _workingWindow.height(), _pixelFormat);
 	_menuSurface.create(windowWidth, workingWindow.top, _pixelFormat);
-	_subtitleSurface.create(windowWidth, windowHeight - workingWindow.bottom, _pixelFormat);
 
 	_menuArea = Common::Rect(0, 0, windowWidth, workingWindow.top);
-	_subtitleArea = Common::Rect(0, workingWindow.bottom, windowWidth, windowHeight);
 
-	_subid = 0;
+	initSubArea(windowWidth, windowHeight, workingWindow);
 }
 
 RenderManager::~RenderManager() {
@@ -83,7 +80,7 @@ void RenderManager::renderSceneToScreen() {
 	// If we have graphical effects, we apply them using a temporary buffer
 	if (!_effects.empty()) {
 		bool copied = false;
-		Common::Rect windowRect(_workingWidth, _workingHeight);
+		Common::Rect windowRect(_workingWindow.width(), _workingWindow.height());
 
 		for (EffectsList::iterator it = _effects.begin(); it != _effects.end(); it++) {
 			Common::Rect rect = (*it)->getRegion();
@@ -121,7 +118,7 @@ void RenderManager::renderSceneToScreen() {
 		if (!_backgroundSurfaceDirtyRect.isEmpty()) {
 			_renderTable.mutateImage(&_warpedSceneSurface, in);
 			out = &_warpedSceneSurface;
-			outWndDirtyRect = Common::Rect(_workingWidth, _workingHeight);
+			outWndDirtyRect = Common::Rect(_workingWindow.width(), _workingWindow.height());
 		}
 	} else {
 		out = in;
@@ -199,7 +196,7 @@ void RenderManager::readImageToSurface(const Common::String &fileName, Graphics:
 	uint32 imageHeight;
 	Image::TGADecoder tga;
 	uint16 *buffer;
-	// All ZVision images are in RGB 555
+	// All Z-Vision images are in RGB 555
 	destination.format = _engine->_resourcePixelFormat;
 
 	bool isTGZ;
@@ -590,7 +587,7 @@ void RenderManager::prepareBackground() {
 
 	if (state == RenderTable::PANORAMA) {
 		// Calculate the visible portion of the background
-		Common::Rect viewPort(_workingWidth, _workingHeight);
+		Common::Rect viewPort(_workingWindow.width(), _workingWindow.height());
 		viewPort.translate(-(_screenCenterX - _backgroundOffset), 0);
 		Common::Rect drawRect = _backgroundDirtyRect;
 		drawRect.clip(viewPort);
@@ -604,7 +601,7 @@ void RenderManager::prepareBackground() {
 		_backgroundSurfaceDirtyRect = _backgroundDirtyRect;
 		_backgroundSurfaceDirtyRect.translate(_screenCenterX - _backgroundOffset, 0);
 
-		// Panorama mode allows the user to spin in circles. Therefore, we need to render 
+		// Panorama mode allows the user to spin in circles. Therefore, we need to render
 		// the portion of the image that wrapped to the other side of the screen
 		if (_backgroundOffset < _screenCenterX) {
 			viewPort.moveTo(-(_screenCenterX - (_backgroundOffset + _backgroundWidth)), 0);
@@ -635,7 +632,7 @@ void RenderManager::prepareBackground() {
 		}
 	} else if (state == RenderTable::TILT) {
 		// Tilt doesn't allow wrapping, so we just do a simple clip
-		Common::Rect viewPort(_workingWidth, _workingHeight);
+		Common::Rect viewPort(_workingWindow.width(), _workingWindow.height());
 		viewPort.translate(0, -(_screenCenterY - _backgroundOffset));
 		Common::Rect drawRect = _backgroundDirtyRect;
 		drawRect.clip(viewPort);
@@ -655,7 +652,7 @@ void RenderManager::prepareBackground() {
 	// Clear the dirty rect since everything is clean now
 	_backgroundDirtyRect = Common::Rect();
 
-	_backgroundSurfaceDirtyRect.clip(_workingWidth, _workingHeight);
+	_backgroundSurfaceDirtyRect.clip(_workingWindow.width(), _workingWindow.height());
 }
 
 void RenderManager::clearMenuSurface() {
@@ -687,6 +684,15 @@ void RenderManager::renderMenuToScreen() {
 	}
 }
 
+void RenderManager::initSubArea(uint32 windowWidth, uint32 windowHeight, const Common::Rect workingWindow) {
+	_workingWindow = workingWindow;
+
+	_subtitleSurface.free();
+
+	_subtitleSurface.create(windowWidth, windowHeight - workingWindow.bottom, _pixelFormat);
+	_subtitleArea = Common::Rect(0, workingWindow.bottom, windowWidth, windowHeight);
+}
+
 uint16 RenderManager::createSubArea(const Common::Rect &area) {
 	_subid++;
 
@@ -747,13 +753,12 @@ void RenderManager::processSubs(uint16 deltatime) {
 		for (SubtitleMap::iterator it = _subsList.begin(); it != _subsList.end(); it++) {
 			OneSubtitle *sub = &it->_value;
 			if (sub->txt.size()) {
-				Graphics::Surface *rndr = new Graphics::Surface();
-				rndr->create(sub->r.width(), sub->r.height(), _engine->_resourcePixelFormat);
-				_engine->getTextRenderer()->drawTxtInOneLine(sub->txt, *rndr);
+				Graphics::Surface subtitleSurface;
+				subtitleSurface.create(sub->r.width(), sub->r.height(), _engine->_resourcePixelFormat);
+				_engine->getTextRenderer()->drawTextWithWordWrapping(sub->txt, subtitleSurface);
 				Common::Rect empty;
-				blitSurfaceToSurface(*rndr, empty, _subtitleSurface, sub->r.left - _subtitleArea.left + _workingWindow.left, sub->r.top - _subtitleArea.top + _workingWindow.top);
-				rndr->free();
-				delete rndr;
+				blitSurfaceToSurface(subtitleSurface, empty, _subtitleSurface, sub->r.left - _subtitleArea.left + _workingWindow.left, sub->r.top - _subtitleArea.top + _workingWindow.top);
+				subtitleSurface.free();
 			}
 			sub->redraw = false;
 		}
@@ -791,8 +796,8 @@ Common::Rect RenderManager::transformBackgroundSpaceRectToScreenSpace(const Comm
 
 	if (state == RenderTable::PANORAMA) {
 		if (_backgroundOffset < _screenCenterX) {
-			Common::Rect rScreen(_screenCenterX + _backgroundOffset, _workingHeight);
-			Common::Rect lScreen(_workingWidth - rScreen.width(), _workingHeight);
+			Common::Rect rScreen(_screenCenterX + _backgroundOffset, _workingWindow.height());
+			Common::Rect lScreen(_workingWindow.width() - rScreen.width(), _workingWindow.height());
 			lScreen.translate(_backgroundWidth - lScreen.width(), 0);
 			lScreen.clip(src);
 			rScreen.clip(src);
@@ -802,8 +807,8 @@ Common::Rect RenderManager::transformBackgroundSpaceRectToScreenSpace(const Comm
 				tmp.translate(_screenCenterX - _backgroundOffset, 0);
 			}
 		} else if (_backgroundWidth - _backgroundOffset < _screenCenterX) {
-			Common::Rect rScreen(_screenCenterX - (_backgroundWidth - _backgroundOffset), _workingHeight);
-			Common::Rect lScreen(_workingWidth - rScreen.width(), _workingHeight);
+			Common::Rect rScreen(_screenCenterX - (_backgroundWidth - _backgroundOffset), _workingWindow.height());
+			Common::Rect lScreen(_workingWindow.width() - rScreen.width(), _workingWindow.height());
 			lScreen.translate(_backgroundWidth - lScreen.width(), 0);
 			lScreen.clip(src);
 			rScreen.clip(src);
@@ -965,16 +970,15 @@ void RenderManager::bkgFill(uint8 r, uint8 g, uint8 b) {
 void RenderManager::timedMessage(const Common::String &str, uint16 milsecs) {
 	uint16 msgid = createSubArea();
 	updateSubArea(msgid, str);
-	processSubs(0);
-	renderSceneToScreen();
 	deleteSubArea(msgid, milsecs);
 }
 
 bool RenderManager::askQuestion(const Common::String &str) {
-	uint16 msgid = createSubArea();
-	updateSubArea(msgid, str);
-	processSubs(0);
-	renderSceneToScreen();
+	Graphics::Surface textSurface;
+	textSurface.create(_subtitleArea.width(), _subtitleArea.height(), _engine->_resourcePixelFormat);
+	_engine->getTextRenderer()->drawTextWithWordWrapping(str, textSurface);
+	copyToScreen(textSurface, _subtitleArea, 0, 0);
+
 	_engine->stopClock();
 
 	int result = 0;
@@ -983,14 +987,38 @@ bool RenderManager::askQuestion(const Common::String &str) {
 		Common::Event evnt;
 		while (_engine->getEventManager()->pollEvent(evnt)) {
 			if (evnt.type == Common::EVENT_KEYDOWN) {
+				// English: yes/no
+				// German: ja/nein
+				// Spanish: si/no
+				// French Nemesis: F4/any other key
+				// French ZGI: oui/non
 				switch (evnt.kbd.keycode) {
 				case Common::KEYCODE_y:
-					result = 2;
+					if (_engine->getLanguage() == Common::EN_ANY)
+						result = 2;
+					break;
+				case Common::KEYCODE_j:
+					if (_engine->getLanguage() == Common::DE_DEU)
+						result = 2;
+					break;
+				case Common::KEYCODE_s:
+					if (_engine->getLanguage() == Common::ES_ESP)
+						result = 2;
+					break;
+				case Common::KEYCODE_o:
+					if (_engine->getLanguage() == Common::FR_FRA && _engine->getGameId() == GID_GRANDINQUISITOR)
+						result = 2;
+					break;
+				case Common::KEYCODE_F4:
+					if (_engine->getLanguage() == Common::FR_FRA && _engine->getGameId() == GID_NEMESIS)
+						result = 2;
 					break;
 				case Common::KEYCODE_n:
 					result = 1;
 					break;
 				default:
+					if (_engine->getLanguage() == Common::FR_FRA && _engine->getGameId() == GID_NEMESIS)
+						result = 1;
 					break;
 				}
 			}
@@ -1001,7 +1029,14 @@ bool RenderManager::askQuestion(const Common::String &str) {
 		else
 			_system->delayMillis(66);
 	}
-	deleteSubArea(msgid);
+
+	// Draw over the text in order to clear it
+	textSurface.fillRect(Common::Rect(_subtitleArea.width(), _subtitleArea.height()), 0);
+	copyToScreen(textSurface, _subtitleArea, 0, 0);
+
+	// Free the surface
+	textSurface.free();
+
 	_engine->startClock();
 	return result == 2;
 }
@@ -1073,7 +1108,7 @@ void RenderManager::updateRotation() {
 			int16 newPosition = startPosition + _velocity;
 
 			int16 screenHeight = getBkgSize().y;
-			int16 tiltGap = _renderTable.getTiltGap();
+			int16 tiltGap = (int16)_renderTable.getTiltGap();
 
 			if (newPosition >= (screenHeight - tiltGap))
 				newPosition = screenHeight - tiltGap;
@@ -1108,7 +1143,7 @@ void RenderManager::checkBorders() {
 		int16 newPosition = startPosition;
 
 		int16 screenHeight = getBkgSize().y;
-		int16 tiltGap = _renderTable.getTiltGap();
+		int16 tiltGap = (int16)_renderTable.getTiltGap();
 
 		if (newPosition >= (screenHeight - tiltGap))
 			newPosition = screenHeight - tiltGap;
@@ -1172,4 +1207,11 @@ void RenderManager::rotateTo(int16 _toPos, int16 _time) {
 	_engine->startClock();
 }
 
+void RenderManager::upscaleRect(Common::Rect &rect) {
+	rect.top = rect.top * HIRES_WINDOW_HEIGHT / WINDOW_HEIGHT;
+	rect.left = rect.left * HIRES_WINDOW_WIDTH / WINDOW_WIDTH;
+	rect.bottom = rect.bottom * HIRES_WINDOW_HEIGHT / WINDOW_HEIGHT;
+	rect.right = rect.right * HIRES_WINDOW_WIDTH / WINDOW_WIDTH;
+}
+
 } // End of namespace ZVision
diff --git a/engines/zvision/graphics/render_manager.h b/engines/zvision/graphics/render_manager.h
index c22f9a78c9..33d8a88e78 100644
--- a/engines/zvision/graphics/render_manager.h
+++ b/engines/zvision/graphics/render_manager.h
@@ -73,12 +73,8 @@ private:
 	 * are given in this coordinate space. Also, all images are clipped to the
 	 * edges of this Rectangle
 	 */
-	const Common::Rect _workingWindow;
+	Common::Rect _workingWindow;
 
-	// Width of the working window. Saved to prevent extraneous calls to _workingWindow.width()
-	const int _workingWidth;
-	// Height of the working window. Saved to prevent extraneous calls to _workingWindow.height()
-	const int _workingHeight;
 	// Center of the screen in the x direction
 	const int _screenCenterX;
 	// Center of the screen in the y direction
@@ -88,7 +84,7 @@ private:
 	Graphics::Surface _currentBackgroundImage;
 	Common::Rect _backgroundDirtyRect;
 
-	/** 
+	/**
 	 * The x1 or y1 offset of the subRectangle of the background that is currently displayed on the screen
 	 * It will be x1 if PANORAMA, or y1 if TILT
 	 */
@@ -106,7 +102,6 @@ private:
 
 	// A buffer for subtitles
 	Graphics::Surface _subtitleSurface;
-	Common::Rect _subtitleSurfaceDirtyRect;
 
 	// Rectangle for subtitles area
 	Common::Rect _subtitleArea;
@@ -138,7 +133,7 @@ private:
 	EffectsList _effects;
 
 	bool _doubleFPS;
-	
+
 public:
 	void initialize();
 
@@ -242,6 +237,8 @@ public:
 
 	// Subtitles methods
 
+	void initSubArea(uint32 windowWidth, uint32 windowHeight, const Common::Rect workingWindow);
+
 	// Create subtitle area and return ID
 	uint16 createSubArea(const Common::Rect &area);
 	uint16 createSubArea();
@@ -335,6 +332,8 @@ public:
 	void checkBorders();
 	void rotateTo(int16 to, int16 time);
 	void updateRotation();
+
+	void upscaleRect(Common::Rect &rect);
 };
 
 } // End of namespace ZVision
diff --git a/engines/zvision/scripting/actions.cpp b/engines/zvision/scripting/actions.cpp
index f60fdbb973..e1380b0eb2 100644
--- a/engines/zvision/scripting/actions.cpp
+++ b/engines/zvision/scripting/actions.cpp
@@ -23,11 +23,12 @@
 #include "common/scummsys.h"
 #include "video/video_decoder.h"
 
+#include "zvision/scripting/actions.h"
+
 #include "zvision/zvision.h"
 #include "zvision/scripting/script_manager.h"
 #include "zvision/graphics/render_manager.h"
 #include "zvision/file/save_manager.h"
-#include "zvision/scripting/actions.h"
 #include "zvision/scripting/menu.h"
 #include "zvision/scripting/effects/timer_effect.h"
 #include "zvision/scripting/effects/music_effect.h"
@@ -46,12 +47,18 @@
 
 namespace ZVision {
 
+ResultAction::ResultAction(ZVision *engine, int32 slotKey) :
+	_engine(engine),
+	_slotKey(slotKey),
+	_scriptManager(engine->getScriptManager()) {
+}
+
 //////////////////////////////////////////////////////////////////////////////
 // ActionAdd
 //////////////////////////////////////////////////////////////////////////////
 
-ActionAdd::ActionAdd(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionAdd::ActionAdd(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_key = 0;
 	_value = 0;
 
@@ -59,7 +66,7 @@ ActionAdd::ActionAdd(ZVision *engine, int32 slotkey, const Common::String &line)
 }
 
 bool ActionAdd::execute() {
-	_engine->getScriptManager()->setStateValue(_key, _engine->getScriptManager()->getStateValue(_key) + _value);
+	_scriptManager->setStateValue(_key, _scriptManager->getStateValue(_key) + _value);
 	return true;
 }
 
@@ -67,23 +74,22 @@ bool ActionAdd::execute() {
 // ActionAssign
 //////////////////////////////////////////////////////////////////////////////
 
-ActionAssign::ActionAssign(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionAssign::ActionAssign(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_key = 0;
 
 	char buf[64];
 	memset(buf, 0, 64);
 	sscanf(line.c_str(), "%u, %s", &_key, buf);
-	_value = new ValueSlot(_engine->getScriptManager(), buf);
+	_value = new ValueSlot(_scriptManager, buf);
 }
 
 ActionAssign::~ActionAssign() {
-	if (_value)
-		delete _value;
+	delete _value;
 }
 
 bool ActionAssign::execute() {
-	_engine->getScriptManager()->setStateValue(_key, _value->getValue());
+	_scriptManager->setStateValue(_key, _value->getValue());
 	return true;
 }
 
@@ -91,8 +97,8 @@ bool ActionAssign::execute() {
 // ActionAttenuate
 //////////////////////////////////////////////////////////////////////////////
 
-ActionAttenuate::ActionAttenuate(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionAttenuate::ActionAttenuate(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_key = 0;
 	_attenuation = 0;
 
@@ -100,10 +106,10 @@ ActionAttenuate::ActionAttenuate(ZVision *engine, int32 slotkey, const Common::S
 }
 
 bool ActionAttenuate::execute() {
-	ScriptingEffect *fx = _engine->getScriptManager()->getSideFX(_key);
+	ScriptingEffect *fx = _scriptManager->getSideFX(_key);
 	if (fx && fx->getType() == ScriptingEffect::SCRIPTING_EFFECT_AUDIO) {
-		MusicNode *mus = (MusicNode *)fx;
-		mus->setVolume(255 - (abs(_attenuation) >> 7));
+		MusicNodeBASE *mus = (MusicNodeBASE *)fx;
+		mus->setVolume(255 * (10000 - abs(_attenuation)) / 10000 );
 	}
 	return true;
 }
@@ -112,8 +118,8 @@ bool ActionAttenuate::execute() {
 // ActionChangeLocation
 //////////////////////////////////////////////////////////////////////////////
 
-ActionChangeLocation::ActionChangeLocation(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionChangeLocation::ActionChangeLocation(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_world = 'g';
 	_room = 'a';
 	_node = 'r';
@@ -125,7 +131,7 @@ ActionChangeLocation::ActionChangeLocation(ZVision *engine, int32 slotkey, const
 
 bool ActionChangeLocation::execute() {
 	// We can't directly call ScriptManager::ChangeLocationIntern() because doing so clears all the Puzzles, and thus would corrupt the current puzzle checking
-	_engine->getScriptManager()->changeLocation(_world, _room, _node, _view, _offset);
+	_scriptManager->changeLocation(_world, _room, _node, _view, _offset);
 	// Tell the puzzle system to stop checking any more puzzles
 	return false;
 }
@@ -134,8 +140,8 @@ bool ActionChangeLocation::execute() {
 // ActionCrossfade
 //////////////////////////////////////////////////////////////////////////////
 
-ActionCrossfade::ActionCrossfade(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionCrossfade::ActionCrossfade(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_keyOne = 0;
 	_keyTwo = 0;
 	_oneStartVolume = 0;
@@ -151,9 +157,9 @@ ActionCrossfade::ActionCrossfade(ZVision *engine, int32 slotkey, const Common::S
 
 bool ActionCrossfade::execute() {
 	if (_keyOne) {
-		ScriptingEffect *fx = _engine->getScriptManager()->getSideFX(_keyOne);
+		ScriptingEffect *fx = _scriptManager->getSideFX(_keyOne);
 		if (fx && fx->getType() == ScriptingEffect::SCRIPTING_EFFECT_AUDIO) {
-			MusicNode *mus = (MusicNode *)fx;
+			MusicNodeBASE *mus = (MusicNodeBASE *)fx;
 			if (_oneStartVolume >= 0)
 				mus->setVolume((_oneStartVolume * 255) / 100);
 
@@ -162,9 +168,9 @@ bool ActionCrossfade::execute() {
 	}
 
 	if (_keyTwo) {
-		ScriptingEffect *fx = _engine->getScriptManager()->getSideFX(_keyTwo);
+		ScriptingEffect *fx = _scriptManager->getSideFX(_keyTwo);
 		if (fx && fx->getType() == ScriptingEffect::SCRIPTING_EFFECT_AUDIO) {
-			MusicNode *mus = (MusicNode *)fx;
+			MusicNodeBASE *mus = (MusicNodeBASE *)fx;
 			if (_twoStartVolume >= 0)
 				mus->setVolume((_twoStartVolume * 255) / 100);
 
@@ -178,8 +184,8 @@ bool ActionCrossfade::execute() {
 // ActionCursor
 //////////////////////////////////////////////////////////////////////////////
 
-ActionCursor::ActionCursor(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionCursor::ActionCursor(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	Common::String up = line;
 	up.toUppercase();
 	_action = 0;
@@ -210,10 +216,13 @@ bool ActionCursor::execute() {
 // ActionDelayRender
 //////////////////////////////////////////////////////////////////////////////
 
-ActionDelayRender::ActionDelayRender(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionDelayRender::ActionDelayRender(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_framesToDelay = 0;
 	sscanf(line.c_str(), "%u", &_framesToDelay);
+	// Limit to 10 frames maximum. This fixes the script bug in ZGI scene px10
+	// (outside Frobozz Electric building), where this is set to 100 (bug #6791).
+	_framesToDelay = MIN<uint32>(_framesToDelay, 10);
 }
 
 bool ActionDelayRender::execute() {
@@ -225,15 +234,15 @@ bool ActionDelayRender::execute() {
 // ActionDisableControl
 //////////////////////////////////////////////////////////////////////////////
 
-ActionDisableControl::ActionDisableControl(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionDisableControl::ActionDisableControl(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_key = 0;
 
 	sscanf(line.c_str(), "%u", &_key);
 }
 
 bool ActionDisableControl::execute() {
-	_engine->getScriptManager()->setStateFlag(_key, Puzzle::DISABLED);
+	_scriptManager->setStateFlag(_key, Puzzle::DISABLED);
 	return true;
 }
 
@@ -241,8 +250,8 @@ bool ActionDisableControl::execute() {
 // ActionDisplayMessage
 //////////////////////////////////////////////////////////////////////////////
 
-ActionDisplayMessage::ActionDisplayMessage(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionDisplayMessage::ActionDisplayMessage(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_control = 0;
 	_msgid = 0;
 
@@ -250,7 +259,7 @@ ActionDisplayMessage::ActionDisplayMessage(ZVision *engine, int32 slotkey, const
 }
 
 bool ActionDisplayMessage::execute() {
-	Control *ctrl = _engine->getScriptManager()->getControl(_control);
+	Control *ctrl = _scriptManager->getControl(_control);
 	if (ctrl && ctrl->getType() == Control::CONTROL_TITLER) {
 		TitlerControl *titler = (TitlerControl *)ctrl;
 		titler->setString(_msgid);
@@ -276,8 +285,8 @@ bool ActionDissolve::execute() {
 // ActionDistort - only used by Zork: Nemesis for the "treatment" puzzle in the Sanitarium (aj30)
 //////////////////////////////////////////////////////////////////////////////
 
-ActionDistort::ActionDistort(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionDistort::ActionDistort(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_distSlot = 0;
 	_speed = 0;
 	_startAngle = 60.0;
@@ -289,14 +298,14 @@ ActionDistort::ActionDistort(ZVision *engine, int32 slotkey, const Common::Strin
 }
 
 ActionDistort::~ActionDistort() {
-	_engine->getScriptManager()->killSideFx(_distSlot);
+	_scriptManager->killSideFx(_distSlot);
 }
 
 bool ActionDistort::execute() {
-	if (_engine->getScriptManager()->getSideFX(_distSlot))
+	if (_scriptManager->getSideFX(_distSlot))
 		return true;
 
-	_engine->getScriptManager()->addSideFX(new DistortNode(_engine, _distSlot, _speed, _startAngle, _endAngle, _startLineScale, _endLineScale));
+	_scriptManager->addSideFX(new DistortNode(_engine, _distSlot, _speed, _startAngle, _endAngle, _startLineScale, _endLineScale));
 
 	return true;
 }
@@ -305,15 +314,15 @@ bool ActionDistort::execute() {
 // ActionEnableControl
 //////////////////////////////////////////////////////////////////////////////
 
-ActionEnableControl::ActionEnableControl(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionEnableControl::ActionEnableControl(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_key = 0;
 
 	sscanf(line.c_str(), "%u", &_key);
 }
 
 bool ActionEnableControl::execute() {
-	_engine->getScriptManager()->unsetStateFlag(_key, Puzzle::DISABLED);
+	_scriptManager->unsetStateFlag(_key, Puzzle::DISABLED);
 	return true;
 }
 
@@ -321,13 +330,13 @@ bool ActionEnableControl::execute() {
 // ActionFlushMouseEvents
 //////////////////////////////////////////////////////////////////////////////
 
-ActionFlushMouseEvents::ActionFlushMouseEvents(ZVision *engine, int32 slotkey) :
-	ResultAction(engine, slotkey) {
+ActionFlushMouseEvents::ActionFlushMouseEvents(ZVision *engine, int32 slotKey) :
+	ResultAction(engine, slotKey) {
 }
 
 bool ActionFlushMouseEvents::execute() {
-	_engine->getScriptManager()->flushEvent(Common::EVENT_LBUTTONUP);
-	_engine->getScriptManager()->flushEvent(Common::EVENT_LBUTTONDOWN);
+	_scriptManager->flushEvent(Common::EVENT_LBUTTONUP);
+	_scriptManager->flushEvent(Common::EVENT_LBUTTONDOWN);
 	return true;
 }
 
@@ -335,8 +344,8 @@ bool ActionFlushMouseEvents::execute() {
 // ActionInventory
 //////////////////////////////////////////////////////////////////////////////
 
-ActionInventory::ActionInventory(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionInventory::ActionInventory(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_type = -1;
 	_key = 0;
 
@@ -360,22 +369,22 @@ ActionInventory::ActionInventory(ZVision *engine, int32 slotkey, const Common::S
 bool ActionInventory::execute() {
 	switch (_type) {
 	case 0: // add
-		_engine->getScriptManager()->inventoryAdd(_key);
+		_scriptManager->inventoryAdd(_key);
 		break;
 	case 1: // addi
-		_engine->getScriptManager()->inventoryAdd(_engine->getScriptManager()->getStateValue(_key));
+		_scriptManager->inventoryAdd(_scriptManager->getStateValue(_key));
 		break;
 	case 2: // drop
 		if (_key >= 0)
-			_engine->getScriptManager()->inventoryDrop(_key);
+			_scriptManager->inventoryDrop(_key);
 		else
-			_engine->getScriptManager()->inventoryDrop(_engine->getScriptManager()->getStateValue(StateKey_InventoryItem));
+			_scriptManager->inventoryDrop(_scriptManager->getStateValue(StateKey_InventoryItem));
 		break;
 	case 3: // dropi
-		_engine->getScriptManager()->inventoryDrop(_engine->getScriptManager()->getStateValue(_key));
+		_scriptManager->inventoryDrop(_scriptManager->getStateValue(_key));
 		break;
 	case 4: // cycle
-		_engine->getScriptManager()->inventoryCycle();
+		_scriptManager->inventoryCycle();
 		break;
 	default:
 		break;
@@ -387,8 +396,8 @@ bool ActionInventory::execute() {
 // ActionKill - only used by ZGI
 //////////////////////////////////////////////////////////////////////////////
 
-ActionKill::ActionKill(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionKill::ActionKill(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_key = 0;
 	_type = 0;
 	char keytype[25];
@@ -416,9 +425,9 @@ ActionKill::ActionKill(ZVision *engine, int32 slotkey, const Common::String &lin
 
 bool ActionKill::execute() {
 	if (_type)
-		_engine->getScriptManager()->killSideFxType((ScriptingEffect::ScriptingEffectType)_type);
+		_scriptManager->killSideFxType((ScriptingEffect::ScriptingEffectType)_type);
 	else
-		_engine->getScriptManager()->killSideFx(_key);
+		_scriptManager->killSideFx(_key);
 	return true;
 }
 
@@ -426,8 +435,8 @@ bool ActionKill::execute() {
 // ActionMenuBarEnable
 //////////////////////////////////////////////////////////////////////////////
 
-ActionMenuBarEnable::ActionMenuBarEnable(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionMenuBarEnable::ActionMenuBarEnable(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_menus = 0xFFFF;
 
 	sscanf(line.c_str(), "%hu", &_menus);
@@ -442,18 +451,20 @@ bool ActionMenuBarEnable::execute() {
 // ActionMusic
 //////////////////////////////////////////////////////////////////////////////
 
-ActionMusic::ActionMusic(ZVision *engine, int32 slotkey, const Common::String &line, bool global) :
-	ResultAction(engine, slotkey),
-	_volume(255),
+ActionMusic::ActionMusic(ZVision *engine, int32 slotKey, const Common::String &line, bool global) :
+	ResultAction(engine, slotKey),
 	_note(0),
 	_prog(0),
 	_universe(global) {
 	uint type = 0;
 	char fileNameBuffer[25];
 	uint loop = 0;
-	uint volume = 255;
+	char volumeBuffer[15];
+
+	// Volume is optional. If it doesn't appear, assume full volume
+	strcpy(volumeBuffer, "100");
 
-	sscanf(line.c_str(), "%u %24s %u %u", &type, fileNameBuffer, &loop, &volume);
+	sscanf(line.c_str(), "%u %24s %u %14s", &type, fileNameBuffer, &loop, volumeBuffer);
 
 	// Type 4 actions are MIDI commands, not files. These are only used by
 	// Zork: Nemesis, for the flute and piano puzzles (tj4e and ve6f, as well
@@ -462,39 +473,54 @@ ActionMusic::ActionMusic(ZVision *engine, int32 slotkey, const Common::String &l
 		_midi = true;
 		int note;
 		int prog;
-		sscanf(line.c_str(), "%u %d %d %u", &type, &prog, &note, &volume);
-		_volume = volume;
+		sscanf(line.c_str(), "%u %d %d %14s", &type, &prog, &note, volumeBuffer);
+		_volume = new ValueSlot(_scriptManager, volumeBuffer);
 		_note = note;
 		_prog = prog;
 	} else {
 		_midi = false;
 		_fileName = Common::String(fileNameBuffer);
 		_loop = loop == 1 ? true : false;
-
-		// Volume is optional. If it doesn't appear, assume full volume
-		if (volume != 255) {
-			// Volume in the script files is mapped to [0, 100], but the ScummVM mixer uses [0, 255]
-			_volume = volume * 255 / 100;
+		if (volumeBuffer[0] != '[' && atoi(volumeBuffer) > 100) {
+			// I thought I saw a case like this in Zork Nemesis, so
+			// let's guard against it.
+			warning("ActionMusic: Adjusting volume for %s from %s to 100", _fileName.c_str(), volumeBuffer);
+			strcpy(volumeBuffer, "100");
 		}
+		_volume = new ValueSlot(_scriptManager, volumeBuffer);
 	}
+
+	// WORKAROUND for a script bug in Zork Nemesis, rooms mq70/mq80.
+	// Fixes an edge case where the player goes to the dark room with the grue
+	// without holding a torch, and then quickly runs away before the grue's
+	// sound effect finishes. Fixes script bug #6794.
+	if (engine->getGameId() == GID_NEMESIS && _slotKey == 14822 && _scriptManager->getStateValue(_slotKey) == 2)
+		_scriptManager->setStateValue(_slotKey, 0);
+
 }
 
 ActionMusic::~ActionMusic() {
 	if (!_universe)
-		_engine->getScriptManager()->killSideFx(_slotKey);
+		_scriptManager->killSideFx(_slotKey);
+	delete _volume;
 }
 
 bool ActionMusic::execute() {
-	if (_engine->getScriptManager()->getSideFX(_slotKey))
-		return true;
+	if (_scriptManager->getSideFX(_slotKey)) {
+		_scriptManager->killSideFx(_slotKey);
+		_scriptManager->setStateValue(_slotKey, 2);
+	}
+
+	uint volume = _volume->getValue();
 
 	if (_midi) {
-		_engine->getScriptManager()->addSideFX(new MusicMidiNode(_engine, _slotKey, _prog, _note, _volume));
+		_scriptManager->addSideFX(new MusicMidiNode(_engine, _slotKey, _prog, _note, volume));
 	} else {
 		if (!_engine->getSearchManager()->hasFile(_fileName))
 			return true;
 
-		_engine->getScriptManager()->addSideFX(new MusicNode(_engine, _slotKey, _fileName, _loop, _volume));
+		// Volume in the script files is mapped to [0, 100], but the ScummVM mixer uses [0, 255]
+		_scriptManager->addSideFX(new MusicNode(_engine, _slotKey, _fileName, _loop, volume * 255 / 100));
 	}
 
 	return true;
@@ -504,8 +530,8 @@ bool ActionMusic::execute() {
 // ActionPanTrack
 //////////////////////////////////////////////////////////////////////////////
 
-ActionPanTrack::ActionPanTrack(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey),
+ActionPanTrack::ActionPanTrack(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey),
 	_pos(0),
 	_musicSlot(0) {
 
@@ -513,14 +539,14 @@ ActionPanTrack::ActionPanTrack(ZVision *engine, int32 slotkey, const Common::Str
 }
 
 ActionPanTrack::~ActionPanTrack() {
-	_engine->getScriptManager()->killSideFx(_slotKey);
+	_scriptManager->killSideFx(_slotKey);
 }
 
 bool ActionPanTrack::execute() {
-	if (_engine->getScriptManager()->getSideFX(_slotKey))
+	if (_scriptManager->getSideFX(_slotKey))
 		return true;
 
-	_engine->getScriptManager()->addSideFX(new PanTrackNode(_engine, _slotKey, _musicSlot, _pos));
+	_scriptManager->addSideFX(new PanTrackNode(_engine, _slotKey, _musicSlot, _pos));
 
 	return true;
 }
@@ -529,8 +555,8 @@ bool ActionPanTrack::execute() {
 // ActionPreferences
 //////////////////////////////////////////////////////////////////////////////
 
-ActionPreferences::ActionPreferences(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionPreferences::ActionPreferences(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	if (line.compareToIgnoreCase("save") == 0)
 		_save = true;
 	else
@@ -550,8 +576,8 @@ bool ActionPreferences::execute() {
 // ActionPreloadAnimation
 //////////////////////////////////////////////////////////////////////////////
 
-ActionPreloadAnimation::ActionPreloadAnimation(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionPreloadAnimation::ActionPreloadAnimation(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_mask = 0;
 	_framerate = 0;
 
@@ -570,18 +596,18 @@ ActionPreloadAnimation::ActionPreloadAnimation(ZVision *engine, int32 slotkey, c
 }
 
 ActionPreloadAnimation::~ActionPreloadAnimation() {
-	_engine->getScriptManager()->deleteSideFx(_slotKey);
+	_scriptManager->deleteSideFx(_slotKey);
 }
 
 bool ActionPreloadAnimation::execute() {
-	AnimationEffect *nod = (AnimationEffect *)_engine->getScriptManager()->getSideFX(_slotKey);
+	AnimationEffect *nod = (AnimationEffect *)_scriptManager->getSideFX(_slotKey);
 
 	if (!nod) {
 		nod = new AnimationEffect(_engine, _slotKey, _fileName, _mask, _framerate, false);
-		_engine->getScriptManager()->addSideFX(nod);
+		_scriptManager->addSideFX(nod);
 	} else
 		nod->stop();
-	_engine->getScriptManager()->setStateValue(_slotKey, 2);
+	_scriptManager->setStateValue(_slotKey, 2);
 	return true;
 }
 
@@ -589,18 +615,18 @@ bool ActionPreloadAnimation::execute() {
 // ActionUnloadAnimation
 //////////////////////////////////////////////////////////////////////////////
 
-ActionUnloadAnimation::ActionUnloadAnimation(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionUnloadAnimation::ActionUnloadAnimation(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_key = 0;
 
 	sscanf(line.c_str(), "%u", &_key);
 }
 
 bool ActionUnloadAnimation::execute() {
-	AnimationEffect *nod = (AnimationEffect *)_engine->getScriptManager()->getSideFX(_key);
+	AnimationEffect *nod = (AnimationEffect *)_scriptManager->getSideFX(_key);
 
 	if (nod && nod->getType() == ScriptingEffect::SCRIPTING_EFFECT_ANIM)
-		_engine->getScriptManager()->deleteSideFx(_key);
+		_scriptManager->deleteSideFx(_key);
 
 	return true;
 }
@@ -609,8 +635,8 @@ bool ActionUnloadAnimation::execute() {
 // ActionPlayAnimation
 //////////////////////////////////////////////////////////////////////////////
 
-ActionPlayAnimation::ActionPlayAnimation(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionPlayAnimation::ActionPlayAnimation(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_x = 0;
 	_y = 0;
 	_x2 = 0;
@@ -635,18 +661,25 @@ ActionPlayAnimation::ActionPlayAnimation(ZVision *engine, int32 slotkey, const C
 		_mask = -1;
 
 	_fileName = Common::String(fileName);
+
+	// WORKAROUND for bug #6769, location me1g.scr (the "Alchemical debacle"
+	// video in ZGI). We only scale up by 2x, in AnimationEffect::process(),
+	// but the dimensions of the target frame are off by 2 pixels. We fix that
+	// here, so that the video can be scaled.
+	if (_fileName == "me1ga011.avi" && _y2 == 213)
+		_y2 = 215;
 }
 
 ActionPlayAnimation::~ActionPlayAnimation() {
-	_engine->getScriptManager()->deleteSideFx(_slotKey);
+	_scriptManager->deleteSideFx(_slotKey);
 }
 
 bool ActionPlayAnimation::execute() {
-	AnimationEffect *nod = (AnimationEffect *)_engine->getScriptManager()->getSideFX(_slotKey);
+	AnimationEffect *nod = (AnimationEffect *)_scriptManager->getSideFX(_slotKey);
 
 	if (!nod) {
 		nod = new AnimationEffect(_engine, _slotKey, _fileName, _mask, _framerate);
-		_engine->getScriptManager()->addSideFX(nod);
+		_scriptManager->addSideFX(nod);
 	} else
 		nod->stop();
 
@@ -660,8 +693,8 @@ bool ActionPlayAnimation::execute() {
 // ActionPlayPreloadAnimation
 //////////////////////////////////////////////////////////////////////////////
 
-ActionPlayPreloadAnimation::ActionPlayPreloadAnimation(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionPlayPreloadAnimation::ActionPlayPreloadAnimation(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_controlKey = 0;
 	_x1 = 0;
 	_y1 = 0;
@@ -677,7 +710,7 @@ ActionPlayPreloadAnimation::ActionPlayPreloadAnimation(ZVision *engine, int32 sl
 }
 
 bool ActionPlayPreloadAnimation::execute() {
-	AnimationEffect *nod = (AnimationEffect *)_engine->getScriptManager()->getSideFX(_controlKey);
+	AnimationEffect *nod = (AnimationEffect *)_scriptManager->getSideFX(_controlKey);
 
 	if (nod)
 		nod->addPlayNode(_slotKey, _x1, _y1, _x2, _y2, _startFrame, _endFrame, _loopCount);
@@ -699,8 +732,8 @@ bool ActionQuit::execute() {
 // ActionRegion - only used by Zork: Nemesis
 //////////////////////////////////////////////////////////////////////////////
 
-ActionRegion::ActionRegion(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionRegion::ActionRegion(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_delay = 0;
 	_type = 0;
 	_unk1 = 0;
@@ -718,11 +751,11 @@ ActionRegion::ActionRegion(ZVision *engine, int32 slotkey, const Common::String
 }
 
 ActionRegion::~ActionRegion() {
-	_engine->getScriptManager()->killSideFx(_slotKey);
+	_scriptManager->killSideFx(_slotKey);
 }
 
 bool ActionRegion::execute() {
-	if (_engine->getScriptManager()->getSideFX(_slotKey))
+	if (_scriptManager->getSideFX(_slotKey))
 		return true;
 
 	GraphicsEffect *effect = NULL;
@@ -767,7 +800,7 @@ bool ActionRegion::execute() {
 	}
 
 	if (effect) {
-		_engine->getScriptManager()->addSideFX(new RegionNode(_engine, _slotKey, effect, _delay));
+		_scriptManager->addSideFX(new RegionNode(_engine, _slotKey, effect, _delay));
 		_engine->getRenderManager()->addEffect(effect);
 	}
 
@@ -778,31 +811,46 @@ bool ActionRegion::execute() {
 // ActionRandom
 //////////////////////////////////////////////////////////////////////////////
 
-ActionRandom::ActionRandom(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionRandom::ActionRandom(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	char maxBuffer[64];
 	memset(maxBuffer, 0, 64);
 	sscanf(line.c_str(), "%s", maxBuffer);
-	_max = new ValueSlot(_engine->getScriptManager(), maxBuffer);
+	_max = new ValueSlot(_scriptManager, maxBuffer);
 }
 
 ActionRandom::~ActionRandom() {
-	if (_max)
-		delete _max;
+	delete _max;
 }
 
 bool ActionRandom::execute() {
 	uint randNumber = _engine->getRandomSource()->getRandomNumber(_max->getValue());
-	_engine->getScriptManager()->setStateValue(_slotKey, randNumber);
+	_scriptManager->setStateValue(_slotKey, randNumber);
 	return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
+// ActionRestoreGame
+//////////////////////////////////////////////////////////////////////////////
+
+ActionRestoreGame::ActionRestoreGame(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
+	char buf[128];
+	sscanf(line.c_str(), "%s", buf);
+	_fileName = Common::String(buf);
+}
+
+bool ActionRestoreGame::execute() {
+	_engine->getSaveManager()->loadGame(-1);
+	return false;
+}
+
+//////////////////////////////////////////////////////////////////////////////
 // ActionRotateTo
 //////////////////////////////////////////////////////////////////////////////
 
-ActionRotateTo::ActionRotateTo(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionRotateTo::ActionRotateTo(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_time = 0;
 	_toPos = 0;
 
@@ -819,8 +867,8 @@ bool ActionRotateTo::execute() {
 // ActionSetPartialScreen
 //////////////////////////////////////////////////////////////////////////////
 
-ActionSetPartialScreen::ActionSetPartialScreen(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionSetPartialScreen::ActionSetPartialScreen(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_x = 0;
 	_y = 0;
 
@@ -859,8 +907,8 @@ bool ActionSetPartialScreen::execute() {
 // ActionSetScreen
 //////////////////////////////////////////////////////////////////////////////
 
-ActionSetScreen::ActionSetScreen(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionSetScreen::ActionSetScreen(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	char fileName[25];
 	sscanf(line.c_str(), "%24s", fileName);
 
@@ -877,14 +925,14 @@ bool ActionSetScreen::execute() {
 // ActionStop
 //////////////////////////////////////////////////////////////////////////////
 
-ActionStop::ActionStop(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionStop::ActionStop(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_key = 0;
 	sscanf(line.c_str(), "%u", &_key);
 }
 
 bool ActionStop::execute() {
-	_engine->getScriptManager()->stopSideFx(_key);
+	_scriptManager->stopSideFx(_key);
 	return true;
 }
 
@@ -892,8 +940,8 @@ bool ActionStop::execute() {
 // ActionStreamVideo
 //////////////////////////////////////////////////////////////////////////////
 
-ActionStreamVideo::ActionStreamVideo(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionStreamVideo::ActionStreamVideo(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_x1 = 0;
 	_x2 = 0;
 	_y1 = 0;
@@ -912,7 +960,15 @@ ActionStreamVideo::ActionStreamVideo(ZVision *engine, int32 slotkey, const Commo
 bool ActionStreamVideo::execute() {
 	Video::VideoDecoder *decoder;
 	Common::Rect destRect = Common::Rect(_x1, _y1, _x2 + 1, _y2 + 1);
+	Common::String subname = _fileName;
+	subname.setChar('s', subname.size() - 3);
+	subname.setChar('u', subname.size() - 2);
+	subname.setChar('b', subname.size() - 1);
+	bool subtitleExists = _engine->getSearchManager()->hasFile(subname);
+	bool switchToHires = false;
 
+// NOTE: We only show the hires MPEG2 videos when libmpeg2 is compiled in,
+// otherwise we fall back to the lowres ones
 #ifdef USE_MPEG2
 	Common::String hiresFileName = _fileName;
 	hiresFileName.setChar('d', hiresFileName.size() - 8);
@@ -920,36 +976,44 @@ bool ActionStreamVideo::execute() {
 	hiresFileName.setChar('o', hiresFileName.size() - 2);
 	hiresFileName.setChar('b', hiresFileName.size() - 1);
 
-	if (_engine->getScriptManager()->getStateValue(StateKey_MPEGMovies) == 1 &&_engine->getSearchManager()->hasFile(hiresFileName))
-		// TODO: Enable once VOB + AC3 support is implemented
-		//_fileName = hiresFileName;
+	if (_scriptManager->getStateValue(StateKey_MPEGMovies) == 1 &&_engine->getSearchManager()->hasFile(hiresFileName)) {
+		// TODO: Enable once AC3 support is implemented
+		if (!_engine->getSearchManager()->hasFile(_fileName))	// Check for the regular video
+			return true;
 		warning("The hires videos of the DVD version of ZGI aren't supported yet, using lowres");
-#endif
-
-	Common::String subname = _fileName;
-	subname.setChar('s', subname.size() - 3);
-	subname.setChar('u', subname.size() - 2);
-	subname.setChar('b', subname.size() - 1);
-
+		//_fileName = hiresFileName;
+		//switchToHires = true;
+	} else if (!_engine->getSearchManager()->hasFile(_fileName))
+		return true;
+#else
 	if (!_engine->getSearchManager()->hasFile(_fileName))
 		return true;
+#endif
 
 	decoder = _engine->loadAnimation(_fileName);
+	Subtitle *sub = (subtitleExists) ? new Subtitle(_engine, subname, switchToHires) : NULL;
 
 	_engine->getCursorManager()->showMouse(false);
 
-	Subtitle *sub = NULL;
-
-	if (_engine->getSearchManager()->hasFile(subname))
-		sub = new Subtitle(_engine, subname);
+	if (switchToHires) {
+		_engine->initHiresScreen();
+		destRect = Common::Rect(40, -40, 760, 440);
+		Common::Rect workingWindow = _engine->_workingWindow;
+		workingWindow.translate(0, -40);
+		_engine->getRenderManager()->initSubArea(HIRES_WINDOW_WIDTH, HIRES_WINDOW_HEIGHT, workingWindow);
+	}
 
 	_engine->playVideo(*decoder, destRect, _skippable, sub);
-	delete decoder;
+
+	if (switchToHires) {
+		_engine->initScreen();
+		_engine->getRenderManager()->initSubArea(WINDOW_WIDTH, WINDOW_HEIGHT, _engine->_workingWindow);
+	}
 
 	_engine->getCursorManager()->showMouse(true);
 
-	if (sub)
-		delete sub;
+	delete decoder;
+	delete sub;
 
 	return true;
 }
@@ -958,8 +1022,8 @@ bool ActionStreamVideo::execute() {
 // ActionSyncSound
 //////////////////////////////////////////////////////////////////////////////
 
-ActionSyncSound::ActionSyncSound(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionSyncSound::ActionSyncSound(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_syncto = 0;
 
 	char fileName[25];
@@ -971,14 +1035,14 @@ ActionSyncSound::ActionSyncSound(ZVision *engine, int32 slotkey, const Common::S
 }
 
 bool ActionSyncSound::execute() {
-	ScriptingEffect *fx = _engine->getScriptManager()->getSideFX(_syncto);
+	ScriptingEffect *fx = _scriptManager->getSideFX(_syncto);
 	if (!fx)
 		return true;
 
 	if (!(fx->getType() & ScriptingEffect::SCRIPTING_EFFECT_ANIM))
 		return true;
 
-	_engine->getScriptManager()->addSideFX(new SyncSoundNode(_engine, _slotKey, _fileName, _syncto));
+	_scriptManager->addSideFX(new SyncSoundNode(_engine, _slotKey, _fileName, _syncto));
 	return true;
 }
 
@@ -986,24 +1050,23 @@ bool ActionSyncSound::execute() {
 // ActionTimer
 //////////////////////////////////////////////////////////////////////////////
 
-ActionTimer::ActionTimer(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionTimer::ActionTimer(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	char timeBuffer[64];
 	memset(timeBuffer, 0, 64);
 	sscanf(line.c_str(), "%s", timeBuffer);
-	_time = new ValueSlot(_engine->getScriptManager(), timeBuffer);
+	_time = new ValueSlot(_scriptManager, timeBuffer);
 }
 
 ActionTimer::~ActionTimer() {
-	if (_time)
-		delete _time;
-	_engine->getScriptManager()->killSideFx(_slotKey);
+	delete _time;
+	_scriptManager->killSideFx(_slotKey);
 }
 
 bool ActionTimer::execute() {
-	if (_engine->getScriptManager()->getSideFX(_slotKey))
+	if (_scriptManager->getSideFX(_slotKey))
 		return true;
-	_engine->getScriptManager()->addSideFX(new TimerNode(_engine, _slotKey, _time->getValue()));
+	_scriptManager->addSideFX(new TimerNode(_engine, _slotKey, _time->getValue()));
 	return true;
 }
 
@@ -1011,25 +1074,25 @@ bool ActionTimer::execute() {
 // ActionTtyText
 //////////////////////////////////////////////////////////////////////////////
 
-ActionTtyText::ActionTtyText(ZVision *engine, int32 slotkey, const Common::String &line) :
-	ResultAction(engine, slotkey) {
+ActionTtyText::ActionTtyText(ZVision *engine, int32 slotKey, const Common::String &line) :
+	ResultAction(engine, slotKey) {
 	_delay = 0;
 
 	char filename[64];
 	int32 x1 = 0, y1 = 0, x2 = 0, y2 = 0;
-	sscanf(line.c_str(), "%d %d %d %d %64s %u", &x1, &y1, &x2, &y2, filename, &_delay);
+	sscanf(line.c_str(), "%d %d %d %d %63s %u", &x1, &y1, &x2, &y2, filename, &_delay);
 	_r = Common::Rect(x1, y1, x2, y2);
 	_filename = Common::String(filename);
 }
 
 ActionTtyText::~ActionTtyText() {
-	_engine->getScriptManager()->killSideFx(_slotKey);
+	_scriptManager->killSideFx(_slotKey);
 }
 
 bool ActionTtyText::execute() {
-	if (_engine->getScriptManager()->getSideFX(_slotKey))
+	if (_scriptManager->getSideFX(_slotKey))
 		return true;
-	_engine->getScriptManager()->addSideFX(new ttyTextNode(_engine, _slotKey, _filename, _r, _delay));
+	_scriptManager->addSideFX(new ttyTextNode(_engine, _slotKey, _filename, _r, _delay));
 	return true;
 }
 
diff --git a/engines/zvision/scripting/actions.h b/engines/zvision/scripting/actions.h
index c2350bc83a..bde1baa291 100644
--- a/engines/zvision/scripting/actions.h
+++ b/engines/zvision/scripting/actions.h
@@ -32,6 +32,7 @@ namespace ZVision {
 
 // Forward declaration of ZVision. This file is included before ZVision is declared
 class ZVision;
+class ScriptManager;
 class ValueSlot;
 
 /**
@@ -40,7 +41,7 @@ class ValueSlot;
   */
 class ResultAction {
 public:
-	ResultAction(ZVision *engine, int32 slotkey) : _engine(engine), _slotKey(slotkey) {}
+	ResultAction(ZVision *engine, int32 slotkey);
 	virtual ~ResultAction() {}
 	/**
 	 * This is called by the script system whenever a Puzzle's criteria are found to be true.
@@ -53,6 +54,7 @@ public:
 	virtual bool execute() = 0;
 protected:
 	ZVision *_engine;
+	ScriptManager *_scriptManager;
 	int32 _slotKey;
 };
 
@@ -224,7 +226,7 @@ public:
 private:
 	Common::String _fileName;
 	bool _loop;
-	byte _volume;
+	ValueSlot *_volume;
 	bool _universe;
 	bool _midi;
 	int8 _note;
@@ -267,7 +269,6 @@ public:
 	bool execute();
 
 private:
-	uint32 _animationKey;
 	uint32 _controlKey;
 	uint32 _x1;
 	uint32 _y1;
@@ -340,6 +341,15 @@ private:
 	ValueSlot *_max;
 };
 
+class ActionRestoreGame : public ResultAction {
+public:
+	ActionRestoreGame(ZVision *engine, int32 slotkey, const Common::String &line);
+	bool execute();
+
+private:
+	Common::String _fileName;
+};
+
 class ActionRotateTo : public ResultAction {
 public:
 	ActionRotateTo(ZVision *engine, int32 slotkey, const Common::String &line);
diff --git a/engines/zvision/scripting/controls/fist_control.cpp b/engines/zvision/scripting/controls/fist_control.cpp
index 4a8e8b1bbd..f79c82dc79 100644
--- a/engines/zvision/scripting/controls/fist_control.cpp
+++ b/engines/zvision/scripting/controls/fist_control.cpp
@@ -105,7 +105,12 @@ bool FistControl::process(uint32 deltaTimeInMillis) {
 		if (_animation->needsUpdate()) {
 			const Graphics::Surface *frameData = _animation->decodeNextFrame();
 			if (frameData)
-				_engine->getRenderManager()->blitSurfaceToBkgScaled(*frameData, _anmRect);
+				// WORKAROUND: Ignore the target frame dimensions for the finger animations.
+				// The target dimensions specify an area smaller than expected, thus if we
+				// scale the finger videos to fit these dimensions, they are not aligned
+				// correctly. Not scaling these videos yields a result identical to the
+				// original. Fixes bug #6784.
+				_engine->getRenderManager()->blitSurfaceToBkg(*frameData, _anmRect.left, _anmRect.top);
 		}
 	}
 
diff --git a/engines/zvision/scripting/controls/input_control.cpp b/engines/zvision/scripting/controls/input_control.cpp
index 47da27fa08..9525333ef0 100644
--- a/engines/zvision/scripting/controls/input_control.cpp
+++ b/engines/zvision/scripting/controls/input_control.cpp
@@ -39,10 +39,10 @@ namespace ZVision {
 
 InputControl::InputControl(ZVision *engine, uint32 key, Common::SeekableReadStream &stream)
 	: Control(engine, key, CONTROL_INPUT),
+	  _background(0),
 	  _nextTabstop(0),
 	  _focused(false),
 	  _textChanged(false),
-	  _cursorOffset(0),
 	  _enterPressed(false),
 	  _readOnly(false),
 	  _txtWidth(0),
@@ -78,13 +78,13 @@ InputControl::InputControl(ZVision *engine, uint32 key, Common::SeekableReadStre
 
 			sscanf(values.c_str(), "%u", &fontFormatNumber);
 
-			_stringInit.readAllStyle(_engine->getStringManager()->getTextLine(fontFormatNumber));
+			_stringInit.readAllStyles(_engine->getStringManager()->getTextLine(fontFormatNumber));
 		} else if (param.matchString("chooser_init_string", true)) {
 			uint fontFormatNumber;
 
 			sscanf(values.c_str(), "%u", &fontFormatNumber);
 
-			_stringChooserInit.readAllStyle(_engine->getStringManager()->getTextLine(fontFormatNumber));
+			_stringChooserInit.readAllStyles(_engine->getStringManager()->getTextLine(fontFormatNumber));
 		} else if (param.matchString("next_tabstop", true)) {
 			sscanf(values.c_str(), "%u", &_nextTabstop);
 		} else if (param.matchString("cursor_dimensions", true)) {
@@ -109,6 +109,15 @@ InputControl::InputControl(ZVision *engine, uint32 key, Common::SeekableReadStre
 		_engine->getScriptManager()->trimCommentsAndWhiteSpace(&line);
 		getParams(line, param, values);
 	}
+
+	_maxTxtWidth = _textRectangle.width();
+	if (_animation)
+		_maxTxtWidth -= _animation->getWidth();
+}
+
+InputControl::~InputControl() {
+	_background->free();
+	delete _background;
 }
 
 bool InputControl::onMouseUp(const Common::Point &screenSpacePos, const Common::Point &backgroundImageSpacePos) {
@@ -191,19 +200,31 @@ bool InputControl::process(uint32 deltaTimeInMillis) {
 	if (_engine->getScriptManager()->getStateFlag(_key) & Puzzle::DISABLED)
 		return false;
 
+	if (!_background) {
+		_background = _engine->getRenderManager()->getBkgRect(_textRectangle);
+	}
+
 	// First see if we need to render the text
 	if (_textChanged) {
 		// Blit the text using the RenderManager
 
 		Graphics::Surface txt;
-		txt.create(_textRectangle.width(), _textRectangle.height(), _engine->_resourcePixelFormat);
+		txt.copyFrom(*_background);
+
+		int32 oldTxtWidth = _txtWidth;
 
 		if (!_readOnly || !_focused)
-			_txtWidth = _engine->getTextRenderer()->drawTxt(_currentInputText, _stringInit, txt);
+			_txtWidth = _engine->getTextRenderer()->drawText(_currentInputText, _stringInit, txt);
 		else
-			_txtWidth = _engine->getTextRenderer()->drawTxt(_currentInputText, _stringChooserInit, txt);
+			_txtWidth = _engine->getTextRenderer()->drawText(_currentInputText, _stringChooserInit, txt);
 
-		_engine->getRenderManager()->blitSurfaceToBkg(txt, _textRectangle.left, _textRectangle.top);
+		if (_readOnly || _txtWidth <= _maxTxtWidth)
+			_engine->getRenderManager()->blitSurfaceToBkg(txt, _textRectangle.left, _textRectangle.top);
+		else {
+			// Assume the last character caused the overflow.
+			_currentInputText.deleteLastChar();
+			_txtWidth = oldTxtWidth;
+		}
 
 		txt.free();
 	}
diff --git a/engines/zvision/scripting/controls/input_control.h b/engines/zvision/scripting/controls/input_control.h
index 99f7f5287d..6abdb3c692 100644
--- a/engines/zvision/scripting/controls/input_control.h
+++ b/engines/zvision/scripting/controls/input_control.h
@@ -38,25 +38,25 @@ namespace ZVision {
 class InputControl : public Control {
 public:
 	InputControl(ZVision *engine, uint32 key, Common::SeekableReadStream &stream);
+	~InputControl();
 
 private:
+	Graphics::Surface *_background;
 	Common::Rect _textRectangle;
 	Common::Rect _headerRectangle;
-	cTxtStyle _stringInit;
-	cTxtStyle _stringChooserInit;
+	TextStyleState _stringInit;
+	TextStyleState _stringChooserInit;
 	uint32 _nextTabstop;
 	bool _focused;
 
 	Common::String _currentInputText;
 	bool _textChanged;
-	uint _cursorOffset;
 	bool _enterPressed;
 	bool _readOnly;
 
 	int16 _txtWidth;
+	int16 _maxTxtWidth;
 	Video::VideoDecoder *_animation;
-	int32 _frameDelay;
-	int16 _frame;
 
 public:
 	void focus() {
diff --git a/engines/zvision/scripting/controls/lever_control.cpp b/engines/zvision/scripting/controls/lever_control.cpp
index bef51f0e91..0f105b424c 100644
--- a/engines/zvision/scripting/controls/lever_control.cpp
+++ b/engines/zvision/scripting/controls/lever_control.cpp
@@ -232,10 +232,13 @@ bool LeverControl::onMouseMove(const Common::Point &screenSpacePos, const Common
 				if (angle >= (int)iter->angle - ANGLE_DELTA && angle <= (int)iter->angle + ANGLE_DELTA) {
 					_currentFrame = iter->toFrame;
 					renderFrame(_currentFrame);
+					_engine->getScriptManager()->setStateValue(_key, _currentFrame);
 					break;
 				}
 			}
 		}
+		_engine->getCursorManager()->changeCursor(_cursor);
+		cursorWasChanged = true;
 	} else if (_frameInfo[_currentFrame].hotspot.contains(backgroundImageSpacePos)) {
 		_engine->getCursorManager()->changeCursor(_cursor);
 		cursorWasChanged = true;
diff --git a/engines/zvision/scripting/controls/safe_control.cpp b/engines/zvision/scripting/controls/safe_control.cpp
index 6ba34106d0..4d2a91a1ad 100644
--- a/engines/zvision/scripting/controls/safe_control.cpp
+++ b/engines/zvision/scripting/controls/safe_control.cpp
@@ -123,6 +123,8 @@ bool SafeControl::process(uint32 deltaTimeInMillis) {
 			_animation->seekToFrame(_animation->getCurFrame() - 1);
 
 		const Graphics::Surface *frameData = _animation->decodeNextFrame();
+		if (_animation->getCurFrame() == _targetFrame)
+			_engine->getScriptManager()->setStateValue(_key, _curState);
 		if (frameData)
 			_engine->getRenderManager()->blitSurfaceToBkg(*frameData, _rectangle.left, _rectangle.top);
 	}
@@ -169,8 +171,6 @@ bool SafeControl::onMouseUp(const Common::Point &screenSpacePos, const Common::P
 			_curState = (_statesCount * 2 + tmp2) % _statesCount;
 
 			_targetFrame = (_curState + _statesCount - _startPointer) % _statesCount;
-
-			_engine->getScriptManager()->setStateValue(_key, _curState);
 			return true;
 		}
 	}
diff --git a/engines/zvision/scripting/controls/titler_control.cpp b/engines/zvision/scripting/controls/titler_control.cpp
index 542e0a0b67..683d6660af 100644
--- a/engines/zvision/scripting/controls/titler_control.cpp
+++ b/engines/zvision/scripting/controls/titler_control.cpp
@@ -82,7 +82,7 @@ TitlerControl::~TitlerControl() {
 void TitlerControl::setString(int strLine) {
 	if (strLine != _curString && strLine >= 0 && strLine < (int)_strings.size()) {
 		_surface->fillRect(Common::Rect(_surface->w, _surface->h), 0);
-		_engine->getTextRenderer()->drawTxtInOneLine(_strings[strLine], *_surface);
+		_engine->getTextRenderer()->drawTextWithWordWrapping(_strings[strLine], *_surface);
 		_engine->getRenderManager()->blitSurfaceToBkg(*_surface, _rectangle.left, _rectangle.top);
 		_curString = strLine;
 	}
diff --git a/engines/zvision/scripting/effects/distort_effect.cpp b/engines/zvision/scripting/effects/distort_effect.cpp
index 78c4a1b9a8..113b5d048d 100644
--- a/engines/zvision/scripting/effects/distort_effect.cpp
+++ b/engines/zvision/scripting/effects/distort_effect.cpp
@@ -52,7 +52,7 @@ DistortNode::DistortNode(ZVision *engine, uint32 key, int16 speed, float startAn
 	_diffLinScale = endLineScale - startLineScale;
 
 	_frmSpeed = (float)speed / 15.0;
-	_frames = ceil((5.0 - _frmSpeed * 2.0) / _frmSpeed);
+	_frames = (int)ceil((5.0 - _frmSpeed * 2.0) / _frmSpeed);
 	if (_frames <= 0)
 		_frames = 1;
 
diff --git a/engines/zvision/scripting/effects/music_effect.cpp b/engines/zvision/scripting/effects/music_effect.cpp
index 102f330305..e3fdc96dba 100644
--- a/engines/zvision/scripting/effects/music_effect.cpp
+++ b/engines/zvision/scripting/effects/music_effect.cpp
@@ -36,16 +36,33 @@
 
 namespace ZVision {
 
-MusicNode::MusicNode(ZVision *engine, uint32 key, Common::String &filename, bool loop, int8 volume)
+static const uint8 dbMapLinear[256] =
+{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2,
+2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
+4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
+8, 8, 8, 9, 9, 9, 10, 10, 11, 11, 11, 12, 12, 13, 13, 14,
+14, 15, 15, 16, 16, 17, 18, 18, 19, 20, 21, 21, 22, 23, 24, 25,
+26, 27, 28, 29, 30, 31, 32, 33, 34, 36, 37, 38, 40, 41, 43, 45,
+46, 48, 50, 52, 53, 55, 57, 60, 62, 64, 67, 69, 72, 74, 77, 80,
+83, 86, 89, 92, 96, 99, 103, 107, 111, 115, 119, 123, 128, 133, 137, 143,
+148, 153, 159, 165, 171, 177, 184, 191, 198, 205, 212, 220, 228, 237, 245, 255};
+
+MusicNode::MusicNode(ZVision *engine, uint32 key, Common::String &filename, bool loop, uint8 volume)
 	: MusicNodeBASE(engine, key, SCRIPTING_EFFECT_AUDIO) {
 	_loop = loop;
 	_volume = volume;
+	_deltaVolume = 0;
+	_balance = 0;
 	_crossfade = false;
 	_crossfadeTarget = 0;
 	_crossfadeTime = 0;
-	_attenuate = 0;
-	_pantrack = false;
-	_pantrackPosition = 0;
 	_sub = NULL;
 	_stereo = false;
 	_loaded = false;
@@ -66,9 +83,9 @@ MusicNode::MusicNode(ZVision *engine, uint32 key, Common::String &filename, bool
 
 		if (_loop) {
 			Audio::LoopingAudioStream *loopingAudioStream = new Audio::LoopingAudioStream(audioStream, 0, DisposeAfterUse::YES);
-			_engine->_mixer->playStream(Audio::Mixer::kPlainSoundType, &_handle, loopingAudioStream, -1, _volume);
+			_engine->_mixer->playStream(Audio::Mixer::kPlainSoundType, &_handle, loopingAudioStream, -1, dbMapLinear[_volume]);
 		} else {
-			_engine->_mixer->playStream(Audio::Mixer::kPlainSoundType, &_handle, audioStream, -1, _volume);
+			_engine->_mixer->playStream(Audio::Mixer::kPlainSoundType, &_handle, audioStream, -1, dbMapLinear[_volume]);
 		}
 
 		if (_key != StateKey_NotSet)
@@ -94,20 +111,17 @@ MusicNode::~MusicNode() {
 		_engine->getScriptManager()->setStateValue(_key, 2);
 	if (_sub)
 		delete _sub;
-	debug(1, "MusicNode: %d destroyed\n", _key);
+	debug(1, "MusicNode: %d destroyed", _key);
 }
 
-void MusicNode::setPanTrack(int16 pos) {
-	if (!_stereo) {
-		_pantrack = true;
-		_pantrackPosition = pos;
-		setVolume(_volume);
-	}
+void MusicNode::setDeltaVolume(uint8 volume) {
+	_deltaVolume = volume;
+	setVolume(_volume);
 }
 
-void MusicNode::unsetPanTrack() {
-	_pantrack = false;
-	setVolume(_volume);
+void MusicNode::setBalance(int8 balance) {
+	_balance = balance;
+	_engine->_mixer->setChannelBalance(_handle, _balance);
 }
 
 void MusicNode::setFade(int32 time, uint8 target) {
@@ -126,7 +140,7 @@ bool MusicNode::process(uint32 deltaTimeInMillis) {
 			if (_crossfadeTime > 0) {
 				if ((int32)deltaTimeInMillis > _crossfadeTime)
 					deltaTimeInMillis = _crossfadeTime;
-				_newvol += floor(((float)(_crossfadeTarget - _newvol) / (float)_crossfadeTime)) * (float)deltaTimeInMillis;
+				_newvol += (int)(floor(((float)(_crossfadeTarget - _newvol) / (float)_crossfadeTime)) * (float)deltaTimeInMillis);
 				_crossfadeTime -= deltaTimeInMillis;
 			} else {
 				_crossfade = false;
@@ -134,7 +148,7 @@ bool MusicNode::process(uint32 deltaTimeInMillis) {
 			}
 		}
 
-		if (_pantrack || _volume != _newvol)
+		if (_volume != _newvol)
 			setVolume(_newvol);
 
 		if (_sub && _engine->getScriptManager()->getStateValue(StateKey_Subtitles) == 1)
@@ -146,55 +160,85 @@ bool MusicNode::process(uint32 deltaTimeInMillis) {
 void MusicNode::setVolume(uint8 newVolume) {
 	if (!_loaded)
 		return;
-	if (_pantrack) {
-		int curX = _engine->getScriptManager()->getStateValue(StateKey_ViewPos);
-		curX -= _pantrackPosition;
-		int32 _width = _engine->getRenderManager()->getBkgSize().x;
-		if (curX < (-_width) / 2)
-			curX += _width;
-		else if (curX >= _width / 2)
-			curX -= _width;
-
-		float norm = (float)curX / ((float)_width / 2.0);
-		float lvl = fabs(norm);
-		if (lvl > 0.5)
-			lvl = (lvl - 0.5) * 1.7;
-		else
-			lvl = 1.0;
 
-		float bal = sin(-norm * 3.1415926) * 127.0;
+	_volume = newVolume;
 
-		if (_engine->_mixer->isSoundHandleActive(_handle)) {
-			_engine->_mixer->setChannelBalance(_handle, bal);
-			_engine->_mixer->setChannelVolume(_handle, newVolume * lvl);
-		}
-	} else {
-		if (_engine->_mixer->isSoundHandleActive(_handle)) {
-			_engine->_mixer->setChannelBalance(_handle, 0);
-			_engine->_mixer->setChannelVolume(_handle, newVolume);
-		}
-	}
+	if (_deltaVolume >= _volume)
+		_engine->_mixer->setChannelVolume(_handle, 0);
+	else
+		_engine->_mixer->setChannelVolume(_handle, dbMapLinear[_volume - _deltaVolume]);
+}
 
-	_volume = newVolume;
+uint8 MusicNode::getVolume() {
+	return _volume;
 }
 
 PanTrackNode::PanTrackNode(ZVision *engine, uint32 key, uint32 slot, int16 pos)
 	: ScriptingEffect(engine, key, SCRIPTING_EFFECT_PANTRACK) {
 	_slot = slot;
+	_position = pos;
 
-	ScriptingEffect *fx = _engine->getScriptManager()->getSideFX(slot);
-	if (fx && fx->getType() == SCRIPTING_EFFECT_AUDIO) {
-		MusicNodeBASE *mus = (MusicNodeBASE *)fx;
-		mus->setPanTrack(pos);
-	}
+	// Try to set pan value for music node immediately
+	process(0);
 }
 
 PanTrackNode::~PanTrackNode() {
-	ScriptingEffect *fx = _engine->getScriptManager()->getSideFX(_slot);
+}
+
+bool PanTrackNode::process(uint32 deltaTimeInMillis) {
+	ScriptManager * scriptManager = _engine->getScriptManager();
+	ScriptingEffect *fx = scriptManager->getSideFX(_slot);
 	if (fx && fx->getType() == SCRIPTING_EFFECT_AUDIO) {
 		MusicNodeBASE *mus = (MusicNodeBASE *)fx;
-		mus->unsetPanTrack();
+
+		int curPos = scriptManager->getStateValue(StateKey_ViewPos);
+		int16 _width = _engine->getRenderManager()->getBkgSize().x;
+		int16 _halfWidth = _width / 2;
+		int16 _quarterWidth = _width / 4;
+
+		int tmp = 0;
+		if (curPos <= _position)
+			tmp = _position - curPos;
+		else
+			tmp = _position - curPos + _width;
+
+		int balance = 0;
+
+		if (tmp > _halfWidth)
+			tmp -= _width;
+
+		if (tmp > _quarterWidth) {
+			balance = 1;
+			tmp = _halfWidth - tmp;
+		} else if (tmp < -_quarterWidth) {
+			balance = -1;
+			tmp = -_halfWidth - tmp;
+		}
+
+		// Originally it's value -90...90 but we use -127...127 and therefore 360 replaced by 508
+		mus->setBalance( (508 * tmp) / _width );
+
+		tmp = (360 * tmp) / _width;
+
+		int deltaVol = balance;
+
+		// This value sets how fast volume goes off than sound source back of you
+		// By this value we can hack some "bugs" have place in originall game engine like beat sound in ZGI-dc10
+		int volumeCorrection = 2;
+
+		if (_engine->getGameId() == GID_GRANDINQUISITOR) {
+			if (scriptManager->getCurrentLocation() == "dc10")
+				volumeCorrection = 5;
+		}
+
+		if (deltaVol != 0)
+			deltaVol = (mus->getVolume() * volumeCorrection) * (90 - tmp * balance) / 90;
+		if (deltaVol > 255)
+			deltaVol = 255;
+
+		mus->setDeltaVolume(deltaVol);
 	}
+	return false;
 }
 
 MusicMidiNode::MusicMidiNode(ZVision *engine, uint32 key, int8 program, int8 note, int8 volume)
@@ -225,10 +269,10 @@ MusicMidiNode::~MusicMidiNode() {
 		_engine->getScriptManager()->setStateValue(_key, 2);
 }
 
-void MusicMidiNode::setPanTrack(int16 pos) {
+void MusicMidiNode::setDeltaVolume(uint8 volume) {
 }
 
-void MusicMidiNode::unsetPanTrack() {
+void MusicMidiNode::setBalance(int8 balance) {
 }
 
 void MusicMidiNode::setFade(int32 time, uint8 target) {
@@ -245,4 +289,8 @@ void MusicMidiNode::setVolume(uint8 newVolume) {
 	_volume = newVolume;
 }
 
+uint8 MusicMidiNode::getVolume() {
+	return _volume;
+}
+
 } // End of namespace ZVision
diff --git a/engines/zvision/scripting/effects/music_effect.h b/engines/zvision/scripting/effects/music_effect.h
index 31d538f668..7657be8e09 100644
--- a/engines/zvision/scripting/effects/music_effect.h
+++ b/engines/zvision/scripting/effects/music_effect.h
@@ -48,16 +48,16 @@ public:
 	virtual bool process(uint32 deltaTimeInMillis) = 0;
 
 	virtual void setVolume(uint8 volume) = 0;
-
-	virtual void setPanTrack(int16 pos) = 0;
-	virtual void unsetPanTrack() = 0;
+	virtual uint8 getVolume() = 0;
+	virtual void setDeltaVolume(uint8 volume) = 0;
+	virtual void setBalance(int8 balance) = 0;
 
 	virtual void setFade(int32 time, uint8 target) = 0;
 };
 
 class MusicNode : public MusicNodeBASE {
 public:
-	MusicNode(ZVision *engine, uint32 key, Common::String &file, bool loop, int8 volume);
+	MusicNode(ZVision *engine, uint32 key, Common::String &file, bool loop, uint8 volume);
 	~MusicNode();
 
 	/**
@@ -70,17 +70,16 @@ public:
 	bool process(uint32 deltaTimeInMillis);
 
 	void setVolume(uint8 volume);
-
-	void setPanTrack(int16 pos);
-	void unsetPanTrack();
+	uint8 getVolume();
+	void setDeltaVolume(uint8 volume);
+	void setBalance(int8 balance);
 
 	void setFade(int32 time, uint8 target);
 
 private:
-	bool _pantrack;
-	int32 _pantrackPosition;
-	int32 _attenuate;
 	uint8 _volume;
+	uint8 _deltaVolume;
+	int8 _balance;
 	bool _loop;
 	bool _crossfade;
 	uint8 _crossfadeTarget;
@@ -107,9 +106,9 @@ public:
 	bool process(uint32 deltaTimeInMillis);
 
 	void setVolume(uint8 volume);
-
-	void setPanTrack(int16 pos);
-	void unsetPanTrack();
+	uint8 getVolume();
+	void setDeltaVolume(uint8 volume);
+	void setBalance(int8 balance);
 
 	void setFade(int32 time, uint8 target);
 
@@ -126,8 +125,11 @@ public:
 	PanTrackNode(ZVision *engine, uint32 key, uint32 slot, int16 pos);
 	~PanTrackNode();
 
+	bool process(uint32 deltaTimeInMillis);
+
 private:
 	uint32 _slot;
+	int16 _position;
 };
 
 } // End of namespace ZVision
diff --git a/engines/zvision/scripting/effects/ttytext_effect.cpp b/engines/zvision/scripting/effects/ttytext_effect.cpp
index c60b3aa8c5..8d340dae39 100644
--- a/engines/zvision/scripting/effects/ttytext_effect.cpp
+++ b/engines/zvision/scripting/effects/ttytext_effect.cpp
@@ -57,9 +57,9 @@ ttyTextNode::ttyTextNode(ZVision *engine, uint32 key, const Common::String &file
 		delete infile;
 	}
 	_img.create(_r.width(), _r.height(), _engine->_resourcePixelFormat);
-	_style._sharp = true;
-	_style.readAllStyle(_txtbuf);
-	_style.setFont(_fnt);
+	_state._sharp = true;
+	_state.readAllStyles(_txtbuf);
+	_state.updateFontWithTextState(_fnt);
 	_engine->getScriptManager()->setStateValue(_key, 1);
 }
 
@@ -74,29 +74,27 @@ bool ttyTextNode::process(uint32 deltaTimeInMillis) {
 	if (_nexttime < 0) {
 		if (_txtpos < _txtbuf.size()) {
 			if (_txtbuf[_txtpos] == '<') {
-				int32 strt = _txtpos;
-				int32 endt = 0;
+				int32 start = _txtpos;
+				int32 end = 0;
 				int16 ret = 0;
 				while (_txtbuf[_txtpos] != '>' && _txtpos < _txtbuf.size())
 					_txtpos++;
-				endt = _txtpos;
-				if (strt != -1)
-					if ((endt - strt - 1) > 0)
-						ret = _style.parseStyle(_txtbuf.c_str() + strt + 1, endt - strt - 1);
-
-				if (ret & (TXT_RET_FNTCHG | TXT_RET_FNTSTL | TXT_RET_NEWLN)) {
-					if (ret & TXT_RET_FNTCHG)
-						_style.setFont(_fnt);
-					if (ret & TXT_RET_FNTSTL)
-						_style.setFontStyle(_fnt);
-
-					if (ret & TXT_RET_NEWLN)
-						newline();
+				end = _txtpos;
+				if (start != -1) {
+					if ((end - start - 1) > 0) {
+						ret = _state.parseStyle(_txtbuf.c_str() + start + 1, end - start - 1);
+					}
+				}
+
+				if (ret & (TEXT_CHANGE_FONT_TYPE | TEXT_CHANGE_FONT_STYLE)) {
+					_state.updateFontWithTextState(_fnt);
+				} else if (ret & TEXT_CHANGE_NEWLINE) {
+					newline();
 				}
 
-				if (ret & TXT_RET_HASSTBOX) {
+				if (ret & TEXT_CHANGE_HAS_STATE_BOX) {
 					Common::String buf;
-					buf = Common::String::format("%d", _engine->getScriptManager()->getStateValue(_style._statebox));
+					buf = Common::String::format("%d", _engine->getScriptManager()->getStateValue(_state._statebox));
 
 					for (uint8 j = 0; j < buf.size(); j++)
 						outchar(buf[j]);
@@ -158,7 +156,7 @@ void ttyTextNode::newline() {
 }
 
 void ttyTextNode::outchar(uint16 chr) {
-	uint32 clr = _engine->_resourcePixelFormat.RGBToColor(_style._red, _style._green, _style._blue);
+	uint32 clr = _engine->_resourcePixelFormat.RGBToColor(_state._red, _state._green, _state._blue);
 
 	if (_dx + _fnt.getCharWidth(chr) > _r.width())
 		newline();
diff --git a/engines/zvision/scripting/effects/ttytext_effect.h b/engines/zvision/scripting/effects/ttytext_effect.h
index 8d8a2518c7..18cbbbaee3 100644
--- a/engines/zvision/scripting/effects/ttytext_effect.h
+++ b/engines/zvision/scripting/effects/ttytext_effect.h
@@ -51,7 +51,7 @@ public:
 private:
 	Common::Rect _r;
 
-	cTxtStyle _style;
+	TextStyleState _state;
 	StyledTTFont _fnt;
 	Common::String _txtbuf;
 	uint32 _txtpos;
diff --git a/engines/zvision/scripting/menu.cpp b/engines/zvision/scripting/menu.cpp
index 16aa57e3ae..064bd1b57d 100644
--- a/engines/zvision/scripting/menu.cpp
+++ b/engines/zvision/scripting/menu.cpp
@@ -46,13 +46,13 @@ MenuHandler::MenuHandler(ZVision *engine) {
 MenuZGI::MenuZGI(ZVision *engine) :
 	MenuHandler(engine) {
 	menuMouseFocus = -1;
-	inmenu = false;
+	inMenu = false;
 	scrolled[0] = false;
 	scrolled[1] = false;
 	scrolled[2] = false;
-	scrollPos[0] = 0.0;
-	scrollPos[1] = 0.0;
-	scrollPos[2] = 0.0;
+	scrollPos[0] = 0;
+	scrollPos[1] = 0;
+	scrollPos[2] = 0;
 	mouseOnItem = -1;
 	redraw = false;
 	clean = false;
@@ -60,15 +60,15 @@ MenuZGI::MenuZGI(ZVision *engine) :
 	char buf[24];
 	for (int i = 1; i < 4; i++) {
 		sprintf(buf, "gmzau%2.2x1.tga", i);
-		_engine->getRenderManager()->readImageToSurface(buf, menuback[i - 1][0], false);
+		_engine->getRenderManager()->readImageToSurface(buf, menuBack[i - 1][0], false);
 		sprintf(buf, "gmzau%2.2x1.tga", i + 0x10);
-		_engine->getRenderManager()->readImageToSurface(buf, menuback[i - 1][1], false);
+		_engine->getRenderManager()->readImageToSurface(buf, menuBack[i - 1][1], false);
 	}
 	for (int i = 0; i < 4; i++) {
 		sprintf(buf, "gmzmu%2.2x1.tga", i);
-		_engine->getRenderManager()->readImageToSurface(buf, menubar[i][0], false);
+		_engine->getRenderManager()->readImageToSurface(buf, menuBar[i][0], false);
 		sprintf(buf, "gmznu%2.2x1.tga", i);
-		_engine->getRenderManager()->readImageToSurface(buf, menubar[i][1], false);
+		_engine->getRenderManager()->readImageToSurface(buf, menuBar[i][1], false);
 	}
 
 	for (int i = 0; i < 50; i++) {
@@ -86,12 +86,12 @@ MenuZGI::MenuZGI(ZVision *engine) :
 
 MenuZGI::~MenuZGI() {
 	for (int i = 0; i < 3; i++) {
-		menuback[i][0].free();
-		menuback[i][1].free();
+		menuBack[i][0].free();
+		menuBack[i][1].free();
 	}
 	for (int i = 0; i < 4; i++) {
-		menubar[i][0].free();
-		menubar[i][1].free();
+		menuBar[i][0].free();
+		menuBar[i][1].free();
 	}
 	for (int i = 0; i < 50; i++) {
 		if (items[i][0]) {
@@ -208,9 +208,9 @@ void MenuZGI::onMouseUp(const Common::Point &Pos) {
 void MenuZGI::onMouseMove(const Common::Point &Pos) {
 	if (Pos.y < 40) {
 
-		if (!inmenu)
+		if (!inMenu)
 			redraw = true;
-		inmenu = true;
+		inMenu = true;
 		switch (menuMouseFocus) {
 		case kMenuItem:
 			if (menuBarFlag & kMenubarItems) {
@@ -311,7 +311,7 @@ void MenuZGI::onMouseMove(const Common::Point &Pos) {
 			if (Common::Rect(64, 0, 64 + 512, 8).contains(Pos)) { // Main
 				menuMouseFocus = kMenuMain;
 				scrolled[kMenuMain]  = false;
-				scrollPos[kMenuMain] = menuback[kMenuMain][1].h - menuback[kMenuMain][0].h;
+				scrollPos[kMenuMain] = menuBack[kMenuMain][1].h - menuBack[kMenuMain][0].h;
 				_engine->getScriptManager()->setStateValue(StateKey_MenuState, 2);
 			}
 
@@ -337,9 +337,9 @@ void MenuZGI::onMouseMove(const Common::Point &Pos) {
 			break;
 		}
 	} else {
-		if (inmenu)
+		if (inMenu)
 			clean = true;
-		inmenu = false;
+		inMenu = false;
 		if (_engine->getScriptManager()->getStateValue(StateKey_MenuState) != 0)
 			_engine->getScriptManager()->setStateValue(StateKey_MenuState, 0);
 		menuMouseFocus = -1;
@@ -361,15 +361,15 @@ void MenuZGI::process(uint32 deltatime) {
 				if (scrl == 0)
 					scrl = 1.0;
 
-				scrollPos [kMenuItem] += scrl;
+				scrollPos[kMenuItem] += (int)scrl;
 
 				if (scrollPos[kMenuItem] >= 0) {
 					scrolled[kMenuItem] = true;
-					scrollPos [kMenuItem] = 0;
+					scrollPos[kMenuItem] = 0;
 				}
 			}
 		if (redraw) {
-			_engine->getRenderManager()->blitSurfaceToMenu(menuback[kMenuItem][0], scrollPos[kMenuItem], 0);
+			_engine->getRenderManager()->blitSurfaceToMenu(menuBack[kMenuItem][0], scrollPos[kMenuItem], 0);
 
 			int itemCount = _engine->getScriptManager()->getStateValue(StateKey_Inv_TotalSlots);
 			if (itemCount == 0)
@@ -430,15 +430,15 @@ void MenuZGI::process(uint32 deltatime) {
 				if (scrl == 0)
 					scrl = 1.0;
 
-				scrollPos [kMenuMagic] += scrl;
+				scrollPos[kMenuMagic] += (int)scrl;
 
 				if (scrollPos[kMenuMagic] >= 600) {
 					scrolled[kMenuMagic] = true;
-					scrollPos [kMenuMagic] = 600;
+					scrollPos[kMenuMagic] = 600;
 				}
 			}
 		if (redraw) {
-			_engine->getRenderManager()->blitSurfaceToMenu(menuback[kMenuMagic][0], 640 - scrollPos[kMenuMagic], 0);
+			_engine->getRenderManager()->blitSurfaceToMenu(menuBack[kMenuMagic][0], 640 - scrollPos[kMenuMagic], 0);
 
 			for (int i = 0; i < 12; i++) {
 				bool inrect = false;
@@ -495,53 +495,53 @@ void MenuZGI::process(uint32 deltatime) {
 			if (scrl == 0)
 				scrl = 1.0;
 
-			scrollPos [kMenuMain] += scrl;
+			scrollPos[kMenuMain] += (int)scrl;
 
 			if (scrollPos[kMenuMain] >= 0) {
 				scrolled[kMenuMain] = true;
-				scrollPos [kMenuMain] = 0;
+				scrollPos[kMenuMain] = 0;
 			}
 		}
 		if (redraw) {
-			_engine->getRenderManager()->blitSurfaceToMenu(menuback[kMenuMain][0], 30, scrollPos[kMenuMain]);
+			_engine->getRenderManager()->blitSurfaceToMenu(menuBack[kMenuMain][0], 30, scrollPos[kMenuMain]);
 
 			if (menuBarFlag & kMenubarExit) {
 				if (mouseOnItem == kMainMenuExit)
-					_engine->getRenderManager()->blitSurfaceToMenu(menubar[kMainMenuExit][1], 320 + 135, scrollPos[kMenuMain]);
+					_engine->getRenderManager()->blitSurfaceToMenu(menuBar[kMainMenuExit][1], 320 + 135, scrollPos[kMenuMain]);
 				else
-					_engine->getRenderManager()->blitSurfaceToMenu(menubar[kMainMenuExit][0], 320 + 135, scrollPos[kMenuMain]);
+					_engine->getRenderManager()->blitSurfaceToMenu(menuBar[kMainMenuExit][0], 320 + 135, scrollPos[kMenuMain]);
 			}
 			if (menuBarFlag & kMenubarSettings) {
 				if (mouseOnItem == kMainMenuPrefs)
-					_engine->getRenderManager()->blitSurfaceToMenu(menubar[kMainMenuPrefs][1], 320, scrollPos[kMenuMain]);
+					_engine->getRenderManager()->blitSurfaceToMenu(menuBar[kMainMenuPrefs][1], 320, scrollPos[kMenuMain]);
 				else
-					_engine->getRenderManager()->blitSurfaceToMenu(menubar[kMainMenuPrefs][0], 320, scrollPos[kMenuMain]);
+					_engine->getRenderManager()->blitSurfaceToMenu(menuBar[kMainMenuPrefs][0], 320, scrollPos[kMenuMain]);
 			}
 			if (menuBarFlag & kMenubarRestore) {
 				if (mouseOnItem == kMainMenuLoad)
-					_engine->getRenderManager()->blitSurfaceToMenu(menubar[kMainMenuLoad][1], 320 - 135, scrollPos[kMenuMain]);
+					_engine->getRenderManager()->blitSurfaceToMenu(menuBar[kMainMenuLoad][1], 320 - 135, scrollPos[kMenuMain]);
 				else
-					_engine->getRenderManager()->blitSurfaceToMenu(menubar[kMainMenuLoad][0], 320 - 135, scrollPos[kMenuMain]);
+					_engine->getRenderManager()->blitSurfaceToMenu(menuBar[kMainMenuLoad][0], 320 - 135, scrollPos[kMenuMain]);
 			}
 			if (menuBarFlag & kMenubarSave) {
 				if (mouseOnItem == kMainMenuSave)
-					_engine->getRenderManager()->blitSurfaceToMenu(menubar[kMainMenuSave][1], 320 - 135 * 2, scrollPos[kMenuMain]);
+					_engine->getRenderManager()->blitSurfaceToMenu(menuBar[kMainMenuSave][1], 320 - 135 * 2, scrollPos[kMenuMain]);
 				else
-					_engine->getRenderManager()->blitSurfaceToMenu(menubar[kMainMenuSave][0], 320 - 135 * 2, scrollPos[kMenuMain]);
+					_engine->getRenderManager()->blitSurfaceToMenu(menuBar[kMainMenuSave][0], 320 - 135 * 2, scrollPos[kMenuMain]);
 			}
 			redraw = false;
 		}
 		break;
 	default:
 		if (redraw) {
-			if (inmenu) {
-				_engine->getRenderManager()->blitSurfaceToMenu(menuback[kMenuMain][1], 30, 0);
+			if (inMenu) {
+				_engine->getRenderManager()->blitSurfaceToMenu(menuBack[kMenuMain][1], 30, 0);
 
 				if (menuBarFlag & kMenubarItems)
-					_engine->getRenderManager()->blitSurfaceToMenu(menuback[kMenuItem][1], 0, 0);
+					_engine->getRenderManager()->blitSurfaceToMenu(menuBack[kMenuItem][1], 0, 0);
 
 				if (menuBarFlag & kMenubarMagic)
-					_engine->getRenderManager()->blitSurfaceToMenu(menuback[kMenuMagic][1], 640 - 28, 0);
+					_engine->getRenderManager()->blitSurfaceToMenu(menuBack[kMenuMagic][1], 640 - 28, 0);
 			}
 			redraw = false;
 		}
@@ -551,9 +551,9 @@ void MenuZGI::process(uint32 deltatime) {
 
 MenuNemesis::MenuNemesis(ZVision *engine) :
 	MenuHandler(engine) {
-	inmenu = false;
+	inMenu = false;
 	scrolled = false;
-	scrollPos = 0.0;
+	scrollPos = 0;
 	mouseOnItem = -1;
 	redraw = false;
 	delay = 0;
@@ -565,7 +565,7 @@ MenuNemesis::MenuNemesis(ZVision *engine) :
 			_engine->getRenderManager()->readImageToSurface(buf, but[i][j], false);
 		}
 
-	_engine->getRenderManager()->readImageToSurface("bar.tga", menubar, false);
+	_engine->getRenderManager()->readImageToSurface("bar.tga", menuBar, false);
 
 	frm = 0;
 }
@@ -575,7 +575,7 @@ MenuNemesis::~MenuNemesis() {
 		for (int j = 0; j < 6; j++)
 			but[i][j].free();
 
-	menubar.free();
+	menuBar.free();
 }
 
 static const int16 buts[4][2] = { {120 , 64}, {144, 184}, {128, 328}, {120, 456} };
@@ -631,7 +631,7 @@ void MenuNemesis::onMouseUp(const Common::Point &Pos) {
 void MenuNemesis::onMouseMove(const Common::Point &Pos) {
 	if (Pos.y < 40) {
 
-		inmenu = true;
+		inMenu = true;
 
 		if (_engine->getScriptManager()->getStateValue(StateKey_MenuState) != 2)
 			_engine->getScriptManager()->setStateValue(StateKey_MenuState, 2);
@@ -681,7 +681,7 @@ void MenuNemesis::onMouseMove(const Common::Point &Pos) {
 			delay = 200;
 		}
 	} else {
-		inmenu = false;
+		inMenu = false;
 		if (_engine->getScriptManager()->getStateValue(StateKey_MenuState) != 0)
 			_engine->getScriptManager()->setStateValue(StateKey_MenuState, 0);
 		mouseOnItem = -1;
@@ -689,14 +689,14 @@ void MenuNemesis::onMouseMove(const Common::Point &Pos) {
 }
 
 void MenuNemesis::process(uint32 deltatime) {
-	if (inmenu) {
+	if (inMenu) {
 		if (!scrolled) {
 			float scrl = 32.0 * 2.0 * (deltatime / 1000.0);
 
 			if (scrl == 0)
 				scrl = 1.0;
 
-			scrollPos += scrl;
+			scrollPos += (int)scrl;
 			redraw = true;
 		}
 
@@ -715,7 +715,7 @@ void MenuNemesis::process(uint32 deltatime) {
 		}
 
 		if (redraw) {
-			_engine->getRenderManager()->blitSurfaceToMenu(menubar, 64, scrollPos);
+			_engine->getRenderManager()->blitSurfaceToMenu(menuBar, 64, scrollPos);
 
 			if (menuBarFlag & kMenubarExit)
 				if (mouseOnItem == kMainMenuExit)
@@ -743,16 +743,16 @@ void MenuNemesis::process(uint32 deltatime) {
 			if (scrl == 0)
 				scrl = 1.0;
 
-			Common::Rect cl(64, 32 + scrollPos - scrl, 64 + 512, 32 + scrollPos + 1);
+			Common::Rect cl(64, (int16)(32 + scrollPos - scrl), 64 + 512, 32 + scrollPos + 1);
 			_engine->getRenderManager()->clearMenuSurface(cl);
 
-			scrollPos -= scrl;
+			scrollPos -= (int)scrl;
 			redraw = true;
 		} else
 			scrollPos = -32;
 
 		if (redraw) {
-			_engine->getRenderManager()->blitSurfaceToMenu(menubar, 64, scrollPos);
+			_engine->getRenderManager()->blitSurfaceToMenu(menuBar, 64, scrollPos);
 			redraw = false;
 		}
 	}
diff --git a/engines/zvision/scripting/menu.h b/engines/zvision/scripting/menu.h
index a88587966f..f6b21b9c97 100644
--- a/engines/zvision/scripting/menu.h
+++ b/engines/zvision/scripting/menu.h
@@ -68,8 +68,8 @@ public:
 	void onMouseUp(const Common::Point &Pos);
 	void process(uint32 deltaTimeInMillis);
 private:
-	Graphics::Surface menuback[3][2];
-	Graphics::Surface menubar[4][2];
+	Graphics::Surface menuBack[3][2];
+	Graphics::Surface menuBar[4][2];
 	Graphics::Surface *items[50][2];
 	uint itemId[50];
 
@@ -77,11 +77,11 @@ private:
 	uint magicId[12];
 
 	int menuMouseFocus;
-	bool inmenu;
+	bool inMenu;
 
 	int mouseOnItem;
 
-	bool   scrolled[3];
+	bool scrolled[3];
 	int16 scrollPos[3];
 
 	bool clean;
@@ -98,13 +98,13 @@ public:
 	void process(uint32 deltaTimeInMillis);
 private:
 	Graphics::Surface but[4][6];
-	Graphics::Surface menubar;
+	Graphics::Surface menuBar;
 
-	bool inmenu;
+	bool inMenu;
 
 	int mouseOnItem;
 
-	bool   scrolled;
+	bool scrolled;
 	int16 scrollPos;
 
 	bool redraw;
@@ -114,6 +114,6 @@ private:
 
 };
 
-}
+} // End of namespace ZVision
 
 #endif
diff --git a/engines/zvision/scripting/scr_file_handling.cpp b/engines/zvision/scripting/scr_file_handling.cpp
index 7856bf7b2e..edc1b8622c 100644
--- a/engines/zvision/scripting/scr_file_handling.cpp
+++ b/engines/zvision/scripting/scr_file_handling.cpp
@@ -47,15 +47,13 @@ namespace ZVision {
 void ScriptManager::parseScrFile(const Common::String &fileName, ScriptScope &scope) {
 	Common::File file;
 	if (!_engine->getSearchManager()->openFile(file, fileName)) {
-		warning("Script file not found: %s", fileName.c_str());
-		return;
+		error("Script file not found: %s", fileName.c_str());
 	}
 
 	while (!file.eos()) {
 		Common::String line = file.readLine();
 		if (file.err()) {
-			warning("Error parsing scr file: %s", fileName.c_str());
-			return;
+			error("Error parsing scr file: %s", fileName.c_str());
 		}
 
 		trimCommentsAndWhiteSpace(&line);
@@ -85,9 +83,18 @@ void ScriptManager::parsePuzzle(Puzzle *puzzle, Common::SeekableReadStream &stre
 
 	while (!stream.eos() && !line.contains('}')) {
 		if (line.matchString("criteria {", true)) {
-			parseCriteria(stream, puzzle->criteriaList);
+			parseCriteria(stream, puzzle->criteriaList, puzzle->key);
 		} else if (line.matchString("results {", true)) {
 			parseResults(stream, puzzle->resultActions);
+
+			// WORKAROUND for a script bug in Zork Nemesis, room ve5e (tuning
+			// fork box closeup). If the player leaves the screen while the
+			// box is open, puzzle 19398 shows the animation where the box
+			// closes, but the box state (state variable 19397) is not updated.
+			// We insert the missing assignment for the box state here.
+			// Fixes bug #6803.
+			if (_engine->getGameId() == GID_NEMESIS && puzzle->key == 19398)
+				puzzle->resultActions.push_back(new ActionAssign(_engine, 11, "19397, 0"));
 		} else if (line.matchString("flags {", true)) {
 			setStateFlag(puzzle->key, parseFlags(stream));
 		}
@@ -99,11 +106,18 @@ void ScriptManager::parsePuzzle(Puzzle *puzzle, Common::SeekableReadStream &stre
 	puzzle->addedBySetState = false;
 }
 
-bool ScriptManager::parseCriteria(Common::SeekableReadStream &stream, Common::List<Common::List<Puzzle::CriteriaEntry> > &criteriaList) const {
+bool ScriptManager::parseCriteria(Common::SeekableReadStream &stream, Common::List<Common::List<Puzzle::CriteriaEntry> > &criteriaList, uint32 key) const {
 	// Loop until we find the closing brace
 	Common::String line = stream.readLine();
 	trimCommentsAndWhiteSpace(&line);
 
+	// Skip any commented out criteria. If all the criteria are commented out,
+	// we might end up with an invalid criteria list (bug #6776).
+	while (line.empty()) {
+		line = stream.readLine();
+		trimCommentsAndWhiteSpace(&line);
+	}
+
 	// Criteria can be empty
 	if (line.contains('}')) {
 		return false;
@@ -112,6 +126,21 @@ bool ScriptManager::parseCriteria(Common::SeekableReadStream &stream, Common::Li
 	// Create a new List to hold the CriteriaEntries
 	criteriaList.push_back(Common::List<Puzzle::CriteriaEntry>());
 
+	// WORKAROUND for a script bug in Zork: Nemesis, room td9e (fist puzzle)
+	// Since we patch the script that triggers when manipulating the left fist
+	// (below), we add an additional check for the left fist sound, so that it
+	// doesn't get killed immediately when the left fist animation starts.
+	// Together with the workaround below, it fixes bug #6783.
+	if (_engine->getGameId() == GID_NEMESIS && key == 3594) {
+		Puzzle::CriteriaEntry entry;
+		entry.key = 567;
+		entry.criteriaOperator = Puzzle::NOT_EQUAL_TO;
+		entry.argumentIsAKey = false;
+		entry.argument = 1;
+
+		criteriaList.back().push_back(entry);
+	}
+
 	while (!stream.eos() && !line.contains('}')) {
 		Puzzle::CriteriaEntry entry;
 
@@ -123,6 +152,13 @@ bool ScriptManager::parseCriteria(Common::SeekableReadStream &stream, Common::Li
 		token = tokenizer.nextToken();
 		sscanf(token.c_str(), "[%u]", &(entry.key));
 
+		// WORKAROUND for a script bug in Zork: Nemesis, room td9e (fist puzzle)
+		// Check for the state of animation 567 (left fist) when manipulating
+		// the fingers of the left fist (puzzle slots 3582, 3583).
+		// Together with the workaround above, it fixes bug #6783.
+		if (_engine->getGameId() == GID_NEMESIS && (key == 3582 || key == 3583) && entry.key == 568)
+			entry.key = 567;
+
 		// Parse the operator out of the second token
 		token = tokenizer.nextToken();
 		if (token.c_str()[0] == '=')
@@ -134,9 +170,17 @@ bool ScriptManager::parseCriteria(Common::SeekableReadStream &stream, Common::Li
 		else if (token.c_str()[0] == '<')
 			entry.criteriaOperator = Puzzle::LESS_THAN;
 
+		// There are supposed to be three tokens, but there is no
+		// guarantee that there will be a space between the second and
+		// the third one (bug #6774)
+		if (token.size() == 1) {
+			token = tokenizer.nextToken();
+		} else {
+			token.deleteChar(0);
+		}
+
 		// First determine if the last token is an id or a value
 		// Then parse it into 'argument'
-		token = tokenizer.nextToken();
 		if (token.contains('[')) {
 			sscanf(token.c_str(), "[%u]", &(entry.argument));
 			entry.argumentIsAKey = true;
@@ -271,8 +315,8 @@ void ScriptManager::parseResults(Common::SeekableReadStream &stream, Common::Lis
 					actionList.push_back(new ActionRegion(_engine, slot, args));
 				} else if (act.matchString("restore_game", true)) {
 					// Only used by ZGI to load the restart game slot, r.svr.
-					_engine->getScriptManager()->reset();
-					_engine->getScriptManager()->changeLocation('g', 'a', 'r', 'y', 0);
+					// Used by the credits screen.
+					actionList.push_back(new ActionRestoreGame(_engine, slot, args));
 				} else if (act.matchString("rotate_to", true)) {
 					actionList.push_back(new ActionRotateTo(_engine, slot, args));
 				} else if (act.matchString("save_game", true)) {
@@ -343,6 +387,16 @@ Control *ScriptManager::parseControl(Common::String &line, Common::SeekableReadS
 	Common::String controlType(controlTypeBuffer);
 
 	if (controlType.equalsIgnoreCase("push_toggle")) {
+		// WORKAROUND for a script bug in ZGI: There is an invalid hotspot
+		// at scene em1h (bottom of tower), which points to a missing
+		// script em1n. This is a hotspot at the right of the screen.
+		// In the original, this hotspot doesn't lead anywhere anyway,
+		// so instead of moving to a missing scene, we just remove the
+		// hotspot altogether. The alternative would be to just process
+		// and ignore invalid scenes, but I don't think it's worth the
+		// effort. Fixes bug #6780.
+		if (_engine->getGameId() == GID_GRANDINQUISITOR && key == 5653)
+			return NULL;
 		return new PushToggleControl(_engine, key, stream);
 	} else if (controlType.equalsIgnoreCase("flat")) {
 		Control::parseFlatControl(_engine);
diff --git a/engines/zvision/scripting/script_manager.cpp b/engines/zvision/scripting/script_manager.cpp
index ba38d3a0e4..70eaab2a0a 100644
--- a/engines/zvision/scripting/script_manager.cpp
+++ b/engines/zvision/scripting/script_manager.cpp
@@ -72,21 +72,23 @@ void ScriptManager::initialize() {
 }
 
 void ScriptManager::update(uint deltaTimeMillis) {
-	if (_currentLocation.node != _nextLocation.node ||
-	        _currentLocation.room != _nextLocation.room ||
-	        _currentLocation.view != _nextLocation.view ||
-	        _currentLocation.world != _nextLocation.world)
-		ChangeLocationReal();
+	if (_currentLocation != _nextLocation) {
+		ChangeLocationReal(false);
+	}
 
 	updateNodes(deltaTimeMillis);
-	if (! execScope(nodeview))
+	if (!execScope(nodeview)) {
 		return;
-	if (! execScope(room))
+	}
+	if (!execScope(room)) {
 		return;
-	if (! execScope(world))
+	}
+	if (!execScope(world)) {
 		return;
-	if (! execScope(universe))
+	}
+	if (!execScope(universe)) {
 		return;
+	}
 	updateControls(deltaTimeMillis);
 }
 
@@ -97,17 +99,22 @@ bool ScriptManager::execScope(ScriptScope &scope) {
 	scope.scopeQueue = tmp;
 	scope.scopeQueue->clear();
 
-	for (PuzzleList::iterator PuzzleIter = scope.puzzles.begin(); PuzzleIter != scope.puzzles.end(); ++PuzzleIter)
+	for (PuzzleList::iterator PuzzleIter = scope.puzzles.begin(); PuzzleIter != scope.puzzles.end(); ++PuzzleIter) {
 		(*PuzzleIter)->addedBySetState = false;
+	}
 
 	if (scope.procCount < 2 || getStateValue(StateKey_ExecScopeStyle)) {
-		for (PuzzleList::iterator PuzzleIter = scope.puzzles.begin(); PuzzleIter != scope.puzzles.end(); ++PuzzleIter)
-			if (!checkPuzzleCriteria(*PuzzleIter, scope.procCount))
+		for (PuzzleList::iterator PuzzleIter = scope.puzzles.begin(); PuzzleIter != scope.puzzles.end(); ++PuzzleIter) {
+			if (!checkPuzzleCriteria(*PuzzleIter, scope.procCount)) {
 				return false;
+			}
+		}
 	} else {
-		for (PuzzleList::iterator PuzzleIter = scope.execQueue->begin(); PuzzleIter != scope.execQueue->end(); ++PuzzleIter)
-			if (!checkPuzzleCriteria(*PuzzleIter, scope.procCount))
+		for (PuzzleList::iterator PuzzleIter = scope.execQueue->begin(); PuzzleIter != scope.execQueue->end(); ++PuzzleIter) {
+			if (!checkPuzzleCriteria(*PuzzleIter, scope.procCount)) {
 				return false;
+			}
+		}
 	}
 
 	if (scope.procCount < 2) {
@@ -119,9 +126,11 @@ bool ScriptManager::execScope(ScriptScope &scope) {
 void ScriptManager::referenceTableAddPuzzle(uint32 key, PuzzleRef ref) {
 	if (_referenceTable.contains(key)) {
 		Common::Array<PuzzleRef> *arr = &_referenceTable[key];
-		for (uint32 i = 0; i < arr->size(); i++)
-			if ((*arr)[i].puz == ref.puz)
+		for (uint32 i = 0; i < arr->size(); i++) {
+			if ((*arr)[i].puz == ref.puz) {
 				return;
+			}
+		}
 	}
 
 	_referenceTable[key].push_back(ref);
@@ -139,9 +148,11 @@ void ScriptManager::addPuzzlesToReferenceTable(ScriptScope &scope) {
 		referenceTableAddPuzzle(puzzlePtr->key, ref);
 
 		// Iterate through each CriteriaEntry and add a reference from the criteria key to the Puzzle
-		for (Common::List<Common::List<Puzzle::CriteriaEntry> >::iterator criteriaIter = (*PuzzleIter)->criteriaList.begin(); criteriaIter != (*PuzzleIter)->criteriaList.end(); ++criteriaIter)
-			for (Common::List<Puzzle::CriteriaEntry>::iterator entryIter = criteriaIter->begin(); entryIter != criteriaIter->end(); ++entryIter)
+		for (Common::List<Common::List<Puzzle::CriteriaEntry> >::iterator criteriaIter = (*PuzzleIter)->criteriaList.begin(); criteriaIter != (*PuzzleIter)->criteriaList.end(); ++criteriaIter) {
+			for (Common::List<Puzzle::CriteriaEntry>::iterator entryIter = criteriaIter->begin(); entryIter != criteriaIter->end(); ++entryIter) {
 				referenceTableAddPuzzle(entryIter->key, ref);
+			}
+		}
 	}
 }
 
@@ -159,8 +170,9 @@ void ScriptManager::updateNodes(uint deltaTimeMillis) {
 }
 
 void ScriptManager::updateControls(uint deltaTimeMillis) {
-	if (!_activeControls)
+	if (!_activeControls) {
 		return;
+	}
 
 	// Process only one event
 	if (!_controlEvents.empty()) {
@@ -187,21 +199,24 @@ void ScriptManager::updateControls(uint deltaTimeMillis) {
 		_controlEvents.pop_front();
 	}
 
-	for (ControlList::iterator iter = _activeControls->begin(); iter != _activeControls->end(); iter++)
-		if ((*iter)->process(deltaTimeMillis))
+	for (ControlList::iterator iter = _activeControls->begin(); iter != _activeControls->end(); iter++) {
+		if ((*iter)->process(deltaTimeMillis)) {
 			break;
+		}
+	}
 }
 
 bool ScriptManager::checkPuzzleCriteria(Puzzle *puzzle, uint counter) {
 	// Check if the puzzle is already finished
 	// Also check that the puzzle isn't disabled
-	if (getStateValue(puzzle->key) == 1 || (getStateFlag(puzzle->key) & Puzzle::DISABLED) == Puzzle::DISABLED) {
+	if (getStateValue(puzzle->key) == 1 || (getStateFlag(puzzle->key) & Puzzle::DISABLED)) {
 		return true;
 	}
 
 	// Check each Criteria
-	if (counter == 0 && (getStateFlag(puzzle->key) & Puzzle::DO_ME_NOW) == 0)
+	if (counter == 0 && (getStateFlag(puzzle->key) & Puzzle::DO_ME_NOW) == 0) {
 		return true;
+	}
 
 	bool criteriaMet = false;
 	for (Common::List<Common::List<Puzzle::CriteriaEntry> >::iterator criteriaIter = puzzle->criteriaList.begin(); criteriaIter != puzzle->criteriaList.end(); ++criteriaIter) {
@@ -210,10 +225,11 @@ bool ScriptManager::checkPuzzleCriteria(Puzzle *puzzle, uint counter) {
 		for (Common::List<Puzzle::CriteriaEntry>::iterator entryIter = criteriaIter->begin(); entryIter != criteriaIter->end(); ++entryIter) {
 			// Get the value to compare against
 			int argumentValue;
-			if (entryIter->argumentIsAKey)
+			if (entryIter->argumentIsAKey) {
 				argumentValue = getStateValue(entryIter->argument);
-			else
+			} else {
 				argumentValue = entryIter->argument;
+			}
 
 			// Do the comparison
 			switch (entryIter->criteriaOperator) {
@@ -251,8 +267,9 @@ bool ScriptManager::checkPuzzleCriteria(Puzzle *puzzle, uint counter) {
 		setStateValue(puzzle->key, 1);
 
 		for (Common::List<ResultAction *>::iterator resultIter = puzzle->resultActions.begin(); resultIter != puzzle->resultActions.end(); ++resultIter) {
-			if (!(*resultIter)->execute())
+			if (!(*resultIter)->execute()) {
 				return false;
+			}
 		}
 	}
 
@@ -275,13 +292,15 @@ void ScriptManager::cleanScriptScope(ScriptScope &scope) {
 	scope.privQueueTwo.clear();
 	scope.scopeQueue = &scope.privQueueOne;
 	scope.execQueue = &scope.privQueueTwo;
-	for (PuzzleList::iterator iter = scope.puzzles.begin(); iter != scope.puzzles.end(); ++iter)
+	for (PuzzleList::iterator iter = scope.puzzles.begin(); iter != scope.puzzles.end(); ++iter) {
 		delete(*iter);
+	}
 
 	scope.puzzles.clear();
 
-	for (ControlList::iterator iter = scope.controls.begin(); iter != scope.controls.end(); ++iter)
+	for (ControlList::iterator iter = scope.controls.begin(); iter != scope.controls.end(); ++iter) {
 		delete(*iter);
+	}
 
 	scope.controls.clear();
 
@@ -289,44 +308,49 @@ void ScriptManager::cleanScriptScope(ScriptScope &scope) {
 }
 
 int ScriptManager::getStateValue(uint32 key) {
-	if (_globalState.contains(key))
+	if (_globalState.contains(key)) {
 		return _globalState[key];
-	else
+	} else {
 		return 0;
+	}
 }
 
 void ScriptManager::queuePuzzles(uint32 key) {
 	if (_referenceTable.contains(key)) {
 		Common::Array<PuzzleRef> *arr = &_referenceTable[key];
-		for (int32 i = arr->size() - 1; i >= 0; i--)
+		for (int32 i = arr->size() - 1; i >= 0; i--) {
 			if (!(*arr)[i].puz->addedBySetState) {
 				(*arr)[i].scope->scopeQueue->push_back((*arr)[i].puz);
 				(*arr)[i].puz->addedBySetState = true;
 			}
+		}
 	}
 }
 
 void ScriptManager::setStateValue(uint32 key, int value) {
-	if (value == 0)
+	if (value == 0) {
 		_globalState.erase(key);
-	else
+	} else {
 		_globalState[key] = value;
+	}
 
 	queuePuzzles(key);
 }
 
 void ScriptManager::setStateValueSilent(uint32 key, int value) {
-	if (value == 0)
+	if (value == 0) {
 		_globalState.erase(key);
-	else
+	} else {
 		_globalState[key] = value;
+	}
 }
 
 uint ScriptManager::getStateFlag(uint32 key) {
-	if (_globalStateFlags.contains(key))
+	if (_globalStateFlags.contains(key)) {
 		return _globalStateFlags[key];
-	else
+	} else {
 		return 0;
+	}
 }
 
 void ScriptManager::setStateFlag(uint32 key, uint value) {
@@ -336,10 +360,11 @@ void ScriptManager::setStateFlag(uint32 key, uint value) {
 }
 
 void ScriptManager::setStateFlagSilent(uint32 key, uint value) {
-	if (value == 0)
+	if (value == 0) {
 		_globalStateFlags.erase(key);
-	else
+	} else {
 		_globalStateFlags[key] = value;
+	}
 }
 
 void ScriptManager::unsetStateFlag(uint32 key, uint value) {
@@ -348,23 +373,29 @@ void ScriptManager::unsetStateFlag(uint32 key, uint value) {
 	if (_globalStateFlags.contains(key)) {
 		_globalStateFlags[key] &= ~value;
 
-		if (_globalStateFlags[key] == 0)
+		if (_globalStateFlags[key] == 0) {
 			_globalStateFlags.erase(key);
+		}
 	}
 }
 
 Control *ScriptManager::getControl(uint32 key) {
-	for (ControlList::iterator iter = _activeControls->begin(); iter != _activeControls->end(); ++iter)
-		if ((*iter)->getKey() == key)
+	for (ControlList::iterator iter = _activeControls->begin(); iter != _activeControls->end(); ++iter) {
+		if ((*iter)->getKey() == key) {
 			return *iter;
+		}
+	}
+
 	return nullptr;
 }
 
 void ScriptManager::focusControl(uint32 key) {
-	if (!_activeControls)
+	if (!_activeControls) {
 		return;
-	if (_currentlyFocusedControl == key)
+	}
+	if (_currentlyFocusedControl == key) {
 		return;
+	}
 	for (ControlList::iterator iter = _activeControls->begin(); iter != _activeControls->end(); ++iter) {
 		uint32 controlKey = (*iter)->getKey();
 
@@ -443,50 +474,60 @@ void ScriptManager::killSideFxType(ScriptingEffect::ScriptingEffectType type) {
 }
 
 void ScriptManager::onMouseDown(const Common::Point &screenSpacePos, const Common::Point &backgroundImageSpacePos) {
-	if (!_activeControls)
+	if (!_activeControls) {
 		return;
+	}
 	for (ControlList::iterator iter = _activeControls->reverse_begin(); iter != _activeControls->end(); iter--) {
-		if ((*iter)->onMouseDown(screenSpacePos, backgroundImageSpacePos))
+		if ((*iter)->onMouseDown(screenSpacePos, backgroundImageSpacePos)) {
 			return;
+		}
 	}
 }
 
 void ScriptManager::onMouseUp(const Common::Point &screenSpacePos, const Common::Point &backgroundImageSpacePos) {
-	if (!_activeControls)
+	if (!_activeControls) {
 		return;
+	}
 	for (ControlList::iterator iter = _activeControls->reverse_begin(); iter != _activeControls->end(); iter--) {
-		if ((*iter)->onMouseUp(screenSpacePos, backgroundImageSpacePos))
+		if ((*iter)->onMouseUp(screenSpacePos, backgroundImageSpacePos)) {
 			return;
+		}
 	}
 }
 
 bool ScriptManager::onMouseMove(const Common::Point &screenSpacePos, const Common::Point &backgroundImageSpacePos) {
-	if (!_activeControls)
+	if (!_activeControls) {
 		return false;
+	}
 
 	for (ControlList::iterator iter = _activeControls->reverse_begin(); iter != _activeControls->end(); iter--) {
-		if ((*iter)->onMouseMove(screenSpacePos, backgroundImageSpacePos))
+		if ((*iter)->onMouseMove(screenSpacePos, backgroundImageSpacePos)) {
 			return true;
+		}
 	}
 
 	return false;
 }
 
 void ScriptManager::onKeyDown(Common::KeyState keyState) {
-	if (!_activeControls)
+	if (!_activeControls) {
 		return;
+	}
 	for (ControlList::iterator iter = _activeControls->begin(); iter != _activeControls->end(); ++iter) {
-		if ((*iter)->onKeyDown(keyState))
+		if ((*iter)->onKeyDown(keyState)) {
 			return;
+		}
 	}
 }
 
 void ScriptManager::onKeyUp(Common::KeyState keyState) {
-	if (!_activeControls)
+	if (!_activeControls) {
 		return;
+	}
 	for (ControlList::iterator iter = _activeControls->begin(); iter != _activeControls->end(); ++iter) {
-		if ((*iter)->onKeyUp(keyState))
+		if ((*iter)->onKeyUp(keyState)) {
 			return;
+		}
 	}
 }
 
@@ -500,8 +541,8 @@ void ScriptManager::changeLocation(char _world, char _room, char _node, char _vi
 	_nextLocation.node = _node;
 	_nextLocation.view = _view;
 	_nextLocation.offset = offset;
-	// If next location 0000 - it's indicate to go to previous location.
-	if (_nextLocation.world == '0' && _nextLocation.room == '0' && _nextLocation.node == '0' && _nextLocation.view == '0') {
+	// If next location is 0000, return to the previous location.
+	if (_nextLocation == "0000") {
 		if (getStateValue(StateKey_World) != 'g' || getStateValue(StateKey_Room) != 'j') {
 			_nextLocation.world = getStateValue(StateKey_LastWorld);
 			_nextLocation.room = getStateValue(StateKey_LastRoom);
@@ -518,36 +559,42 @@ void ScriptManager::changeLocation(char _world, char _room, char _node, char _vi
 	}
 }
 
-void ScriptManager::ChangeLocationReal() {
+void ScriptManager::ChangeLocationReal(bool isLoading) {
 	assert(_nextLocation.world != 0);
 	debug(1, "Changing location to: %c %c %c %c %u", _nextLocation.world, _nextLocation.room, _nextLocation.node, _nextLocation.view, _nextLocation.offset);
 
-	if (_nextLocation.world == 'g' && _nextLocation.room == 'j' && !ConfMan.getBool("originalsaveload")) {
-		if ((_nextLocation.node == 's' || _nextLocation.node == 'r') && _nextLocation.view == 'e') {
+	const bool enteringMenu = (_nextLocation.world == 'g' && _nextLocation.room == 'j');
+	const bool leavingMenu = (_currentLocation.world == 'g' && _currentLocation.room == 'j');
+	const bool isSaveScreen = (enteringMenu && _nextLocation.node == 's' && _nextLocation.view == 'e');
+	const bool isRestoreScreen = (enteringMenu && _nextLocation.node == 'r' && _nextLocation.view == 'e');
+
+	if (enteringMenu && !ConfMan.getBool("originalsaveload")) {
+		if (isSaveScreen || isRestoreScreen) {
 			// Hook up the ScummVM save/restore dialog
-			bool isSave = (_nextLocation.node == 's');
-			bool gameSavedOrLoaded = _engine->getSaveManager()->scummVMSaveLoadDialog(isSave);
-			if (!gameSavedOrLoaded || isSave) {
+			bool gameSavedOrLoaded = _engine->getSaveManager()->scummVMSaveLoadDialog(isSaveScreen);
+			if (!gameSavedOrLoaded || isSaveScreen) {
 				// Reload the current room
 				_nextLocation.world = _currentLocation.world;
 				_nextLocation.room = _currentLocation.room;
 				_nextLocation.node = _currentLocation.node;
 				_nextLocation.view = _currentLocation.view;
 				_nextLocation.offset = _currentLocation.offset;
-				_currentLocation.world = '0';
+				
+				return;
+			} else {
+				_currentLocation.world = 'g';
 				_currentLocation.room = '0';
 				_currentLocation.node = '0';
 				_currentLocation.view = '0';
 				_currentLocation.offset = 0;
-			} else
-				return;
+			}
 		}
 	}
 
 	_engine->setRenderDelay(2);
 
-	if (getStateValue(StateKey_World) != 'g' || getStateValue(StateKey_Room) != 'j') {
-		if (_nextLocation.world != 'g' || _nextLocation.room != 'j') {
+	if (!leavingMenu) {
+		if (!isLoading && !enteringMenu) {
 			setStateValue(StateKey_LastWorld, getStateValue(StateKey_World));
 			setStateValue(StateKey_LastRoom, getStateValue(StateKey_Room));
 			setStateValue(StateKey_LastNode, getStateValue(StateKey_Node));
@@ -562,13 +609,14 @@ void ScriptManager::ChangeLocationReal() {
 		}
 	}
 
-	if (_nextLocation.world == 'g' && _nextLocation.room == 'j') {
-		if (_nextLocation.node == 's' && _nextLocation.view == 'e' &&
-		        _currentLocation.world != 'g' && _currentLocation.room != 'j')
+	if (enteringMenu) {
+		if (isSaveScreen && !leavingMenu) {
 			_engine->getSaveManager()->prepareSaveBuffer();
+		}
 	} else {
-		if (_currentLocation.world == 'g' && _currentLocation.room == 'j')
+		if (leavingMenu) {
 			_engine->getSaveManager()->flushSaveBuffer();
+		}
 	}
 
 	setStateValue(StateKey_World, _nextLocation.world);
@@ -631,7 +679,7 @@ void ScriptManager::ChangeLocationReal() {
 	// Change the background position
 	_engine->getRenderManager()->setBackgroundPosition(_nextLocation.offset);
 
-	if (_currentLocation.world == 0 && _currentLocation.room == 0 && _currentLocation.node == 0 && _currentLocation.view == 0) {
+	if (_currentLocation == "0000") {
 		_currentLocation = _nextLocation;
 		execScope(world);
 		execScope(room);
@@ -664,29 +712,33 @@ void ScriptManager::serialize(Common::WriteStream *stream) {
 	stream->writeByte(getStateValue(StateKey_View));
 	stream->writeUint32LE(getStateValue(StateKey_ViewPos));
 
-	for (SideFXList::iterator iter = _activeSideFx.begin(); iter != _activeSideFx.end(); ++iter)
+	for (SideFXList::iterator iter = _activeSideFx.begin(); iter != _activeSideFx.end(); ++iter) {
 		(*iter)->serialize(stream);
+	}
 
 	stream->writeUint32BE(MKTAG('F', 'L', 'A', 'G'));
 
 	int32 slots = 20000;
-	if (_engine->getGameId() == GID_NEMESIS)
+	if (_engine->getGameId() == GID_NEMESIS) {
 		slots = 30000;
+	}
 
 	stream->writeUint32LE(slots * 2);
 
-	for (int32 i = 0; i < slots; i++)
+	for (int32 i = 0; i < slots; i++) {
 		stream->writeUint16LE(getStateFlag(i));
+	}
 
 	stream->writeUint32BE(MKTAG('P', 'U', 'Z', 'Z'));
 
 	stream->writeUint32LE(slots * 2);
 
-	for (int32 i = 0; i < slots; i++)
+	for (int32 i = 0; i < slots; i++) {
 		stream->writeSint16LE(getStateValue(i));
+	}
 }
 
-void ScriptManager::reset() {
+void ScriptManager::deserialize(Common::SeekableReadStream *stream) {
 	// Clear out the current table values
 	_globalState.clear();
 	_globalStateFlags.clear();
@@ -700,16 +752,13 @@ void ScriptManager::reset() {
 	_currentLocation.room = 0;
 	_currentLocation.view = 0;
 
-	for (SideFXList::iterator iter = _activeSideFx.begin(); iter != _activeSideFx.end(); iter++)
+	for (SideFXList::iterator iter = _activeSideFx.begin(); iter != _activeSideFx.end(); iter++) {
 		delete(*iter);
+	}
 
 	_activeSideFx.clear();
 
 	_referenceTable.clear();
-}
-
-void ScriptManager::deserialize(Common::SeekableReadStream *stream) {
-	reset();
 
 	if (stream->readUint32BE() != MKTAG('Z', 'N', 'S', 'G') || stream->readUint32LE() != 4) {
 		changeLocation('g', 'a', 'r', 'y', 0);
@@ -738,20 +787,23 @@ void ScriptManager::deserialize(Common::SeekableReadStream *stream) {
 		case MKTAG('T', 'I', 'M', 'R'): {
 			uint32 key = stream->readUint32LE();
 			uint32 time = stream->readUint32LE();
-			if (_engine->getGameId() == GID_GRANDINQUISITOR)
+			if (_engine->getGameId() == GID_GRANDINQUISITOR) {
 				time /= 100;
-			else if (_engine->getGameId() == GID_NEMESIS)
+			} else if (_engine->getGameId() == GID_NEMESIS) {
 				time /= 1000;
+			}
 			addSideFX(new TimerNode(_engine, key, time));
 		}
 		break;
 		case MKTAG('F', 'L', 'A', 'G'):
-			for (uint32 i = 0; i < tagSize / 2; i++)
+			for (uint32 i = 0; i < tagSize / 2; i++) {
 				setStateFlagSilent(i, stream->readUint16LE());
+			}
 			break;
 		case MKTAG('P', 'U', 'Z', 'Z'):
-			for (uint32 i = 0; i < tagSize / 2; i++)
+			for (uint32 i = 0; i < tagSize / 2; i++) {
 				setStateValueSilent(i, stream->readUint16LE());
+			}
 			break;
 		default:
 			stream->seek(tagSize, SEEK_CUR);
@@ -760,7 +812,7 @@ void ScriptManager::deserialize(Common::SeekableReadStream *stream) {
 
 	_nextLocation = nextLocation;
 
-	ChangeLocationReal();
+	ChangeLocationReal(true);
 
 	_engine->setRenderDelay(10);
 	setStateValue(StateKey_RestoreFlag, 1);
@@ -805,10 +857,11 @@ void ScriptManager::flushEvent(Common::EventType type) {
 	EventList::iterator it = _controlEvents.begin();
 	while (it != _controlEvents.end()) {
 
-		if ((*it).type == type)
+		if ((*it).type == type) {
 			it = _controlEvents.erase(it);
-		else
+		} else {
 			it++;
+		}
 	}
 }
 
@@ -837,12 +890,15 @@ ValueSlot::ValueSlot(ScriptManager *scriptManager, const char *slotValue):
 }
 int16 ValueSlot::getValue() {
 	if (slot) {
-		if (value >= 0)
+		if (value >= 0) {
 			return _scriptManager->getStateValue(value);
-		else
+		}
+		else {
 			return 0;
-	} else
+		}
+	} else {
 		return value;
+	}
 }
 
 } // End of namespace ZVision
diff --git a/engines/zvision/scripting/script_manager.h b/engines/zvision/scripting/script_manager.h
index a05c112a18..7c276bf917 100644
--- a/engines/zvision/scripting/script_manager.h
+++ b/engines/zvision/scripting/script_manager.h
@@ -113,6 +113,28 @@ struct Location {
 	uint32 offset;
 };
 
+inline bool operator==(const Location& lhs, const Location& rhs) {
+	return (
+		lhs.world == rhs.world &&
+		lhs.room == rhs.room &&
+		lhs.node == rhs.node &&
+		lhs.view == rhs.view
+	);
+}
+
+inline bool operator==(const Location& lhs, const char* rhs) {
+	Common::String lhsStr = Common::String::format("%c%c%c%c", lhs.world, lhs.room, lhs.node, lhs.view);
+	return lhsStr == rhs;
+}
+
+inline bool operator!=(const Location& lhs, const Location& rhs) {
+	return !(lhs == rhs);
+}
+
+inline bool operator!=(const Location& lhs, const char* rhs) {
+	return !(lhs == rhs);
+}
+
 typedef Common::List<Puzzle *> PuzzleList;
 typedef Common::Queue<Puzzle *> PuzzleQueue;
 typedef Common::List<Control *> ControlList;
@@ -248,7 +270,6 @@ public:
 
 	void serialize(Common::WriteStream *stream);
 	void deserialize(Common::SeekableReadStream *stream);
-	void reset();
 
 	Location getCurrentLocation() const;
 	Location getLastLocation();
@@ -274,7 +295,7 @@ private:
 	bool execScope(ScriptScope &scope);
 
 	/** Perform change location */
-	void ChangeLocationReal();
+	void ChangeLocationReal(bool isLoading);
 
 	int8 inventoryGetCount();
 	void inventorySetCount(int8 cnt);
@@ -313,9 +334,10 @@ private:
 	 *
 	 * @param criteria    Pointer to the Criteria object to fill
 	 * @param stream      Scr file stream
+	 * @param key         Puzzle key (for workarounds)
 	 * @return            Whether any criteria were read
 	 */
-	bool parseCriteria(Common::SeekableReadStream &stream, Common::List<Common::List<Puzzle::CriteriaEntry> > &criteriaList) const;
+	bool parseCriteria(Common::SeekableReadStream &stream, Common::List<Common::List<Puzzle::CriteriaEntry> > &criteriaList, uint32 key) const;
 
 	/**
 	 * Parses the stream into a ResultAction objects
diff --git a/engines/zvision/scripting/scripting_effect.h b/engines/zvision/scripting/scripting_effect.h
index 0af1d9c21c..2a2153204f 100644
--- a/engines/zvision/scripting/scripting_effect.h
+++ b/engines/zvision/scripting/scripting_effect.h
@@ -37,7 +37,7 @@ class ZVision;
   * The base class that represents effects created from Actions.
   * This class is virtual.
   *
-  * Detailed Description: 
+  * Detailed Description:
   *     A scene has Controls. By interacting with the controls, the user
   *     causes Actions to execute. Certain Actions create 'effects', for
   *     example, a sound or an animation. This is the base class for
diff --git a/engines/zvision/sound/zork_raw.cpp b/engines/zvision/sound/zork_raw.cpp
index 0ef5de2f55..124235e0e0 100644
--- a/engines/zvision/sound/zork_raw.cpp
+++ b/engines/zvision/sound/zork_raw.cpp
@@ -33,7 +33,6 @@
 
 #include "zvision/sound/zork_raw.h"
 #include "zvision/zvision.h"
-#include "zvision/detection.h"
 
 namespace ZVision {
 
@@ -136,7 +135,8 @@ int RawChunkStream::readBuffer(int16 *buffer, Common::SeekableReadStream *stream
 	return bytesRead;
 }
 
-const SoundParams RawZorkStream::_zNemSoundParamLookupTable[32] = {{'0', 0x1F40, false, false, false},
+const SoundParams RawZorkStream::_zNemSoundParamLookupTable[32] = {
+	{'0', 0x1F40, false, false, false},
 	{'1', 0x1F40, true, false, false},
 	{'2', 0x1F40, false, false, true},
 	{'3', 0x1F40, true, false, true},
@@ -170,7 +170,8 @@ const SoundParams RawZorkStream::_zNemSoundParamLookupTable[32] = {{'0', 0x1F40,
 	{'x', 0xAC44, true, true, true}
 };
 
-const SoundParams RawZorkStream::_zgiSoundParamLookupTable[24] = {{'4', 0x2B11, false, false, false},
+const SoundParams RawZorkStream::_zgiSoundParamLookupTable[24] = {
+	{'4', 0x2B11, false, false, false},
 	{'5', 0x2B11, true, false, false},
 	{'6', 0x2B11, false, false, true},
 	{'7', 0x2B11, true, false, true},
@@ -256,9 +257,9 @@ Audio::RewindableAudioStream *makeRawZorkStream(const Common::String &filePath,
 		actualName.setChar('c', actualName.size() - 1);
 
 		if (!engine->getSearchManager()->openFile(*file, actualName))
-			error("File not found: %s", actualName.c_str());
+			return NULL;
 	} else if (!found && !isRaw) {
-		error("File not found: %s", actualName.c_str());
+		return NULL;
 	}
 
 	// Get the file name
diff --git a/engines/zvision/text/string_manager.h b/engines/zvision/text/string_manager.h
index f4564ee1ec..2c31cf7afe 100644
--- a/engines/zvision/text/string_manager.h
+++ b/engines/zvision/text/string_manager.h
@@ -23,7 +23,6 @@
 #ifndef ZVISION_STRING_MANAGER_H
 #define ZVISION_STRING_MANAGER_H
 
-#include "zvision/detection.h"
 #include "zvision/text/truetype_font.h"
 
 namespace Graphics {
diff --git a/engines/zvision/text/subtitles.cpp b/engines/zvision/text/subtitles.cpp
index acf4c37c2f..ffc9e2b808 100644
--- a/engines/zvision/text/subtitles.cpp
+++ b/engines/zvision/text/subtitles.cpp
@@ -27,7 +27,7 @@
 
 namespace ZVision {
 
-Subtitle::Subtitle(ZVision *engine, const Common::String &subname) :
+Subtitle::Subtitle(ZVision *engine, const Common::String &subname, bool upscaleToHires) :
 	_engine(engine),
 	_areaId(-1),
 	_subId(-1) {
@@ -44,6 +44,8 @@ Subtitle::Subtitle(ZVision *engine, const Common::String &subname) :
 				int32 x1, y1, x2, y2;
 				sscanf(str.c_str(), "%*[^:]:%d %d %d %d", &x1, &y1, &x2, &y2);
 				Common::Rect rct = Common::Rect(x1, y1, x2, y2);
+				if (upscaleToHires)
+					_engine->getRenderManager()->upscaleRect(rct);
 				_areaId = _engine->getRenderManager()->createSubArea(rct);
 			} else if (str.matchString("*TextFile*", true)) {
 				char filename[64];
@@ -67,6 +69,11 @@ Subtitle::Subtitle(ZVision *engine, const Common::String &subname) :
 				int32 sb;
 				if (sscanf(str.c_str(), "%*[^:]:(%d,%d)=%d", &st, &en, &sb) == 3) {
 					if (sb <= (int32)_subs.size()) {
+						if (upscaleToHires) {
+							// Convert from 15FPS (AVI) to 29.97FPS (VOB)
+							st = st * 2997 / 1500;
+							en = en * 2997 / 1500;
+						}
 						_subs[sb].start = st;
 						_subs[sb].stop = en;
 					}
diff --git a/engines/zvision/text/subtitles.h b/engines/zvision/text/subtitles.h
index c3da6583a4..329339be55 100644
--- a/engines/zvision/text/subtitles.h
+++ b/engines/zvision/text/subtitles.h
@@ -31,7 +31,7 @@ class ZVision;
 
 class Subtitle {
 public:
-	Subtitle(ZVision *engine, const Common::String &subname);
+	Subtitle(ZVision *engine, const Common::String &subname, bool upscaleToHires = false);
 	~Subtitle();
 
 	void process(int32 time);
diff --git a/engines/zvision/text/text.cpp b/engines/zvision/text/text.cpp
index a5ed044424..868ee4f1ae 100644
--- a/engines/zvision/text/text.cpp
+++ b/engines/zvision/text/text.cpp
@@ -38,7 +38,7 @@
 
 namespace ZVision {
 
-cTxtStyle::cTxtStyle() {
+TextStyleState::TextStyleState() {
 	_fontname = "Arial";
 	_blue = 255;
 	_green = 255;
@@ -49,7 +49,7 @@ cTxtStyle::cTxtStyle() {
 	_escapement = 0;
 #endif
 	_italic = false;
-	_justify = TXT_JUSTIFY_LEFT;
+	_justification = TEXT_JUSTIFY_LEFT;
 	_size = 12;
 #if 0
 	_skipcolor = false;
@@ -60,10 +60,10 @@ cTxtStyle::cTxtStyle() {
 	_sharp = false;
 }
 
-txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
-	Common::String buf = Common::String(strin.c_str(), ln);
+TextChange TextStyleState::parseStyle(const Common::String &str, int16 len) {
+	Common::String buf = Common::String(str.c_str(), len);
 
-	int8 retval = TXT_RET_NOTHING;
+	uint retval = TEXT_CHANGE_NONE;
 
 	Common::StringTokenizer tokenizer(buf, " ");
 	Common::String token;
@@ -89,7 +89,7 @@ txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
 				if (!tokenizer.empty())
 					_fontname = token;
 			}
-			retval |= TXT_RET_FNTCHG;
+			retval |= TEXT_CHANGE_FONT_TYPE;
 
 		} else if (token.matchString("blue", true)) {
 			if (!tokenizer.empty()) {
@@ -97,7 +97,7 @@ txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
 				int32 tmp = atoi(token.c_str());
 				if (_blue != tmp) {
 					_blue = tmp;
-					retval |= TXT_RET_FNTSTL;
+					retval |= TEXT_CHANGE_FONT_STYLE;
 				}
 			}
 		} else if (token.matchString("red", true)) {
@@ -106,7 +106,7 @@ txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
 				int32 tmp = atoi(token.c_str());
 				if (_red != tmp) {
 					_red = tmp;
-					retval |= TXT_RET_FNTSTL;
+					retval |= TEXT_CHANGE_FONT_STYLE;
 				}
 			}
 		} else if (token.matchString("green", true)) {
@@ -115,7 +115,7 @@ txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
 				int32 tmp = atoi(token.c_str());
 				if (_green != tmp) {
 					_green = tmp;
-					retval |= TXT_RET_FNTSTL;
+					retval |= TEXT_CHANGE_FONT_STYLE;
 				}
 			}
 		} else if (token.matchString("newline", true)) {
@@ -125,14 +125,14 @@ txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
 
 			_newline++;
 #endif
-			retval |= TXT_RET_NEWLN;
+			retval |= TEXT_CHANGE_NEWLINE;
 		} else if (token.matchString("point", true)) {
 			if (!tokenizer.empty()) {
 				token = tokenizer.nextToken();
 				int32 tmp = atoi(token.c_str());
 				if (_size != tmp) {
 					_size = tmp;
-					retval |= TXT_RET_FNTCHG;
+					retval |= TEXT_CHANGE_FONT_TYPE;
 				}
 			}
 		} else if (token.matchString("escapement", true)) {
@@ -149,12 +149,12 @@ txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
 				if (token.matchString("on", true)) {
 					if (_italic != true) {
 						_italic = true;
-						retval |= TXT_RET_FNTSTL;
+						retval |= TEXT_CHANGE_FONT_STYLE;
 					}
 				} else if (token.matchString("off", true)) {
 					if (_italic != false) {
 						_italic = false;
-						retval |= TXT_RET_FNTSTL;
+						retval |= TEXT_CHANGE_FONT_STYLE;
 					}
 				}
 			}
@@ -164,12 +164,12 @@ txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
 				if (token.matchString("on", true)) {
 					if (_underline != true) {
 						_underline = true;
-						retval |= TXT_RET_FNTSTL;
+						retval |= TEXT_CHANGE_FONT_STYLE;
 					}
 				} else if (token.matchString("off", true)) {
 					if (_underline != false) {
 						_underline = false;
-						retval |= TXT_RET_FNTSTL;
+						retval |= TEXT_CHANGE_FONT_STYLE;
 					}
 				}
 			}
@@ -179,12 +179,12 @@ txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
 				if (token.matchString("on", true)) {
 					if (_strikeout != true) {
 						_strikeout = true;
-						retval |= TXT_RET_FNTSTL;
+						retval |= TEXT_CHANGE_FONT_STYLE;
 					}
 				} else if (token.matchString("off", true)) {
 					if (_strikeout != false) {
 						_strikeout = false;
-						retval |= TXT_RET_FNTSTL;
+						retval |= TEXT_CHANGE_FONT_STYLE;
 					}
 				}
 			}
@@ -194,12 +194,12 @@ txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
 				if (token.matchString("on", true)) {
 					if (_bold != true) {
 						_bold = true;
-						retval |= TXT_RET_FNTSTL;
+						retval |= TEXT_CHANGE_FONT_STYLE;
 					}
 				} else if (token.matchString("off", true)) {
 					if (_bold != false) {
 						_bold = false;
-						retval |= TXT_RET_FNTSTL;
+						retval |= TEXT_CHANGE_FONT_STYLE;
 					}
 				}
 			}
@@ -220,24 +220,24 @@ txtReturn cTxtStyle::parseStyle(const Common::String &strin, int16 ln) {
 			if (!tokenizer.empty()) {
 				token = tokenizer.nextToken();
 				_statebox = atoi(token.c_str());
-				retval |= TXT_RET_HASSTBOX;
+				retval |= TEXT_CHANGE_HAS_STATE_BOX;
 			}
 		} else if (token.matchString("justify", true)) {
 			if (!tokenizer.empty()) {
 				token = tokenizer.nextToken();
 				if (token.matchString("center", true))
-					_justify = TXT_JUSTIFY_CENTER;
+					_justification = TEXT_JUSTIFY_CENTER;
 				else if (token.matchString("left", true))
-					_justify = TXT_JUSTIFY_LEFT;
+					_justification = TEXT_JUSTIFY_LEFT;
 				else if (token.matchString("right", true))
-					_justify = TXT_JUSTIFY_RIGHT;
+					_justification = TEXT_JUSTIFY_RIGHT;
 			}
 		}
 	}
-	return (txtReturn)retval;
+	return (TextChange)retval;
 }
 
-void cTxtStyle::readAllStyle(const Common::String &txt) {
+void TextStyleState::readAllStyles(const Common::String &txt) {
 	int16 startTextPosition = -1;
 	int16 endTextPosition = -1;
 
@@ -246,252 +246,273 @@ void cTxtStyle::readAllStyle(const Common::String &txt) {
 			startTextPosition = i;
 		else if (txt[i] == '>') {
 			endTextPosition = i;
-			if (startTextPosition != -1)
-				if ((endTextPosition - startTextPosition - 1) > 0)
+			if (startTextPosition != -1) {
+				if ((endTextPosition - startTextPosition - 1) > 0) {
 					parseStyle(Common::String(txt.c_str() + startTextPosition + 1), endTextPosition - startTextPosition - 1);
+				}
+			}
 		}
 
 	}
 }
 
-void cTxtStyle::setFontStyle(StyledTTFont &font) {
+void TextStyleState::updateFontWithTextState(StyledTTFont &font) {
 	uint tempStyle = 0;
 
-	if (_bold)
-		tempStyle |= StyledTTFont::STTF_BOLD;
-
-	if (_italic)
-		tempStyle |= StyledTTFont::STTF_ITALIC;
-
-	if (_underline)
-		tempStyle |= StyledTTFont::STTF_UNDERLINE;
-
-	if (_strikeout)
-		tempStyle |= StyledTTFont::STTF_STRIKEOUT;
-
-	if (_sharp)
-		tempStyle |= StyledTTFont::STTF_SHARP;
+	if (_bold) {
+		tempStyle |= StyledTTFont::TTF_STYLE_BOLD;
+	}
+	if (_italic) {
+		tempStyle |= StyledTTFont::TTF_STYLE_ITALIC;
+	}
+	if (_underline) {
+		tempStyle |= StyledTTFont::TTF_STYLE_UNDERLINE;
+	}
+	if (_strikeout) {
+		tempStyle |= StyledTTFont::TTF_STYLE_STRIKETHROUGH;
+	}
+	if (_sharp) {
+		tempStyle |= StyledTTFont::TTF_STYLE_SHARP;
+	}
 
-	font.setStyle(tempStyle);
+	font.loadFont(_fontname, _size, tempStyle);
 }
 
-void cTxtStyle::setFont(StyledTTFont &font) {
-	uint tempStyle = 0;
-
-	if (_bold)
-		tempStyle |= StyledTTFont::STTF_BOLD;
+void TextRenderer::drawTextWithJustification(const Common::String &text, StyledTTFont &font, uint32 color, Graphics::Surface &dest, int lineY, TextJustification justify) {
+	if (justify == TEXT_JUSTIFY_LEFT)
+		font.drawString(&dest, text, 0, lineY, dest.w, color, Graphics::kTextAlignLeft);
+	else if (justify == TEXT_JUSTIFY_CENTER)
+		font.drawString(&dest, text, 0, lineY, dest.w, color, Graphics::kTextAlignCenter);
+	else if (justify == TEXT_JUSTIFY_RIGHT)
+		font.drawString(&dest, text, 0, lineY, dest.w, color, Graphics::kTextAlignRight);
+}
 
-	if (_italic)
-		tempStyle |= StyledTTFont::STTF_ITALIC;
+int32 TextRenderer::drawText(const Common::String &text, TextStyleState &state, Graphics::Surface &dest) {
+	StyledTTFont font(_engine);
+	state.updateFontWithTextState(font);
 
-	if (_underline)
-		tempStyle |= StyledTTFont::STTF_UNDERLINE;
+	uint32 color = _engine->_resourcePixelFormat.RGBToColor(state._red, state._green, state._blue);
+	drawTextWithJustification(text, font, color, dest, 0, state._justification);
 
-	if (_strikeout)
-		tempStyle |= StyledTTFont::STTF_STRIKEOUT;
+	return font.getStringWidth(text);
+}
 
-	if (_sharp)
-		tempStyle |= StyledTTFont::STTF_SHARP;
+struct TextSurface {
+	TextSurface(Graphics::Surface *surface, Common::Point surfaceOffset, uint lineNumber)
+		: _surface(surface),
+		  _surfaceOffset(surfaceOffset),
+		  _lineNumber(lineNumber) {
+	}
 
-	font.loadFont(_fontname, _size, tempStyle);
-}
+	Graphics::Surface *_surface;
+	Common::Point _surfaceOffset;
+	uint _lineNumber;
+};
 
-Graphics::Surface *TextRenderer::render(StyledTTFont &fnt, const Common::String &txt, cTxtStyle &style) {
-	style.setFontStyle(fnt);
-	uint32 clr = _engine->_resourcePixelFormat.RGBToColor(style._red, style._green, style._blue);
-	return fnt.renderSolidText(txt, clr);
-}
+void TextRenderer::drawTextWithWordWrapping(const Common::String &text, Graphics::Surface &dest) {
+	Common::Array<TextSurface> textSurfaces;
+	Common::Array<uint> lineWidths;
+	Common::Array<TextJustification> lineJustifications;
 
-void TextRenderer::drawTxtWithJustify(const Common::String &txt, StyledTTFont &fnt, uint32 color, Graphics::Surface &dst, int lineY, txtJustify justify) {
-	if (justify == TXT_JUSTIFY_LEFT)
-		fnt.drawString(&dst, txt, 0, lineY, dst.w, color, Graphics::kTextAlignLeft);
-	else if (justify == TXT_JUSTIFY_CENTER)
-		fnt.drawString(&dst, txt, 0, lineY, dst.w, color, Graphics::kTextAlignCenter);
-	else if (justify == TXT_JUSTIFY_RIGHT)
-		fnt.drawString(&dst, txt, 0, lineY, dst.w, color, Graphics::kTextAlignRight);
-}
+	// Create the initial text state
+	TextStyleState currentState;
 
-int32 TextRenderer::drawTxt(const Common::String &txt, cTxtStyle &fontStyle, Graphics::Surface &dst) {
+	// Create an empty font and bind it to the state
 	StyledTTFont font(_engine);
-	fontStyle.setFont(font);
+	currentState.updateFontWithTextState(font);
 
-	dst.fillRect(Common::Rect(dst.w, dst.h), 0);
+	Common::String currentSentence; // Not a true 'grammatical' sentence. Rather, it's just a collection of words
+	Common::String currentWord;
+	int sentenceWidth = 0;
+	int wordWidth = 0;
+	int lineWidth = 0;
+	int lineHeight = font.getFontHeight();
 
-	uint32 clr = _engine->_resourcePixelFormat.RGBToColor(fontStyle._red, fontStyle._green, fontStyle._blue);
+	uint currentLineNumber = 0u;
 
-	int16 w;
+	uint numSpaces = 0u;
+	int spaceWidth = 0;
 
-	w = font.getStringWidth(txt);
+	// The pixel offset to the currentSentence
+	Common::Point sentencePixelOffset;
 
-	drawTxtWithJustify(txt, font, clr, dst, 0, fontStyle._justify);
+	uint i = 0u;
+	uint stringlen = text.size();
 
-	return w;
-}
+	while (i < stringlen) {
+		if (text[i] == '<') {
+			// Flush the currentWord to the currentSentence			
+			currentSentence += currentWord;
+			sentenceWidth += wordWidth;
+
+			// Reset the word variables
+			currentWord.clear();
+			wordWidth = 0;
+			
+			// Parse the style tag
+			uint startTextPosition = i;
+			while (i < stringlen && text[i] != '>') {
+				++i;
+			}
+			uint endTextPosition = i;
 
-void TextRenderer::drawTxtInOneLine(const Common::String &text, Graphics::Surface &dst) {
-	const int16 TXT_CFG_TEXTURES_LINES = 256; // For now I don't want remake it
-	const int TXT_CFG_TEXTURES_PER_LINE = 6;
-	cTxtStyle style, style2;
-	int16 startTextPosition = -1;
-	int16 endTextPosition = -1;
-	int16 i = 0;
-	int16 dx = 0, dy = 0;
-	int16 textPixelWidth;
-	int16 textPosition = 0;
-	Common::String buf;
-	Common::String buf2;
-
-	Graphics::Surface *TxtSurfaces[TXT_CFG_TEXTURES_LINES][TXT_CFG_TEXTURES_PER_LINE];
-	int16 currentline = 0, currentlineitm = 0;
-
-	int TxtJustify[TXT_CFG_TEXTURES_LINES];
-	int TxtPoint[TXT_CFG_TEXTURES_LINES];
-
-	for (int16 k = 0; k < TXT_CFG_TEXTURES_LINES; k++) {
-		TxtPoint[k] = 0;
-		for (int j = 0; j < TXT_CFG_TEXTURES_PER_LINE; j++)
-			TxtSurfaces[k][j] = NULL;
-	}
+			uint32 textColor = currentState.getTextColor(_engine);
 
-	int16 stringlen = text.size();
+			uint stateChanges = 0u;
+			if ((endTextPosition - startTextPosition - 1) > 0) {
+				stateChanges = currentState.parseStyle(Common::String(text.c_str() + startTextPosition + 1), endTextPosition - startTextPosition - 1);
+			}
 
-	StyledTTFont font(_engine);
+			if (stateChanges & (TEXT_CHANGE_FONT_TYPE | TEXT_CHANGE_FONT_STYLE)) {
+				// Use the last state to render out the current sentence
+				// Styles apply to the text 'after' them
+				if (!currentSentence.empty()) {
+					textSurfaces.push_back(TextSurface(font.renderSolidText(currentSentence, textColor), sentencePixelOffset, currentLineNumber));
 
-	style.setFont(font);
+					lineWidth += sentenceWidth;
+					sentencePixelOffset.x += sentenceWidth;
 
-	int16 prevbufspace = 0, prevtxtspace = 0;
+					// Reset the sentence variables
+					currentSentence.clear();
+					sentenceWidth = 0;
+				}
 
-	while (i < stringlen) {
-		TxtJustify[currentline] = style._justify;
-		if (text[i] == '<') {
-			int16 ret = 0;
+				// Update the current state with the style information
+				currentState.updateFontWithTextState(font);
 
-			startTextPosition = i;
-			while (i < stringlen && text[i] != '>')
-				i++;
-			endTextPosition = i;
-			if (startTextPosition != -1)
-				if ((endTextPosition - startTextPosition - 1) > 0) {
-					style2 = style;
-					ret = style.parseStyle(Common::String(text.c_str() + startTextPosition + 1), endTextPosition - startTextPosition - 1);
+				lineHeight = MAX(lineHeight, font.getFontHeight());
+				spaceWidth = font.getCharWidth(' ');
+			}
+			if (stateChanges & TEXT_CHANGE_NEWLINE) {
+				// If the current sentence has content, render it out
+				if (!currentSentence.empty()) {
+					textSurfaces.push_back(TextSurface(font.renderSolidText(currentSentence, textColor), sentencePixelOffset, currentLineNumber));
 				}
+				
+				// Set line width
+				lineWidths.push_back(lineWidth + sentenceWidth - (numSpaces * spaceWidth));
+
+				currentSentence.clear();
+				sentenceWidth = 0;
+				
+				// Update the offsets
+				sentencePixelOffset.x = 0u;
+				sentencePixelOffset.y += lineHeight;
+
+				// Reset the line variables
+				lineHeight = font.getFontHeight();
+				lineWidth = 0;
+				++currentLineNumber;
+				lineJustifications.push_back(currentState._justification);
+			}
+			if (stateChanges & TEXT_CHANGE_HAS_STATE_BOX) {
+				Common::String temp = Common::String::format("%d", _engine->getScriptManager()->getStateValue(currentState._statebox));
+				wordWidth += font.getStringWidth(temp);
 
-			if (ret & (TXT_RET_FNTCHG | TXT_RET_FNTSTL | TXT_RET_NEWLN)) {
-				if (buf.size() > 0) {
-					textPixelWidth = font.getStringWidth(buf);
-
-					TxtSurfaces[currentline][currentlineitm] = render(font, buf, style2);
-					TxtPoint[currentline] = MAX(font.getFontHeight(), TxtPoint[currentline]);
+				// If the word causes the line to overflow, render the sentence and start a new line
+				if (lineWidth + sentenceWidth + wordWidth > dest.w) {
+					textSurfaces.push_back(TextSurface(font.renderSolidText(currentSentence, textColor), sentencePixelOffset, currentLineNumber));
 
-					currentlineitm++;
+					// Set line width
+					lineWidths.push_back(lineWidth + sentenceWidth - (numSpaces * spaceWidth));
 
-					buf.clear();
-					prevbufspace = 0;
-					textPosition = 0;
-					dx += textPixelWidth;
+					currentSentence.clear();
+					sentenceWidth = 0;
 
-				}
-				if (ret & TXT_RET_FNTCHG) {
-					style.setFont(font);
-				}
-				if (ret & TXT_RET_FNTSTL)
-					style.setFontStyle(font);
+					// Update the offsets
+					sentencePixelOffset.x = 0u;
+					sentencePixelOffset.y += lineHeight;
 
-				if (ret & TXT_RET_NEWLN) {
-					currentline++;
-					currentlineitm = 0;
-					dx = 0;
+					// Reset the line variables
+					lineHeight = font.getFontHeight();
+					lineWidth = 0;
+					++currentLineNumber;
+					lineJustifications.push_back(currentState._justification);
 				}
 			}
-
-			if (ret & TXT_RET_HASSTBOX) {
-				Common::String buf3;
-				buf3 = Common::String::format("%d", _engine->getScriptManager()->getStateValue(style._statebox));
-				buf += buf3;
-				textPosition += buf3.size();
-			}
-
 		} else {
-
-			buf += text[i];
-			textPosition++;
+			currentWord += text[i];
+			wordWidth += font.getCharWidth(text[i]);
 
 			if (text[i] == ' ') {
-				prevbufspace = textPosition - 1;
-				prevtxtspace = i;
-			}
+				// When we hit the first space, flush the current word to the sentence
+				if (!currentWord.empty()) {
+					currentSentence += currentWord;
+					sentenceWidth += wordWidth;
 
-			if (font.isLoaded()) {
-				textPixelWidth = font.getStringWidth(buf);
-				if (textPixelWidth + dx > dst.w) {
-					if (prevbufspace == 0) {
-						prevtxtspace = i;
-						prevbufspace = textPosition - 1;
-					}
-					buf2 = Common::String(buf.c_str(), prevbufspace + 1);
+					currentWord.clear();
+					wordWidth = 0;
+				}
 
-					if (buf2.size() > 0) {
-						TxtSurfaces[currentline][currentlineitm] = render(font, buf2, style);
-						TxtPoint[currentline] = MAX(font.getFontHeight(), TxtPoint[currentline]);
+				// We track the number of spaces so we can disregard their width in lineWidth calculations
+				++numSpaces;
+			} else {			
+				// If the word causes the line to overflow, render the sentence and start a new line
+				if (lineWidth + sentenceWidth + wordWidth > dest.w) {
+					// Only render out content
+					if (!currentSentence.empty()) {
+						textSurfaces.push_back(TextSurface(font.renderSolidText(currentSentence, currentState.getTextColor(_engine)), sentencePixelOffset, currentLineNumber));
 					}
 
-					buf.clear();
-					i = prevtxtspace;
-					prevbufspace = 0;
-					textPosition = 0;
-					currentline++;
-					currentlineitm = 0;
-					dx = 0;
+					// Set line width
+					lineWidths.push_back(lineWidth + sentenceWidth - (numSpaces * spaceWidth));
+
+					currentSentence.clear();
+					sentenceWidth = 0;
+
+					// Update the offsets
+					sentencePixelOffset.x = 0u;
+					sentencePixelOffset.y += lineHeight;
+
+					// Reset the line variables
+					lineHeight = font.getFontHeight();
+					lineWidth = 0;
+					++currentLineNumber;
+					lineJustifications.push_back(currentState._justification);
 				}
+
+				numSpaces = 0u;
 			}
 		}
+
 		i++;
 	}
 
-	if (buf.size() > 0) {
-		TxtSurfaces[currentline][currentlineitm] = render(font, buf, style);
-		TxtPoint[currentline] = MAX(font.getFontHeight(), TxtPoint[currentline]);
+	// Render out any remaining words/sentences
+	if (!currentWord.empty() || !currentSentence.empty()) {
+		currentSentence += currentWord;
+		sentenceWidth += wordWidth;
+		
+		textSurfaces.push_back(TextSurface(font.renderSolidText(currentSentence, currentState.getTextColor(_engine)), sentencePixelOffset, currentLineNumber));
 	}
 
-	dy = 0;
-	for (i = 0; i <= currentline; i++) {
-		int16 j = 0;
-		int16 width = 0;
-		while (TxtSurfaces[i][j] != NULL) {
-			width += TxtSurfaces[i][j]->w;
-			j++;
-		}
-		dx = 0;
-		Common::Rect empty;
-		for (int32 jj = 0; jj < j; jj++) {
-			if (TxtJustify[i] == TXT_JUSTIFY_LEFT)
-				_engine->getRenderManager()->blitSurfaceToSurface(*TxtSurfaces[i][jj], empty, dst, dx, dy + TxtPoint[i] - TxtSurfaces[i][jj]->h, 0);
+	lineWidths.push_back(lineWidth + sentenceWidth);
+	lineJustifications.push_back(currentState._justification);
 
-			else if (TxtJustify[i] == TXT_JUSTIFY_CENTER)
-				_engine->getRenderManager()->blitSurfaceToSurface(*TxtSurfaces[i][jj], empty, dst, ((dst.w - width) / 2) + dx,  dy + TxtPoint[i] - TxtSurfaces[i][jj]->h, 0);
-
-			else if (TxtJustify[i] == TXT_JUSTIFY_RIGHT)
-				_engine->getRenderManager()->blitSurfaceToSurface(*TxtSurfaces[i][jj], empty, dst, dst.w - width + dx, dy + TxtPoint[i] - TxtSurfaces[i][jj]->h, 0);
+	for (Common::Array<TextSurface>::iterator iter = textSurfaces.begin(); iter != textSurfaces.end(); ++iter) {
+		Common::Rect empty;
 
-			dx += TxtSurfaces[i][jj]->w;
+		if (lineJustifications[iter->_lineNumber] == TEXT_JUSTIFY_LEFT) {
+			_engine->getRenderManager()->blitSurfaceToSurface(*iter->_surface, empty, dest, iter->_surfaceOffset.x, iter->_surfaceOffset.y, 0);
+		} else if (lineJustifications[iter->_lineNumber] == TEXT_JUSTIFY_CENTER) {
+			_engine->getRenderManager()->blitSurfaceToSurface(*iter->_surface, empty, dest, ((dest.w - lineWidths[iter->_lineNumber]) / 2) + iter->_surfaceOffset.x, iter->_surfaceOffset.y, 0);
+		} else if (lineJustifications[iter->_lineNumber] == TEXT_JUSTIFY_RIGHT) {
+			_engine->getRenderManager()->blitSurfaceToSurface(*iter->_surface, empty, dest, dest.w - lineWidths[iter->_lineNumber]  + iter->_surfaceOffset.x, iter->_surfaceOffset.y, 0);
 		}
 
-		dy += TxtPoint[i];
+		// Release memory
+		iter->_surface->free();
+		delete iter->_surface;
 	}
-
-	for (i = 0; i < TXT_CFG_TEXTURES_LINES; i++)
-		for (int32 j = 0; j < TXT_CFG_TEXTURES_PER_LINE; j++)
-			if (TxtSurfaces[i][j] != NULL) {
-				TxtSurfaces[i][j]->free();
-				delete TxtSurfaces[i][j];
-			}
 }
 
 Common::String readWideLine(Common::SeekableReadStream &stream) {
 	Common::String asciiString;
 
-	while (!stream.eos()) {
+	while (true) {
 		uint32 value = stream.readUint16LE();
+		if (stream.eos())
+			break;
 		// Check for CRLF
 		if (value == 0x0A0D) {
 			// Read in the extra NULL char
diff --git a/engines/zvision/text/text.h b/engines/zvision/text/text.h
index c942b8141a..5dd872a440 100644
--- a/engines/zvision/text/text.h
+++ b/engines/zvision/text/text.h
@@ -24,7 +24,6 @@
 #ifndef ZVISION_TEXT_H
 #define ZVISION_TEXT_H
 
-#include "zvision/detection.h"
 #include "zvision/text/truetype_font.h"
 #include "zvision/zvision.h"
 
@@ -32,59 +31,53 @@ namespace ZVision {
 
 class ZVision;
 
-enum txtJustify {
-	TXT_JUSTIFY_CENTER = 0,
-	TXT_JUSTIFY_LEFT = 1,
-	TXT_JUSTIFY_RIGHT = 2
+enum TextJustification {
+	TEXT_JUSTIFY_CENTER = 0,
+	TEXT_JUSTIFY_LEFT = 1,
+	TEXT_JUSTIFY_RIGHT = 2
 };
 
-enum txtReturn {
-	TXT_RET_NOTHING = 0x0,
-	TXT_RET_FNTCHG = 0x1,
-	TXT_RET_FNTSTL = 0x2,
-	TXT_RET_NEWLN = 0x4,
-	TXT_RET_HASSTBOX = 0x8
+enum TextChange {
+	TEXT_CHANGE_NONE = 0x0,
+	TEXT_CHANGE_FONT_TYPE = 0x1,
+	TEXT_CHANGE_FONT_STYLE = 0x2,
+	TEXT_CHANGE_NEWLINE = 0x4,
+	TEXT_CHANGE_HAS_STATE_BOX = 0x8
 };
 
-class cTxtStyle {
+class TextStyleState {
 public:
-	cTxtStyle();
-	txtReturn parseStyle(const Common::String &strin, int16 len);
-	void readAllStyle(const Common::String &txt);
-	void setFontStyle(StyledTTFont &font);
-	void setFont(StyledTTFont &font);
+	TextStyleState();
+	TextChange parseStyle(const Common::String &str, int16 len);
+	void readAllStyles(const Common::String &txt);
+	void updateFontWithTextState(StyledTTFont &font);
+
+	uint32 getTextColor(ZVision *engine) {
+		return engine->_resourcePixelFormat.RGBToColor(_red, _green, _blue);
+	}
 
 public:
 	Common::String _fontname;
-	txtJustify _justify;  // 0 - center, 1-left, 2-right
+	TextJustification _justification;
 	int16 _size;
 	uint8 _red;     // 0-255
 	uint8 _green;   // 0-255
 	uint8 _blue;    // 0-255
-#if  0
-	int8 _newline;
-	int8 _escapement;
-#endif
 	bool _italic;
 	bool _bold;
 	bool _underline;
 	bool _strikeout;
-#if 0
-	bool _skipcolor;
-#endif
 	int32 _statebox;
 	bool _sharp;
-	// char image ??
 };
 
 class TextRenderer {
 public:
 	TextRenderer(ZVision *engine): _engine(engine) {};
 
-	void drawTxtWithJustify(const Common::String &txt, StyledTTFont &fnt, uint32 color, Graphics::Surface &dst, int lineY, txtJustify justify);
-	int32 drawTxt(const Common::String &txt, cTxtStyle &fontStyle, Graphics::Surface &dst);
-	Graphics::Surface *render(StyledTTFont &fnt, const Common::String &txt, cTxtStyle &style);
-	void drawTxtInOneLine(const Common::String &txt, Graphics::Surface &dst);
+	void drawTextWithJustification(const Common::String &text, StyledTTFont &font, uint32 color, Graphics::Surface &dest, int lineY, TextJustification jusification);
+	int32 drawText(const Common::String &text, TextStyleState &state, Graphics::Surface &dest);
+	void drawTextWithWordWrapping(const Common::String &text, Graphics::Surface &dest);
 
 private:
 	ZVision *_engine;
diff --git a/engines/zvision/text/truetype_font.cpp b/engines/zvision/text/truetype_font.cpp
index 622a02a6a8..acb053ea8d 100644
--- a/engines/zvision/text/truetype_font.cpp
+++ b/engines/zvision/text/truetype_font.cpp
@@ -26,6 +26,7 @@
 #include "common/file.h"
 #include "common/system.h"
 #include "common/unzip.h"
+#include "common/ustr.h"
 #include "graphics/font.h"
 #include "graphics/fonts/ttf.h"
 #include "graphics/surface.h"
@@ -36,65 +37,73 @@
 
 namespace ZVision {
 
+const FontStyle systemFonts[] = {
+	{ "*times new roman*",	  "times",   "FreeSerif", "Italic", "LiberationSerif"  },
+	{ "*times*",		  "times",   "FreeSerif", "Italic", "LiberationSerif"  },
+	{ "*century schoolbook*", "censcbk", "FreeSerif", "Italic", "LiberationSerif"  },
+	{ "*garamond*", 	  "gara",    "FreeSerif", "Italic", "LiberationSerif"  },
+	{ "*courier new*",	  "cour",    "FreeMono",  "Oblique", "LiberationMono" },
+	{ "*courier*",		  "cour",    "FreeMono",  "Oblique", "LiberationMono" },
+	{ "*ZorkDeath*",	  "cour",    "FreeMono",  "Oblique", "LiberationMono" },
+	{ "*arial*",		  "arial",   "FreeSans",  "Oblique", "LiberationSans" },
+	{ "*ZorkNormal*",	  "arial",   "FreeSans",  "Oblique", "LiberationSans" }
+};
+
+const FontStyle getSystemFont(int fontIndex) {
+	return systemFonts[fontIndex];
+}
+
 StyledTTFont::StyledTTFont(ZVision *engine) {
 	_engine = engine;
 	_style = 0;
-	_font = NULL;
+	_font = nullptr;
 	_lineHeight = 0;
 }
 
 StyledTTFont::~StyledTTFont() {
-	if (_font)
-		delete _font;
+	delete _font;
 }
 
 bool StyledTTFont::loadFont(const Common::String &fontName, int32 point, uint style) {
-	_style = style;
-	return loadFont(fontName, point);
-}
+	// Don't re-load the font if we've already loaded it
+	// We have to check for empty so we can default to Arial 
+	if (!fontName.empty() && _fontName.equalsIgnoreCase(fontName) && _lineHeight == point && _style == style) {
+		return true;
+	}
 
-bool StyledTTFont::loadFont(const Common::String &fontName, int32 point) {
-	struct FontStyle {
-		const char *zorkFont;
-		const char *fontBase;
-		const char *freeFontBase;
-		const char *freeFontItalicName;
-	};
-
-	const FontStyle systemFonts[] = {
-		{ "*times new roman*",	  "times",   "FreeSerif", "Italic"  },
-		{ "*times*",		  "times",   "FreeSerif", "Italic"  },
-		{ "*century schoolbook*", "censcbk", "FreeSerif", "Italic"  },
-		{ "*garamond*", 	  "gara",    "FreeSerif", "Italic"  },
-		{ "*courier new*",	  "cour",    "FreeMono",  "Oblique" },
-		{ "*courier*",		  "cour",    "FreeMono",  "Oblique" },
-		{ "*ZorkDeath*",	  "cour",    "FreeMono",  "Oblique" },
-		{ "*arial*",		  "arial",   "FreeSans",  "Oblique" },
-		{ "*ZorkNormal*",	  "arial",   "FreeSans",  "Oblique" },
-	};
+	_style = style;
 
 	Common::String newFontName;
 	Common::String freeFontName;
+	Common::String liberationFontName;
 
-	for (int i = 0; i < ARRAYSIZE(systemFonts); i++) {
-		if (fontName.matchString(systemFonts[i].zorkFont, true)) {
-			newFontName = systemFonts[i].fontBase;
-			freeFontName = systemFonts[i].freeFontBase;
+	for (int i = 0; i < FONT_COUNT; i++) {
+		FontStyle curFont = getSystemFont(i);
+		if (fontName.matchString(curFont.zorkFont, true)) {
+			newFontName = curFont.fontBase;
+			freeFontName = curFont.freeFontBase;
+			liberationFontName = curFont.liberationFontBase;
 
-			if ((_style & STTF_BOLD) && (_style & STTF_ITALIC)) {
+			if ((_style & TTF_STYLE_BOLD) && (_style & TTF_STYLE_ITALIC)) {
 				newFontName += "bi";
 				freeFontName += "Bold";
-				freeFontName += systemFonts[i].freeFontItalicName;
-			} else if (_style & STTF_BOLD) {
+				freeFontName += curFont.freeFontItalicName;
+				liberationFontName += "-BoldItalic";
+			} else if (_style & TTF_STYLE_BOLD) {
 				newFontName += "bd";
 				freeFontName += "Bold";
-			} else if (_style & STTF_ITALIC) {
+				liberationFontName += "-Bold";
+			} else if (_style & TTF_STYLE_ITALIC) {
 				newFontName += "i";
-				freeFontName += systemFonts[i].freeFontItalicName;
+				freeFontName += curFont.freeFontItalicName;
+				liberationFontName += "-Italic";
+			} else {
+				liberationFontName += "-Regular";
 			}
 
 			newFontName += ".ttf";
 			freeFontName += ".ttf";
+			liberationFontName += ".ttf";
 			break;
 		}
 	}
@@ -103,72 +112,99 @@ bool StyledTTFont::loadFont(const Common::String &fontName, int32 point) {
 		debug("Could not identify font: %s. Reverting to Arial", fontName.c_str());
 		newFontName = "arial.ttf";
 		freeFontName = "FreeSans.ttf";
+		liberationFontName = "LiberationSans-Regular.ttf";
 	}
 
-	bool sharp = (_style & STTF_SHARP) == STTF_SHARP;
+	bool sharp = (_style & TTF_STYLE_SHARP) == TTF_STYLE_SHARP;
 
 	Common::File file;
-	if (!file.open(newFontName) && !file.open(freeFontName) && !_engine->getSearchManager()->openFile(file, newFontName) && !_engine->getSearchManager()->openFile(file, freeFontName))
-		error("Unable to open font file %s (free alternative: %s)", newFontName.c_str(), freeFontName.c_str());
-
-	Graphics::Font *_newFont = Graphics::loadTTFFont(file, point, 60, (sharp ? Graphics::kTTFRenderModeMonochrome : Graphics::kTTFRenderModeNormal)); // 66 dpi for 640 x 480 on 14" display
-	if (_newFont) {
-		if (!_font)
-			delete _font;
-		_font = _newFont;
+	if (!file.open(newFontName) && !_engine->getSearchManager()->openFile(file, newFontName) &&
+		!file.open(liberationFontName) && !_engine->getSearchManager()->openFile(file, liberationFontName) &&
+		!file.open(freeFontName) && !_engine->getSearchManager()->openFile(file, freeFontName))
+		error("Unable to open font file %s (Liberation Font alternative: %s, FreeFont alternative: %s)", newFontName.c_str(), liberationFontName.c_str(), freeFontName.c_str());
+
+	Graphics::Font *newFont = Graphics::loadTTFFont(file, point, 60, (sharp ? Graphics::kTTFRenderModeMonochrome : Graphics::kTTFRenderModeNormal)); // 66 dpi for 640 x 480 on 14" display
+	if (newFont == nullptr) {
+		return false;
 	}
 
-	_fntName = fontName;
-	_lineHeight = point;
+	delete _font;
+	_font = newFont;
 
-	if (_font)
-		return true;
-	return false;
-}
+	_fontName = fontName;
+	_lineHeight = point;
 
-void StyledTTFont::setStyle(uint newStyle) {
-	if ((_style & (STTF_BOLD | STTF_ITALIC | STTF_SHARP)) != (newStyle & (STTF_BOLD | STTF_ITALIC | STTF_SHARP))) {
-		_style = newStyle;
-		loadFont(_fntName, _lineHeight);
-	} else {
-		_style = newStyle;
-	}
+	return true;
 }
 
 int StyledTTFont::getFontHeight() {
 	if (_font)
 		return _font->getFontHeight();
+
 	return 0;
 }
 
 int StyledTTFont::getMaxCharWidth() {
 	if (_font)
 		return _font->getMaxCharWidth();
+
 	return 0;
 }
 
 int StyledTTFont::getCharWidth(byte chr) {
 	if (_font)
 		return _font->getCharWidth(chr);
+
 	return 0;
 }
 
 int StyledTTFont::getKerningOffset(byte left, byte right) {
 	if (_font)
 		return _font->getKerningOffset(left, right);
+
 	return 0;
 }
 
+Common::U32String StyledTTFont::convertUtf8ToUtf32(const Common::String &str) {
+	// The String class, and therefore the Font class as well, assume one
+	// character is one byte, but in this case it's actually an UTF-8
+	// string with up to 4 bytes per character. To work around this,
+	// convert it to an U32String before drawing it, because our Font class
+	// can handle that.
+	Common::U32String u32str;
+	uint i = 0;
+	while (i < str.size()) {
+		uint32 chr = 0;
+		if ((str[i] & 0xF8) == 0xF0) {
+			chr |= (str[i++] & 0x07) << 18;
+			chr |= (str[i++] & 0x3F) << 12;
+			chr |= (str[i++] & 0x3F) << 6;
+			chr |= (str[i++] & 0x3F);
+		} else if ((str[i] & 0xF0) == 0xE0) {
+			chr |= (str[i++] & 0x0F) << 12;
+			chr |= (str[i++] & 0x3F) << 6;
+			chr |= (str[i++] & 0x3F);
+		} else if ((str[i] & 0xE0) == 0xC0) {
+			chr |= (str[i++] & 0x1F) << 6;
+			chr |= (str[i++] & 0x3F);
+		} else {
+			chr = (str[i++] & 0x7F);
+		}
+		u32str += chr;
+	}
+	return u32str;
+}
+
 void StyledTTFont::drawChar(Graphics::Surface *dst, byte chr, int x, int y, uint32 color) {
 	if (_font) {
 		_font->drawChar(dst, chr, x, y, color);
-		if (_style & STTF_UNDERLINE) {
-			int16 pos = floor(_font->getFontHeight() * 0.87);
+		if (_style & TTF_STYLE_UNDERLINE) {
+			int16 pos = (int16)floor(_font->getFontHeight() * 0.87);
 			int thk = MAX((int)(_font->getFontHeight() * 0.05), 1);
 			dst->fillRect(Common::Rect(x, y + pos, x + _font->getCharWidth(chr), y + pos + thk), color);
 		}
-		if (_style & STTF_STRIKEOUT) {
-			int16 pos = floor(_font->getFontHeight() * 0.60);
+		if (_style & TTF_STYLE_STRIKETHROUGH) {
+			int16 pos = (int16)floor(_font->getFontHeight() * 0.60);
 			int thk = MAX((int)(_font->getFontHeight() * 0.05), 1);
 			dst->fillRect(Common::Rect(x, y + pos, x + _font->getCharWidth(chr), y + pos + thk), color);
 		}
@@ -177,10 +213,11 @@ void StyledTTFont::drawChar(Graphics::Surface *dst, byte chr, int x, int y, uint
 
 void StyledTTFont::drawString(Graphics::Surface *dst, const Common::String &str, int x, int y, int w, uint32 color, Graphics::TextAlign align) {
 	if (_font) {
-		_font->drawString(dst, str, x, y, w, color, align);
-		if (_style & STTF_UNDERLINE) {
-			int16 pos = floor(_font->getFontHeight() * 0.87);
-			int16 wd = MIN(_font->getStringWidth(str), w);
+		Common::U32String u32str = convertUtf8ToUtf32(str);
+		_font->drawString(dst, u32str, x, y, w, color, align);
+		if (_style & TTF_STYLE_UNDERLINE) {
+			int16 pos = (int16)floor(_font->getFontHeight() * 0.87);
+			int16 wd = MIN(_font->getStringWidth(u32str), w);
 			int16 stX = x;
 			if (align == Graphics::kTextAlignCenter)
 				stX += (w - wd) / 2;
@@ -191,9 +228,9 @@ void StyledTTFont::drawString(Graphics::Surface *dst, const Common::String &str,
 
 			dst->fillRect(Common::Rect(stX, y + pos, stX + wd, y + pos + thk), color);
 		}
-		if (_style & STTF_STRIKEOUT) {
-			int16 pos = floor(_font->getFontHeight() * 0.60);
-			int16 wd = MIN(_font->getStringWidth(str), w);
+		if (_style & TTF_STYLE_STRIKETHROUGH) {
+			int16 pos = (int16)floor(_font->getFontHeight() * 0.60);
+			int16 wd = MIN(_font->getStringWidth(u32str), w);
 			int16 stX = x;
 			if (align == Graphics::kTextAlignCenter)
 				stX += (w - wd) / 2;
diff --git a/engines/zvision/text/truetype_font.h b/engines/zvision/text/truetype_font.h
index b5fac4af8a..6abe05cda6 100644
--- a/engines/zvision/text/truetype_font.h
+++ b/engines/zvision/text/truetype_font.h
@@ -34,6 +34,16 @@ struct Surface;
 
 namespace ZVision {
 
+struct FontStyle {
+	const char *zorkFont;
+	const char *fontBase;
+	const char *freeFontBase;
+	const char *freeFontItalicName;
+	const char *liberationFontBase;
+};
+
+#define FONT_COUNT 9
+
 class ZVision;
 
 // Styled TTF
@@ -43,11 +53,11 @@ public:
 	~StyledTTFont();
 
 	enum {
-		STTF_BOLD = 1,
-		STTF_ITALIC = 2,
-		STTF_UNDERLINE = 4,
-		STTF_STRIKEOUT = 8,
-		STTF_SHARP = 16
+		TTF_STYLE_BOLD = 0x01,
+		TTF_STYLE_ITALIC = 0x02,
+		TTF_STYLE_UNDERLINE = 0x04,
+		TTF_STYLE_STRIKETHROUGH = 0x08,
+		TTF_STYLE_SHARP = 0x10
 	};
 
 private:
@@ -55,18 +65,18 @@ private:
 	Graphics::Font *_font;
 	int _lineHeight;
 	uint _style;
-	Common::String _fntName;
+	Common::String _fontName;
 
 public:
-	bool loadFont(const Common::String &fontName, int32 point);
 	bool loadFont(const Common::String &fontName, int32 point, uint style);
-	void setStyle(uint newStyle);
 
 	int getFontHeight();
 	int getMaxCharWidth();
 	int getCharWidth(byte chr);
 	int getKerningOffset(byte left, byte right);
 
+	Common::U32String convertUtf8ToUtf32(const Common::String &str);
+
 	void drawChar(Graphics::Surface *dst, byte chr, int x, int y, uint32 color);
 
 	void drawString(Graphics::Surface *dst, const Common::String &str, int x, int y, int w, uint32 color, Graphics::TextAlign align = Graphics::kTextAlignLeft);
diff --git a/engines/zvision/video/rlf_decoder.cpp b/engines/zvision/video/rlf_decoder.cpp
index db598a25b6..3bbf22edff 100644
--- a/engines/zvision/video/rlf_decoder.cpp
+++ b/engines/zvision/video/rlf_decoder.cpp
@@ -159,7 +159,7 @@ RLFDecoder::RLFVideoTrack::Frame RLFDecoder::RLFVideoTrack::readNextFrame() {
 
 bool RLFDecoder::RLFVideoTrack::seek(const Audio::Timestamp &time) {
 	uint frame = getFrameAtTime(time);
-	assert(frame < (int)_frameCount);
+	assert(frame < _frameCount);
 
 	if ((uint)_displayedFrame == frame)
 		return true;
@@ -169,7 +169,7 @@ bool RLFDecoder::RLFVideoTrack::seek(const Audio::Timestamp &time) {
 
 	if (distance < 0) {
 		for (uint i = 0; i < _completeFrames.size(); ++i) {
-			if ((int)_completeFrames[i] > frame)
+			if (_completeFrames[i] > frame)
 				break;
 			closestFrame = _completeFrames[i];
 		}
@@ -197,7 +197,7 @@ bool RLFDecoder::RLFVideoTrack::seek(const Audio::Timestamp &time) {
 const Graphics::Surface *RLFDecoder::RLFVideoTrack::decodeNextFrame() {
 	if (_displayedFrame >= (int)_frameCount)
 		return NULL;
-	
+
 	_displayedFrame++;
 	applyFrameToCurrent(_displayedFrame);
 
diff --git a/engines/zvision/video/video.cpp b/engines/zvision/video/video.cpp
index 66a567abb2..1cfd0f4197 100644
--- a/engines/zvision/video/video.cpp
+++ b/engines/zvision/video/video.cpp
@@ -23,9 +23,7 @@
 #include "common/scummsys.h"
 #include "common/system.h"
 #include "video/video_decoder.h"
-// TODO: Enable once VOB + AC3 support is implemented
-#if 0
-//#ifdef USE_MPEG2
+#ifdef USE_MPEG2
 #include "video/mpegps_decoder.h"
 #endif
 #include "engines/util.h"
@@ -50,9 +48,7 @@ Video::VideoDecoder *ZVision::loadAnimation(const Common::String &fileName) {
 		animation = new RLFDecoder();
 	else if (tmpFileName.hasSuffix(".avi"))
 		animation = new ZorkAVIDecoder();
-// TODO: Enable once VOB + AC3 support is implemented
-#if 0
-//#ifdef USE_MPEG2
+#ifdef USE_MPEG2
 	else if (tmpFileName.hasSuffix(".vob"))
 		animation = new Video::MPEGPSDecoder();
 #endif
@@ -66,7 +62,7 @@ Video::VideoDecoder *ZVision::loadAnimation(const Common::String &fileName) {
 	bool loaded = animation->loadStream(_file);
 	if (!loaded)
 		error("Error loading animation %s", tmpFileName.c_str());
-	
+
 	return animation;
 }
 
diff --git a/engines/zvision/video/zork_avi_decoder.cpp b/engines/zvision/video/zork_avi_decoder.cpp
index 5618250d79..1d23546551 100644
--- a/engines/zvision/video/zork_avi_decoder.cpp
+++ b/engines/zvision/video/zork_avi_decoder.cpp
@@ -34,33 +34,43 @@
 namespace ZVision {
 
 Video::AVIDecoder::AVIAudioTrack *ZorkAVIDecoder::createAudioTrack(Video::AVIDecoder::AVIStreamHeader sHeader, Video::AVIDecoder::PCMWaveFormat wvInfo) {
-	ZorkAVIDecoder::ZorkAVIAudioTrack *audioTrack = new ZorkAVIDecoder::ZorkAVIAudioTrack(sHeader, wvInfo, _soundType);
-	return (Video::AVIDecoder::AVIAudioTrack *)audioTrack;
+	if (wvInfo.tag != kWaveFormatZorkPCM)
+		return new AVIAudioTrack(sHeader, wvInfo, _soundType);
+
+	assert(wvInfo.size == 8);
+	return new ZorkAVIAudioTrack(sHeader, wvInfo, _soundType);
+}
+
+ZorkAVIDecoder::ZorkAVIAudioTrack::ZorkAVIAudioTrack(const AVIStreamHeader &streamHeader, const PCMWaveFormat &waveFormat, Audio::Mixer::SoundType soundType) :
+		Video::AVIDecoder::AVIAudioTrack(streamHeader, waveFormat, soundType), _queueStream(0), _decoder(waveFormat.channels == 2) {
 }
 
-void ZorkAVIDecoder::ZorkAVIAudioTrack::queueSound(Common::SeekableReadStream *stream) {
-	if (_audStream) {
-		if (_wvInfo.tag == kWaveFormatZorkPCM) {
-			assert(_wvInfo.size == 8);
-			RawChunkStream::RawChunk chunk = decoder->readNextChunk(stream);
-			delete stream;
+void ZorkAVIDecoder::ZorkAVIAudioTrack::createAudioStream() {
+	_queueStream = Audio::makeQueuingAudioStream(_wvInfo.samplesPerSec, _wvInfo.channels == 2);
+	_audioStream = _queueStream;
+}
+
+void ZorkAVIDecoder::ZorkAVIAudioTrack::queueSound(Common::SeekableReadStream *stream) {			
+	RawChunkStream::RawChunk chunk = _decoder.readNextChunk(stream);
+	delete stream;
 
-			if (chunk.data) {
-				byte flags = Audio::FLAG_16BITS | Audio::FLAG_STEREO;
+	if (chunk.data) {
+		byte flags = Audio::FLAG_16BITS;
+		if (_wvInfo.channels == 2)
+			flags |= Audio::FLAG_STEREO;
 #ifdef SCUMM_LITTLE_ENDIAN
-				// RawChunkStream produces native endianness int16
-				flags |= Audio::FLAG_LITTLE_ENDIAN;
+		// RawChunkStream produces native endianness int16
+		flags |= Audio::FLAG_LITTLE_ENDIAN;
 #endif
-				_audStream->queueBuffer((byte *)chunk.data, chunk.size, DisposeAfterUse::YES, flags);
-			}
-		} else {
-			AVIAudioTrack::queueSound(stream);
-		}
+		_queueStream->queueBuffer((byte *)chunk.data, chunk.size, DisposeAfterUse::YES, flags);
 	}
+
+	_curChunk++;
 }
 
 void ZorkAVIDecoder::ZorkAVIAudioTrack::resetStream() {
-	decoder->init();
+	AVIAudioTrack::resetStream();
+	_decoder.init();
 }
 
 } // End of namespace ZVision
diff --git a/engines/zvision/video/zork_avi_decoder.h b/engines/zvision/video/zork_avi_decoder.h
index 89c0d1e4b9..afcdb05676 100644
--- a/engines/zvision/video/zork_avi_decoder.h
+++ b/engines/zvision/video/zork_avi_decoder.h
@@ -39,22 +39,15 @@ public:
 private:
 	class ZorkAVIAudioTrack : public Video::AVIDecoder::AVIAudioTrack {
 	public:
-		ZorkAVIAudioTrack(const AVIStreamHeader &streamHeader, const PCMWaveFormat &waveFormat, Audio::Mixer::SoundType soundType) :
-			Video::AVIDecoder::AVIAudioTrack(streamHeader, waveFormat, soundType),
-			decoder(NULL) {
-			if (_audStream) {
-				decoder = new RawChunkStream(_audStream->isStereo());
-			}
-		}
-		virtual ~ZorkAVIAudioTrack() {
-			if (decoder)
-				delete decoder;
-		}
+		ZorkAVIAudioTrack(const AVIStreamHeader &streamHeader, const PCMWaveFormat &waveFormat, Audio::Mixer::SoundType soundType);
 
+		void createAudioStream();
 		void queueSound(Common::SeekableReadStream *stream);
 		void resetStream();
+
 	private:
-		RawChunkStream *decoder;
+		Audio::QueuingAudioStream *_queueStream;
+		RawChunkStream _decoder;
 	};
 
 	Video::AVIDecoder::AVIAudioTrack *createAudioTrack(Video::AVIDecoder::AVIStreamHeader sHeader, Video::AVIDecoder::PCMWaveFormat wvInfo);
diff --git a/engines/zvision/zvision.cpp b/engines/zvision/zvision.cpp
index 5b6d63e869..779fdc4464 100644
--- a/engines/zvision/zvision.cpp
+++ b/engines/zvision/zvision.cpp
@@ -29,7 +29,6 @@
 #include "zvision/graphics/cursors/cursor_manager.h"
 #include "zvision/file/save_manager.h"
 #include "zvision/text/string_manager.h"
-#include "zvision/detection.h"
 #include "zvision/scripting/menu.h"
 #include "zvision/file/search_manager.h"
 #include "zvision/text/text.h"
@@ -184,14 +183,14 @@ void ZVision::initialize() {
 	_searchManager->addDir("FONTS");
 	_searchManager->addDir("addon");
 
-	if (_gameDescription->gameId == GID_GRANDINQUISITOR) {
+	if (getGameId() == GID_GRANDINQUISITOR) {
 		if (!_searchManager->loadZix("INQUIS.ZIX"))
-			error("Unable to load the game ZIX file");
-	} else if (_gameDescription->gameId == GID_NEMESIS) {
+			error("Unable to load file INQUIS.ZIX");
+	} else if (getGameId() == GID_NEMESIS) {
 		if (!_searchManager->loadZix("NEMESIS.ZIX")) {
 			// The game might not be installed, try MEDIUM.ZIX instead
 			if (!_searchManager->loadZix("ZNEMSCR/MEDIUM.ZIX"))
-				error("Unable to load the game ZIX file");
+				error("Unable to load the file ZNEMSCR/MEDIUM.ZIX");
 		}
 	}
 
@@ -209,7 +208,7 @@ void ZVision::initialize() {
 	_textRenderer = new TextRenderer(this);
 	_midiManager = new MidiManager();
 
-	if (_gameDescription->gameId == GID_GRANDINQUISITOR)
+	if (getGameId() == GID_GRANDINQUISITOR)
 		_menu = new MenuZGI(this);
 	else
 		_menu = new MenuNemesis(this);
@@ -217,7 +216,7 @@ void ZVision::initialize() {
 	// Initialize the managers
 	_cursorManager->initialize();
 	_scriptManager->initialize();
-	_stringManager->initialize(_gameDescription->gameId);
+	_stringManager->initialize(getGameId());
 
 	registerDefaultSettings();
 
@@ -236,6 +235,8 @@ void ZVision::initialize() {
 	getTimerManager()->installTimerProc(&fpsTimerCallback, 1000000, this, "zvisionFPS");
 }
 
+extern const FontStyle getSystemFont(int fontIndex);
+
 Common::Error ZVision::run() {
 	initialize();
 
@@ -243,16 +244,62 @@ Common::Error ZVision::run() {
 	if (ConfMan.hasKey("save_slot"))
 		_saveManager->loadGame(ConfMan.getInt("save_slot"));
 
+	bool foundAllFonts = true;
+
 	// Before starting, make absolutely sure that the user has copied the needed fonts
-	if (!Common::File::exists("arial.ttf") && !Common::File::exists("FreeSans.ttf") && !_searchManager->hasFile("arial.ttf")  && !_searchManager->hasFile("FreeSans.ttf") ) {
+	for (int i = 0; i < FONT_COUNT; i++) {
+		FontStyle curFont = getSystemFont(i);
+		Common::String freeFontBoldItalic = Common::String("Bold") + curFont.freeFontItalicName;
+
+		const char *fontSuffixes[4] = { "", "bd", "i", "bi" };
+		const char *freeFontSuffixes[4] = { "", "Bold", curFont.freeFontItalicName, freeFontBoldItalic.c_str() };
+		const char *liberationFontSuffixes[4] = { "-Regular", "-Bold", "-Italic", "-BoldItalic" };
+
+		for (int j = 0; j < 4; j++) {
+			Common::String fontName = curFont.fontBase;
+			if (fontName == "censcbk" && j > 0)
+				fontName = "schlbk";
+			fontName += fontSuffixes[j];
+			fontName += ".ttf";
+
+			if (fontName == "schlbkbd.ttf")
+				fontName = "schlbkb.ttf";
+			if (fontName == "garabi.ttf")
+				continue;
+			if (fontName == "garai.ttf")
+				fontName = "garait.ttf";
+
+			Common::String freeFontName = curFont.freeFontBase;
+			freeFontName += freeFontSuffixes[j];
+			freeFontName += ".ttf";
+
+			Common::String liberationFontName = curFont.liberationFontBase;
+			liberationFontName += liberationFontSuffixes[j];
+			liberationFontName += ".ttf";
+
+			if (!Common::File::exists(fontName) && !_searchManager->hasFile(fontName) &&
+				!Common::File::exists(liberationFontName) && !_searchManager->hasFile(liberationFontName) &&
+				!Common::File::exists(freeFontName) && !_searchManager->hasFile(freeFontName)) {
+				foundAllFonts = false;
+				break;
+			}
+		}
+
+		if (!foundAllFonts)
+			break;
+	}
+
+	if (!foundAllFonts) {
 		GUI::MessageDialog dialog(
 				"Before playing this game, you'll need to copy the required "
 				"fonts into ScummVM's extras directory, or into the game directory. "
 				"On Windows, you'll need the following font files from the Windows "
 				"font directory: Times New Roman, Century Schoolbook, Garamond, "
-				"Courier New and Arial. Alternatively, you can download the GNU "
-				"FreeFont package. You'll need all the fonts from that package, "
-				"i.e., FreeMono, FreeSans and FreeSerif."
+				"Courier New and Arial. Alternatively, you can download the "
+				"Liberation Fonts or the GNU FreeFont package. You'll need all the "
+				"fonts from the font package you choose, i.e., LiberationMono, "
+				"LiberationSans and LiberationSerif, or FreeMono, FreeSans and "
+				"FreeSerif respectively."
 		);
 		dialog.runModal();
 		quitGame();
@@ -348,8 +395,8 @@ void ZVision::fpsTimer() {
 }
 
 void ZVision::initScreen() {
-	uint16 workingWindowWidth  = (_gameDescription->gameId == GID_NEMESIS) ? ZNM_WORKING_WINDOW_WIDTH  : ZGI_WORKING_WINDOW_WIDTH;
-	uint16 workingWindowHeight = (_gameDescription->gameId == GID_NEMESIS) ? ZNM_WORKING_WINDOW_HEIGHT : ZGI_WORKING_WINDOW_HEIGHT;
+	uint16 workingWindowWidth = (getGameId() == GID_NEMESIS) ? ZNM_WORKING_WINDOW_WIDTH : ZGI_WORKING_WINDOW_WIDTH;
+	uint16 workingWindowHeight = (getGameId() == GID_NEMESIS) ? ZNM_WORKING_WINDOW_HEIGHT : ZGI_WORKING_WINDOW_HEIGHT;
 	_workingWindow = Common::Rect(
 						 (WINDOW_WIDTH  -  workingWindowWidth) / 2,
 						 (WINDOW_HEIGHT - workingWindowHeight) / 2,
@@ -360,4 +407,10 @@ void ZVision::initScreen() {
 	initGraphics(WINDOW_WIDTH, WINDOW_HEIGHT, true, &_screenPixelFormat);
 }
 
+void ZVision::initHiresScreen() {
+	_renderManager->upscaleRect(_workingWindow);
+
+	initGraphics(HIRES_WINDOW_WIDTH, HIRES_WINDOW_HEIGHT, true, &_screenPixelFormat);
+}
+
 } // End of namespace ZVision
diff --git a/engines/zvision/zvision.h b/engines/zvision/zvision.h
index a3bcb384d1..4c948faaa4 100644
--- a/engines/zvision/zvision.h
+++ b/engines/zvision/zvision.h
@@ -24,7 +24,6 @@
 #ifndef ZVISION_ZVISION_H
 #define ZVISION_ZVISION_H
 
-#include "zvision/detection.h"
 #include "zvision/core/clock.h"
 #include "zvision/file/search_manager.h"
 
@@ -51,7 +50,6 @@ class VideoDecoder;
  * - Zork: Grand Inquisitor
  *
  */
-
 namespace ZVision {
 
 struct ZVisionGameDescription;
@@ -67,6 +65,33 @@ class TextRenderer;
 class Subtitle;
 class MidiManager;
 
+enum {
+	WINDOW_WIDTH = 640,
+	WINDOW_HEIGHT = 480,
+
+	HIRES_WINDOW_WIDTH = 800,
+	HIRES_WINDOW_HEIGHT = 600,
+
+	// Zork Nemesis working window sizes
+	ZNM_WORKING_WINDOW_WIDTH = 512,
+	ZNM_WORKING_WINDOW_HEIGHT = 320,
+
+	// ZGI working window sizes
+	ZGI_WORKING_WINDOW_WIDTH = 640,
+	ZGI_WORKING_WINDOW_HEIGHT = 344,
+
+	ROTATION_SCREEN_EDGE_OFFSET = 60,
+	MAX_ROTATION_SPEED = 400, // Pixels per second
+
+	KEYBUF_SIZE = 20
+};
+
+enum ZVisionGameId {
+	GID_NONE = 0,
+	GID_NEMESIS = 1,
+	GID_GRANDINQUISITOR = 2
+};
+
 class ZVision : public Engine {
 public:
 	ZVision(OSystem *syst, const ZVisionGameDescription *gameDesc);
@@ -83,24 +108,6 @@ public:
 	const Graphics::PixelFormat _screenPixelFormat;
 
 private:
-	enum {
-		WINDOW_WIDTH = 640,
-		WINDOW_HEIGHT = 480,
-
-		// Zork nemesis working window sizes
-		ZNM_WORKING_WINDOW_WIDTH  = 512,
-		ZNM_WORKING_WINDOW_HEIGHT = 320,
-
-		// ZGI working window sizes
-		ZGI_WORKING_WINDOW_WIDTH  = 640,
-		ZGI_WORKING_WINDOW_HEIGHT = 344,
-
-		ROTATION_SCREEN_EDGE_OFFSET = 60,
-		MAX_ROTATION_SPEED = 400, // Pixels per second
-
-		KEYBUF_SIZE = 20
-	};
-
 	Console *_console;
 	const ZVisionGameDescription *_gameDescription;
 
@@ -113,12 +120,12 @@ private:
 	ScriptManager *_scriptManager;
 	RenderManager *_renderManager;
 	CursorManager *_cursorManager;
-	SaveManager *_saveManager;
 	StringManager *_stringManager;
-	MenuHandler *_menu;
 	SearchManager *_searchManager;
 	TextRenderer *_textRenderer;
 	MidiManager *_midiManager;
+	SaveManager *_saveManager;
+	MenuHandler *_menu;
 
 	// Clock
 	Clock _clock;
@@ -138,12 +145,15 @@ private:
 	bool _videoIsPlaying;
 
 	uint8 _cheatBuffer[KEYBUF_SIZE];
+
 public:
-	uint32 getFeatures() const;
-	Common::Language getLanguage() const;
 	Common::Error run();
 	void pauseEngineIntern(bool pause);
 
+	ZVisionGameId getGameId() const;
+	Common::Language getLanguage() const;
+	uint32 getFeatures() const;
+
 	ScriptManager *getScriptManager() const {
 		return _scriptManager;
 	}
@@ -171,12 +181,10 @@ public:
 	MenuHandler *getMenuHandler() const {
 		return _menu;
 	}
+
 	Common::RandomSource *getRandomSource() const {
 		return _rnd;
 	}
-	ZVisionGameId getGameId() const {
-		return _gameDescription->gameId;
-	}
 	int16 getKeyboardVelocity() const {
 		return _keyboardVelocity;
 	}
@@ -195,6 +203,7 @@ public:
 	}
 
 	void initScreen();
+	void initHiresScreen();
 
 	/**
 	 * Play a video until it is finished. This is a blocking call. It will call
@@ -232,6 +241,7 @@ public:
 	bool canSaveGameStateCurrently();
 	Common::Error loadGameState(int slot);
 	Common::Error saveGameState(int slot, const Common::String &desc);
+
 private:
 	void initialize();
 	void initFonts();