Merged revisions 32124,32126-32128,32131,32133,32135-32144,32146-32153,32155-32163,32165-32168,32170-32173,32175-32179,32181-32191,32193-32202,32204-32205,32209-32214,32216,32218,32220-32235,32237-32266,32269-32271,32273-32290,32292-32295,32297-32317,32319-32323,32325-32328,32330-32331,32334-32338,32343-32347 via svnmerge from

https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk

svn-id: r32350

156 files changed, 6923 insertions, 4949 deletions

diff --git a/engines/agos/agos.cpp b/engines/agos/agos.cpp
index 80fbe28c0c..7880d407b8 100644
--- a/engines/agos/agos.cpp
+++ b/engines/agos/agos.cpp
@@ -23,7 +23,7 @@
  *
  */
 
-
+#include <time.h>	// for AGOSEngine::getTime()
 
 #include "common/config-manager.h"
 #include "common/file.h"
@@ -38,8 +38,6 @@
 #include "sound/mididrv.h"
 #include "sound/mods/protracker.h"
 
-#include <time.h>	// for AGOSEngine::getTime()
-
 using Common::File;
 
 namespace AGOS {
@@ -928,25 +926,31 @@ GUI::Debugger *AGOSEngine::getDebugger() {
 	return _debugger;
 }
 
-void AGOSEngine::pause() {
-	_keyPressed.reset();
-	_pause = true;
-	bool ambient_status = _ambientPaused;
-	bool music_status = _musicPaused;
+void AGOSEngine::pauseEngineIntern(bool pauseIt) {
+	if (pauseIt) {
+		_keyPressed.reset();
+		_pause = true;
+
+		_midi.pause(true);
+		_mixer->pauseAll(true);
+		_sound->ambientPause(true);
+	} else {
+		_pause = false;
+
+		_midi.pause(_musicPaused);
+		_mixer->pauseAll(false);
+		_sound->ambientPause(_ambientPaused);
+	}
+}
 
-	_midi.pause(true);
-	_mixer->pauseAll(true);
-	_sound->ambientPause(true);
+void AGOSEngine::pause() {
+	pauseEngine(true);
 
 	while (_pause && !_quit) {
 		delay(1);
 		if (_keyPressed.keycode == Common::KEYCODE_p)
-			_pause = false;
+			pauseEngine(false);
 	}
-
-	_midi.pause(music_status);
-	_mixer->pauseAll(false);
-	_sound->ambientPause(ambient_status);
 }
 
 int AGOSEngine::go() {
diff --git a/engines/agos/agos.h b/engines/agos/agos.h
index bd8ff9d63c..74a0b026e9 100644
--- a/engines/agos/agos.h
+++ b/engines/agos/agos.h
@@ -1207,6 +1207,7 @@ protected:
 	void checkTimerCallback();
 	void delay(uint delay);
 	void pause();
+	virtual void pauseEngineIntern(bool pause);
 
 	void waitForMark(uint i);
 	void scrollScreen();
diff --git a/engines/cine/anim.cpp b/engines/cine/anim.cpp
index 6edc714da7..73837308ca 100644
--- a/engines/cine/anim.cpp
+++ b/engines/cine/anim.cpp
@@ -53,6 +53,7 @@ AnimData animDataTable[NUM_MAX_ANIMDATA];
 
 static const AnimDataEntry transparencyData[] = {
 	{"ALPHA", 0xF},
+	{"TITRE", 0xF},
 	{"TITRE2", 0xF},
 	{"ET", 0xC},
 	{"L311", 0x3},
diff --git a/engines/cine/bg.cpp b/engines/cine/bg.cpp
index b6c07a05cb..c5b7fb4e3d 100644
--- a/engines/cine/bg.cpp
+++ b/engines/cine/bg.cpp
@@ -37,7 +37,7 @@ uint16 bgVar0;
 byte *additionalBgTable[9];
 byte currentAdditionalBgIdx = 0, currentAdditionalBgIdx2 = 0;
 
-byte loadCt(const char *ctName) {
+byte loadCtFW(const char *ctName) {
 	uint16 header[32];
 	byte *ptr, *dataPtr;
 
@@ -46,79 +46,62 @@ byte loadCt(const char *ctName) {
 
 	ptr = dataPtr = readBundleFile(findFileInBundle(ctName));
 
-	if (g_cine->getGameType() == Cine::GType_OS) {
-		uint16 bpp = READ_BE_UINT16(ptr); ptr += 2;
-		if (bpp == 8) {
-			ctColorMode = 1;
-			memcpy(newPalette, ptr, 256 * 3);
-			ptr += 3 * 256;
-			memcpy(page3Raw, ptr, 320 * 200);
-		} else {
-			ctColorMode = 0;
-			for (int i = 0; i < 16; i++) {
-				tempPalette[i] = READ_BE_UINT16(ptr);
-				ptr += 2;
-			}
-
-			gfxResetRawPage(page3Raw);
-			gfxConvertSpriteToRaw(page3Raw, ptr, 160, 200);
-		}
-	} else {
-		loadRelatedPalette(ctName);
+	loadRelatedPalette(ctName);
 
-		assert(strstr(ctName, ".NEO"));
+	assert(strstr(ctName, ".NEO"));
 
-		Common::MemoryReadStream readS(ptr, 32);
-
-		for (int i = 0; i < 16; i++) {
-			header[i] = readS.readUint16BE();
-		}
+	Common::MemoryReadStream readS(ptr, 32);
 
-		gfxConvertSpriteToRaw(page3Raw, ptr + 0x80, 160, 200);
+	for (int i = 0; i < 16; i++) {
+		header[i] = readS.readUint16BE();
 	}
 
+	gfxConvertSpriteToRaw(page3Raw, ptr + 0x80, 160, 200);
+
 	free(dataPtr);
 	return 0;
 }
 
-void loadBgHigh(const char *currentPtr) {
-	memcpy(newPalette, currentPtr, 256 * 3);
-	currentPtr += 256 * 3;
+byte loadCtOS(const char *ctName) {
+	byte *ptr, *dataPtr;
 
-	memcpy(page2Raw, currentPtr, 320 * 200);
+	if (currentCtName != ctName)
+		strcpy(currentCtName, ctName);
+
+	ptr = dataPtr = readBundleFile(findFileInBundle(ctName));
 
-	newColorMode = 2;
-	bgColorMode = 1;
+	uint16 bpp = READ_BE_UINT16(ptr);
+	ptr += 2;
+
+	if (bpp == 8) {
+		memcpy(page3Raw, ptr + 256 * 3, 320 * 200);
+		renderer->loadCt256(ptr, ctName);
+	} else {
+		gfxConvertSpriteToRaw(page3Raw, ptr + 32, 160, 200);
+		renderer->loadCt16(ptr, ctName);
+	}
 
+	free(dataPtr);
+	return 0;
 }
 
 byte loadBg(const char *bgName) {
 	byte *ptr, *dataPtr;
 
-	if (currentBgName[0] != bgName)
-		strcpy(currentBgName[0], bgName);
-
 	byte fileIdx = findFileInBundle(bgName);
 	ptr = dataPtr = readBundleFile(fileIdx);
 
-	uint16 bpp = READ_BE_UINT16(ptr); ptr += 2;
+	uint16 bpp = READ_BE_UINT16(ptr);
+	ptr += 2;
+
 	if (bpp == 8) {
-		loadBgHigh((const char *)ptr);
+		renderer->loadBg256(ptr, bgName);
 	} else {
-		newColorMode = 1;
-		bgColorMode = 0;
-
-		for (int i = 0; i < 16; i++) {
-			tempPalette[i] = READ_BE_UINT16(ptr);
-			ptr += 2;
-		}
-
 		if (g_cine->getGameType() == Cine::GType_FW) {
 			loadRelatedPalette(bgName);
 		}
 
-		gfxResetRawPage(page2Raw);
-		gfxConvertSpriteToRaw(page2Raw, ptr, 160, 200);
+		renderer->loadBg16(ptr, bgName);
 	}
 	free(dataPtr);
 	return 0;
@@ -127,28 +110,15 @@ byte loadBg(const char *bgName) {
 void addBackground(const char *bgName, uint16 bgIdx) {
 	byte *ptr, *dataPtr;
 
-	strcpy(currentBgName[bgIdx], bgName);
-
 	byte fileIdx = findFileInBundle(bgName);
 	ptr = dataPtr = readBundleFile(fileIdx);
 
-	additionalBgTable[bgIdx] = (byte *) malloc(320 * 200);
-
 	uint16 bpp = READ_BE_UINT16(ptr); ptr += 2;
 
 	if (bpp == 8) {
-		bgColorMode = 1;
-		memcpy(newPalette, ptr, 256 * 3);
-		ptr += 3 * 256;
-		memcpy(additionalBgTable[bgIdx], ptr, 320 * 200);
+		renderer->loadBg256(ptr, bgName, bgIdx);
 	} else {
-		bgColorMode = 0;
-		for (int i = 0; i < 16; i++) {
-			tempPalette[i] = READ_BE_UINT16(ptr);
-			ptr += 2;
-		}
-
-		gfxConvertSpriteToRaw(additionalBgTable[bgIdx], ptr, 160, 200);
+		renderer->loadBg16(ptr, bgName, bgIdx);
 	}
 	free(dataPtr);
 }
diff --git a/engines/cine/bg.h b/engines/cine/bg.h
index ca5c222131..5fa8209131 100644
--- a/engines/cine/bg.h
+++ b/engines/cine/bg.h
@@ -27,20 +27,9 @@
 #define CINE_BG_H
 
 namespace Cine {
-struct bgData {
-	byte *data;
-	byte colorMode;
-	byte *highPalette;
-	uint16 *lowPalette;
-};
-
 byte loadBg(const char *bgName);
-byte loadCt(const char *bgName);
-
-//extern bgData additionalBgTable[9];
-extern byte *additionalBgTable[9];
-extern byte currentAdditionalBgIdx;
-extern byte currentAdditionalBgIdx2;
+byte loadCtFW(const char *bgName);
+byte loadCtOS(const char *bgName);
 
 void addBackground(const char *bgName, uint16 bgIdx);
 
diff --git a/engines/cine/bg_list.cpp b/engines/cine/bg_list.cpp
index a70733dc68..cf25f1d355 100644
--- a/engines/cine/bg_list.cpp
+++ b/engines/cine/bg_list.cpp
@@ -40,62 +40,20 @@ Common::List<BGIncrust> bgIncrustList;
 
 /*! \brief Add masked sprite to the background
  * \param objIdx Sprite description
- * \param addList Add sprite to incrust list if true
- * \todo Fix incrust objects on CT background. Always drawing incrust elements
- * on CT background breaks game zones
  */
-void addToBGList(int16 objIdx, bool addList) {
-	int16 x = objectTable[objIdx].x;
-	int16 y = objectTable[objIdx].y;
-	int16 width = animDataTable[objectTable[objIdx].frame]._var1;
-	int16 height = animDataTable[objectTable[objIdx].frame]._height;
-	const byte *data = animDataTable[objectTable[objIdx].frame].data();
-	const byte *mask = animDataTable[objectTable[objIdx].frame].mask();
-//	int16 part = objectTable[objIdx].part;
-
-	// Operation Stealth may switch among multiple backgrounds
-	if (g_cine->getGameType() == GType_OS) {
-		for (int i = 0; i < 8; i++) {
-			if (additionalBgTable[i]) {
-				drawSpriteRaw2(data, objectTable[objIdx].part, width, height, additionalBgTable[i], x, y);
-			}
-		}
-	} else {
-		drawSpriteRaw(data, mask, width, height, page2Raw, x, y);
-	}
+void addToBGList(int16 objIdx) {
+	renderer->incrustSprite(objectTable[objIdx]);
 
-	if (addList)
-		createBgIncrustListElement(objIdx, 0);
+	createBgIncrustListElement(objIdx, 0);
 }
 
 /*! \brief Add filled sprite to the background
  * \param objIdx Sprite description
- * \param addList Add sprite to incrust list if true
- * \todo Fix incrust objects on CT background. Always drawing incrust elements
- * on CT background breaks game zones
  */
-void addSpriteFilledToBGList(int16 objIdx, bool addList) {
-	int16 x = objectTable[objIdx].x;
-	int16 y = objectTable[objIdx].y;
-	int16 width = animDataTable[objectTable[objIdx].frame]._realWidth;
-	int16 height = animDataTable[objectTable[objIdx].frame]._height;
-	const byte *data = animDataTable[objectTable[objIdx].frame].data();
-
-	if (data) {
-		// Operation Stealth may switch among multiple backgrounds
-		if (g_cine->getGameType() == GType_OS) {
-			for (int i = 0; i < 8; i++) {
-				if (additionalBgTable[i]) {
-					gfxFillSprite(data, width, height, additionalBgTable[i], x, y);
-				}
-			}
-		} else {
-			gfxFillSprite(data, width, height, page2Raw, x, y);
-		}
-	}
+void addSpriteFilledToBGList(int16 objIdx) {
+	renderer->incrustMask(objectTable[objIdx]);
 
-	if (addList)
-		createBgIncrustListElement(objIdx, 1);
+	createBgIncrustListElement(objIdx, 1);
 }
 
 /*! \brief Add new element to incrust list
@@ -115,7 +73,7 @@ void createBgIncrustListElement(int16 objIdx, int16 param) {
 	bgIncrustList.push_back(tmp);
 }
 
-/*! \brief Reset var8 (probably something related to bgIncrustList
+/*! \brief Reset var8 (probably something related to bgIncrustList)
  */
 void resetBgIncrustList(void) {
 	var8 = 0;
@@ -142,9 +100,9 @@ void loadBgIncrustFromSave(Common::InSaveFile &fHandle) {
 		bgIncrustList.push_back(tmp);
 
 		if (tmp.param == 0) {
-			addToBGList(tmp.objIdx, false);
+			renderer->incrustSprite(objectTable[tmp.objIdx]);
 		} else {
-			addSpriteFilledToBGList(tmp.objIdx, false);
+			renderer->incrustMask(objectTable[tmp.objIdx]);
 		}
 	}
 }
diff --git a/engines/cine/bg_list.h b/engines/cine/bg_list.h
index 9ceae0acf5..1849d6ec3d 100644
--- a/engines/cine/bg_list.h
+++ b/engines/cine/bg_list.h
@@ -46,8 +46,8 @@ struct BGIncrust {
 extern Common::List<BGIncrust> bgIncrustList;
 extern uint32 var8;
 
-void addToBGList(int16 objIdx, bool addList = true);
-void addSpriteFilledToBGList(int16 idx, bool addList = true);
+void addToBGList(int16 objIdx);
+void addSpriteFilledToBGList(int16 idx);
 
 void createBgIncrustListElement(int16 objIdx, int16 param);
 void resetBgIncrustList(void);
diff --git a/engines/cine/cine.cpp b/engines/cine/cine.cpp
index 52474d13a9..6cf9e2fb26 100644
--- a/engines/cine/cine.cpp
+++ b/engines/cine/cine.cpp
@@ -97,7 +97,9 @@ int CineEngine::init() {
 int CineEngine::go() {
 	CursorMan.showMouse(true);
 	mainLoop(1);
-	gfxDestroy();
+
+	delete renderer;
+	delete[] page3Raw;
 	delete g_sound;
 	return 0;
 }
@@ -107,8 +109,14 @@ void CineEngine::initialize() {
 	setupOpcodes();
 
 	initLanguage(g_cine->getLanguage());
-	gfxInit();
 
+	if (g_cine->getGameType() == Cine::GType_OS) {
+		renderer = new OSRenderer;
+	} else {
+		renderer = new FWRenderer;
+	}
+
+	page3Raw = new byte[320 * 200];
 	textDataPtr = (byte *)malloc(8000);
 
 	partBuffer = (PartBuffer *)malloc(NUM_MAX_PARTDATA * sizeof(PartBuffer));
diff --git a/engines/cine/gfx.cpp b/engines/cine/gfx.cpp
index 2730a92e62..e20dd46c53 100644
--- a/engines/cine/gfx.cpp
+++ b/engines/cine/gfx.cpp
@@ -27,6 +27,7 @@
 #include "cine/bg.h"
 #include "cine/bg_list.h"
 #include "cine/various.h"
+#include "cine/pal.h"
 
 #include "common/endian.h"
 #include "common/system.h"
@@ -35,18 +36,8 @@
 
 namespace Cine {
 
-uint16 c_palette[256];
-byte colorMode256 = 0;
-byte palette256[256 * 3];
-byte newPalette[256 * 3];
-byte newColorMode = 0;
-byte ctColorMode = 0;
-byte bgColorMode = 0;
-
-byte *screenBuffer;
-byte *page1Raw;
-byte *page2Raw;
 byte *page3Raw;
+FWRenderer *renderer = NULL;
 
 static const byte mouseCursorNormal[] = {
 	0x00, 0x00, 0x40, 0x00, 0x60, 0x00, 0x70, 0x00,
@@ -96,28 +87,1189 @@ static const byte cursorPalette[] = {
 	0xff, 0xff, 0xff, 0xff
 };
 
-void gfxInit() {
-	screenBuffer = (byte *)malloc(320 * 200);
-	page1Raw = (byte *)malloc(320 * 200);
-	page2Raw = (byte *)malloc(320 * 200);
-	page3Raw = (byte *)malloc(320 * 200);
-	if (!screenBuffer || !page1Raw || !page2Raw || !page3Raw) {
-		error("Unable to allocate offscreen buffers");
+/*! \brief Initialize renderer
+ */
+FWRenderer::FWRenderer() : _background(NULL), _palette(NULL), _cmd(""),
+	_cmdY(0), _messageBg(0), _backBuffer(new byte[_screenSize]),
+	_activeLowPal(NULL), _changePal(0) {
+
+	assert(_backBuffer);
+
+	memset(_backBuffer, 0, _screenSize);
+	memset(_bgName, 0, sizeof (_bgName));
+}
+
+/* \brief Destroy renderer
+ */
+FWRenderer::~FWRenderer() {
+	delete[] _background;
+	delete[] _palette;
+	delete[] _backBuffer;
+	delete[] _activeLowPal;
+}
+
+/* \brief Reset renderer state
+ */
+void FWRenderer::clear() {
+	delete[] _background;
+	delete[] _palette;
+	delete[] _activeLowPal;
+
+	_background = NULL;
+	_palette = NULL;
+	_activeLowPal = NULL;
+
+	memset(_backBuffer, 0, _screenSize);
+
+	_cmd = "";
+	_cmdY = 0;
+	_messageBg = 0;
+	_changePal = 0;
+}
+
+/*! \brief Draw 1bpp sprite using selected color
+ * \param obj Object info
+ * \param fillColor Sprite color
+ */
+void FWRenderer::fillSprite(const objectStruct &obj, uint8 color) {
+	const byte *data = animDataTable[obj.frame].data();
+	int x, y, width, height;
+
+	x = obj.x;
+	y = obj.y;
+	width = animDataTable[obj.frame]._realWidth;
+	height = animDataTable[obj.frame]._height;
+
+	gfxFillSprite(data, width, height, _backBuffer, x, y, color);
+}
+
+/*! \brief Draw 1bpp sprite using selected color on background
+ * \param obj Object info
+ * \param fillColor Sprite color
+ */
+void FWRenderer::incrustMask(const objectStruct &obj, uint8 color) {
+	const byte *data = animDataTable[obj.frame].data();
+	int x, y, width, height;
+
+	x = obj.x;
+	y = obj.y;
+	width = animDataTable[obj.frame]._realWidth;
+	height = animDataTable[obj.frame]._height;
+
+	gfxFillSprite(data, width, height, _background, x, y, color);
+}
+
+/*! \brief Draw color sprite using with external mask
+ * \param obj Object info
+ * \param mask External mask
+ */
+void FWRenderer::drawMaskedSprite(const objectStruct &obj, const byte *mask) {
+	const byte *data = animDataTable[obj.frame].data();
+	int x, y, width, height;
+
+	x = obj.x;
+	y = obj.y;
+	width = animDataTable[obj.frame]._realWidth;
+	height = animDataTable[obj.frame]._height;
+
+	assert(mask);
+
+	drawSpriteRaw(data, mask, width, height, _backBuffer, x, y);
+}
+
+/*! \brief Draw color sprite
+ * \param obj Object info
+ */
+void FWRenderer::drawSprite(const objectStruct &obj) {
+	const byte *mask = animDataTable[obj.frame].mask();
+	drawMaskedSprite(obj, mask);
+}
+
+/*! \brief Draw color sprite on background
+ * \param obj Object info
+ */
+void FWRenderer::incrustSprite(const objectStruct &obj) {
+	const byte *data = animDataTable[obj.frame].data();
+	const byte *mask = animDataTable[obj.frame].mask();
+	int x, y, width, height;
+
+	x = obj.x;
+	y = obj.y;
+	width = animDataTable[obj.frame]._realWidth;
+	height = animDataTable[obj.frame]._height;
+
+	assert(mask);
+
+	drawSpriteRaw(data, mask, width, height, _background, x, y);
+}
+
+/*! \brief Draw command box on screen
+ */
+void FWRenderer::drawCommand() {
+	unsigned int i;
+	int x = 10, y = _cmdY;
+
+	drawPlainBox(x, y, 301, 11, 0);
+	drawBorder(x - 1, y - 1, 302, 12, 2);
+
+	x += 2;
+	y += 2;
+
+	for (i = 0; i < _cmd.size(); i++) {
+		x = drawChar(_cmd[i], x, y);
+	}
+}
+
+/*! \brief Draw message in a box
+ * \param str Message to draw
+ * \param x Top left message box corner coordinate
+ * \param y Top left message box corner coordinate
+ * \param width Message box width
+ * \param color Message box background color
+ */
+void FWRenderer::drawMessage(const char *str, int x, int y, int width, byte color) {
+	int i, tx, ty, tw;
+	int line = 0, words = 0, cw = 0;
+	int space = 0, extraSpace = 0;
+
+	drawPlainBox(x, y, width, 4, color);
+	tx = x + 4;
+	ty = str[0] ? y - 5 : y + 4;
+	tw = width - 8;
+
+	for (i = 0; str[i]; i++, line--) {
+		// Fit line of text into textbox
+		if (!line) {
+			while (str[i] == ' ') i++;
+			line = fitLine(str + i, tw, words, cw);
+
+			if ( str[i + line] != '\0' && str[i + line] != 0x7C && words) {
+				space = (tw - cw) / words;
+				extraSpace = (tw - cw) % words;
+			} else {
+				space = 5;
+				extraSpace = 0;
+			}
+
+			ty += 9;
+			drawPlainBox(x, ty, width, 9, color);
+			tx = x + 4;
+		}
+
+		// draw characters
+		if (str[i] == ' ') {
+			tx += space + extraSpace;
+
+			if (extraSpace) {
+				extraSpace = 0;
+			}
+		} else {
+			tx = drawChar(str[i], tx, ty);
+		}
+	}
+
+	ty += 9;
+	drawPlainBox(x, ty, width, 4, color);
+	drawDoubleBorder(x, y, width, ty - y + 4, 2);
+}
+
+/*! \brief Draw rectangle on screen
+ * \param x Top left corner coordinate
+ * \param y Top left corner coordinate
+ * \param width Rectangle width
+ * \param height Rectangle height
+ * \param color Fill color
+ */
+void FWRenderer::drawPlainBox(int x, int y, int width, int height, byte color) {
+	int i;
+	byte *dest = _backBuffer + y * 320 + x;
+
+	if (width < 0) {
+		x += width;
+		width = -width;
+	}
+
+	if (height < 0) {
+		y += height;
+		height = -height;
+	}
+
+	for (i = 0; i < height; i++) {
+		memset(dest + i * 320, color, width);
+	}
+}
+
+/*! \brief Draw empty rectangle
+ * \param x Top left corner coordinate
+ * \param y Top left corner coordinate
+ * \param width Rectangle width
+ * \param height Rectangle height
+ * \param color Line color
+ */
+void FWRenderer::drawBorder(int x, int y, int width, int height, byte color) {
+	drawLine(x, y, width, 1, color);
+	drawLine(x, y + height, width, 1, color);
+	drawLine(x, y, 1, height, color);
+	drawLine(x + width, y, 1, height + 1, color);
+}
+
+/*! \brief Draw empty 2 color rectangle (inner line color is black)
+ * \param x Top left corner coordinate
+ * \param y Top left corner coordinate
+ * \param width Rectangle width
+ * \param height Rectangle height
+ * \param color Outter line color
+ */
+void FWRenderer::drawDoubleBorder(int x, int y, int width, int height, byte color) {
+	drawBorder(x + 1, y + 1, width - 2, height - 2, 0);
+	drawBorder(x, y, width, height, color);
+}
+
+/*! \brief Draw text character on screen
+ * \param character Character to draw
+ * \param x Character coordinate
+ * \param y Character coordinate
+ */
+int FWRenderer::drawChar(char character, int x, int y) {
+	int width, idx;
+
+	if (character == ' ') {
+		x += 5;
+	} else if ((width = fontParamTable[character].characterWidth)) {
+		idx = fontParamTable[character].characterIdx;
+		drawSpriteRaw(textTable[idx][0], textTable[idx][1], 16, 8, _backBuffer, x, y);
+		x += width + 1;
+	}
+
+	return x;
+}
+
+/*! \brief Draw Line
+ * \param x Line end coordinate
+ * \param y Line end coordinate
+ * \param width Horizontal line length
+ * \param height Vertical line length
+ * \param color Line color
+ * \note Either width or height must be equal to 1
+ */
+void FWRenderer::drawLine(int x, int y, int width, int height, byte color) {
+	// this line is a special case of rectangle ;-)
+	drawPlainBox(x, y, width, height, color);
+}
+
+/*! \brief Hide invisible parts of the sprite
+ * \param[in,out] mask Mask to be updated
+ * \param it Overlay info from overlayList
+ */
+void FWRenderer::remaskSprite(byte *mask, Common::List<overlay>::iterator it) {
+	AnimData &sprite = animDataTable[objectTable[it->objIdx].frame];
+	int x, y, width, height, idx;
+	int mx, my, mw, mh;
+
+	x = objectTable[it->objIdx].x;
+	y = objectTable[it->objIdx].y;
+	width = sprite._realWidth;
+	height = sprite._height;
+
+	for (++it; it != overlayList.end(); ++it) {
+		if (it->type != 5) {
+			continue;
+		}
+
+		idx = ABS(objectTable[it->objIdx].frame);
+		mx = objectTable[it->objIdx].x;
+		my = objectTable[it->objIdx].y;
+		mw = animDataTable[idx]._realWidth;
+		mh = animDataTable[idx]._height;
+
+		gfxUpdateSpriteMask(mask, x, y, width, height, animDataTable[idx].data(), mx, my, mw, mh);
+	}
+}
+
+/*! \brief Draw background to backbuffer
+ */
+void FWRenderer::drawBackground() {
+	assert(_background);
+	memcpy(_backBuffer, _background, _screenSize);
+}
+
+/*! \brief Draw one overlay
+ * \param it Overlay info
+ */
+void FWRenderer::renderOverlay(const Common::List<overlay>::iterator &it) {
+	int idx, len, width;
+	objectStruct *obj;
+	AnimData *sprite;
+	byte *mask;
+
+	switch (it->type) {
+	// color sprite
+	case 0:
+		sprite = animDataTable + objectTable[it->objIdx].frame;
+		len = sprite->_realWidth * sprite->_height;
+		mask = new byte[len];
+		memcpy(mask, sprite->mask(), len);
+		remaskSprite(mask, it);
+		drawMaskedSprite(objectTable[it->objIdx], mask);
+		delete[] mask;
+		break;
+
+	// game message
+	case 2:
+		if (it->objIdx >= messageTable.size()) {
+			return;
+		}
+
+		_messageLen += messageTable[it->objIdx].size();
+		drawMessage(messageTable[it->objIdx].c_str(), it->x, it->y, it->width, it->color);
+		break;
+
+	// action failure message
+	case 3:
+		idx = it->objIdx * 4 + g_cine->_rnd.getRandomNumber(3);
+		len = strlen(failureMessages[idx]);
+		_messageLen += len;
+		width = 6 * len + 20;
+		width = width > 300 ? 300 : width;
+
+		drawMessage(failureMessages[idx], (320 - width) / 2, 80, width, 4);
+		break;
+
+	// bitmap
+	case 4:
+		assert(it->objIdx < NUM_MAX_OBJECT);
+		obj = objectTable + it->objIdx;
+
+		if (obj->frame < 0) {
+			return;
+		}
+
+		if (!animDataTable[obj->frame].data()) {
+			return;
+		}
+
+		fillSprite(*obj);
+		break;
+	}
+}
+
+/*! \brief Draw overlays
+ */
+void FWRenderer::drawOverlays() {
+	Common::List<overlay>::iterator it;
+
+	for (it = overlayList.begin(); it != overlayList.end(); ++it) {
+		renderOverlay(it);
+	}
+}
+
+/*! \brief Draw another frame
+ */
+void FWRenderer::drawFrame() {
+	drawBackground();
+	drawOverlays();
+
+	if (!_cmd.empty()) {
+		drawCommand();
+	}
+
+	if (_changePal) {
+		refreshPalette();
+	}
+
+	blit();
+}
+
+/*! \brief Update screen
+ */
+void FWRenderer::blit() {
+	g_system->copyRectToScreen(_backBuffer, 320, 0, 0, 320, 200);
+}
+
+/*! \brief Set player command string
+ * \param cmd New command string
+ */
+void FWRenderer::setCommand(const char *cmd) {
+	_cmd = cmd;
+}
+
+/*! \brief Refresh current palette
+ */
+void FWRenderer::refreshPalette() {
+	int i;
+	byte pal[16*4];
+
+	assert(_activeLowPal);
+
+	for (i = 0; i < 16; i++) {
+		// This seems to match the output from DOSbox.
+		pal[i * 4 + 2] = ((_activeLowPal[i] & 0x00f) >> 0) * 32;
+		pal[i * 4 + 1] = ((_activeLowPal[i] & 0x0f0) >> 4) * 32;
+		pal[i * 4 + 0] = ((_activeLowPal[i] & 0xf00) >> 8) * 32;
+		pal[i * 4 + 3] = 0;
+	}
+
+	g_system->setPalette(pal, 0, 16);
+	_changePal = 0;
+}
+
+/*! \brief Load palette of current background
+ */
+void FWRenderer::reloadPalette() {
+	assert(_palette);
+
+	if (!_activeLowPal) {
+		_activeLowPal = new uint16[_lowPalSize];
 	}
-	memset(page1Raw, 0, 320 * 200);
-	memset(page2Raw, 0, 320 * 200);
-	memset(page3Raw, 0, 320 * 200);
 
-	memset(additionalBgTable, 0, sizeof(additionalBgTable));
-	additionalBgTable[0] = page2Raw;
-	additionalBgTable[8] = page3Raw;
+	assert(_activeLowPal);
+
+	memcpy(_activeLowPal, _palette, _lowPalSize * sizeof (uint16));
+	_changePal = 1;
+}
+
+/*! \brief Load background into renderer
+ * \param bg Raw background data
+ */
+void FWRenderer::loadBg16(const byte *bg, const char *name) {
+	int i;
+
+	if (!_background) {
+		_background = new byte[_screenSize];
+	}
+
+	if (!_palette) {
+		_palette = new uint16[_lowPalSize];
+	}
+
+	assert(_background && _palette);
+
+	strcpy(_bgName, name);
+
+	for (i = 0; i < _lowPalSize; i++, bg += 2) {
+		_palette[i] = READ_BE_UINT16(bg);
+	}
+
+	gfxConvertSpriteToRaw(_background, bg, 160, 200);
+}
+
+/*! \brief Placeholder for Operation Stealth implementation
+ */
+void FWRenderer::loadBg16(const byte *bg, const char *name, unsigned int idx) {
+	error("Future Wars renderer doesn't support multiple backgrounds");
+}
+
+/*! \brief Placeholder for Operation Stealth implementation
+ */
+void FWRenderer::loadCt16(const byte *ct, const char *name) {
+	error("Future Wars renderer doesn't support multiple backgrounds");
+}
+
+/*! \brief Placeholder for Operation Stealth implementation
+ */
+void FWRenderer::loadBg256(const byte *bg, const char *name) {
+	error("Future Wars renderer doesn't support 256 color mode");
+}
+
+/*! \brief Placeholder for Operation Stealth implementation
+ */
+void FWRenderer::loadBg256(const byte *bg, const char *name, unsigned int idx) {
+	error("Future Wars renderer doesn't support multiple backgrounds");
+}
+
+/*! \brief Placeholder for Operation Stealth implementation
+ */
+void FWRenderer::loadCt256(const byte *ct, const char *name) {
+	error("Future Wars renderer doesn't support multiple backgrounds");
+}
+
+/*! \brief Placeholder for Operation Stealth implementation
+ */
+void FWRenderer::selectBg(unsigned int idx) {
+	error("Future Wars renderer doesn't support multiple backgrounds");
 }
 
-void gfxDestroy() {
-	free(screenBuffer);
-	free(page1Raw);
-	free(page2Raw);
-	free(page3Raw);
+/*! \brief Placeholder for Operation Stealth implementation
+ */
+void FWRenderer::selectScrollBg(unsigned int idx) {
+	error("Future Wars renderer doesn't support multiple backgrounds");
+}
+
+/*! \brief Placeholder for Operation Stealth implementation
+ */
+void FWRenderer::setScroll(unsigned int shift) {
+	error("Future Wars renderer doesn't support multiple backgrounds");
+}
+
+/*! \brief Placeholder for Operation Stealth implementation
+ */
+void FWRenderer::removeBg(unsigned int idx) {
+	error("Future Wars renderer doesn't support multiple backgrounds");
+}
+
+void FWRenderer::saveBg(Common::OutSaveFile &fHandle) {
+	fHandle.write(_bgName, 13);
+}
+
+/*! \brief Restore active and backup palette from save
+ * \param fHandle Savefile open for reading
+ */
+void FWRenderer::restorePalette(Common::InSaveFile &fHandle) {
+	int i;
+
+	if (!_palette) {
+		_palette = new uint16[_lowPalSize];
+	}
+
+	if (!_activeLowPal) {
+		_activeLowPal = new uint16[_lowPalSize];
+	}
+
+	assert(_palette && _activeLowPal);
+
+	for (i = 0; i < _lowPalSize; i++) {
+		_activeLowPal[i] = fHandle.readUint16BE();
+	}
+
+	for (i = 0; i < _lowPalSize; i++) {
+		_palette[i] = fHandle.readUint16BE();
+	}
+
+	_changePal = 1;
+}
+
+/*! \brief Write active and backup palette to save
+ * \param fHandle Savefile open for writing
+ */
+void FWRenderer::savePalette(Common::OutSaveFile &fHandle) {
+	int i;
+
+	assert(_palette && _activeLowPal);
+
+	for (i = 0; i < _lowPalSize; i++) {
+		fHandle.writeUint16BE(_activeLowPal[i]);
+	}
+
+	for (i = 0; i < _lowPalSize; i++) {
+		fHandle.writeUint16BE(_palette[i]);
+	}
+}
+
+/*! \brief Rotate active palette
+ * \param a First color to rotate
+ * \param b Last color to rotate
+ * \param c Possibly rotation step, must be equal to 1 at the moment
+ */
+void FWRenderer::rotatePalette(int a, int b, int c) {
+	palRotate(_activeLowPal, a, b, c);
+	refreshPalette();
+}
+
+/*! \brief Copy part of backup palette to active palette and transform
+ * \param first First color to transform
+ * \param last Last color to transform
+ * \param r Red channel transformation
+ * \param g Green channel transformation
+ * \param b Blue channel transformation
+ */
+void FWRenderer::transformPalette(int first, int last, int r, int g, int b) {
+	if (!_activeLowPal) {
+		_activeLowPal = new uint16[_lowPalSize];
+		memset(_activeLowPal, 0, _lowPalSize * sizeof (uint16));
+	}
+
+	transformPaletteRange(_activeLowPal, _palette, first, last, r, g, b);
+	refreshPalette();
+}
+
+/*! \brief Draw menu box, one item per line with possible highlight
+ * \param items Menu items
+ * \param height Item count
+ * \param x Top left menu corner coordinate
+ * \param y Top left menu corner coordinate
+ * \param width Menu box width
+ * \param selected Index of highlighted item (no highlight if less than 0)
+ */
+void FWRenderer::drawMenu(const CommandeType *items, unsigned int height, int x, int y, int width, int selected) {
+	int tx, ty, th = height * 9 + 10;
+	unsigned int i, j;
+
+	if (x + width > 319) {
+		x = 319 - width;
+	}
+
+	if (y + th > 199) {
+		y = 199 - th;
+	}
+
+	drawPlainBox(x, y, width, 4, _messageBg);
+
+	ty = y + 4;
+
+	for (i = 0; i < height; i++, ty += 9) {
+		drawPlainBox(x, ty, width, 9, (int)i == selected ? 0 : _messageBg);
+		tx = x + 4;
+
+		for (j = 0; items[i][j]; j++) {
+			tx = drawChar(items[i][j], tx, ty);
+		}
+	}
+
+	drawPlainBox(x, ty, width, 4, _messageBg);
+	drawDoubleBorder(x, y, width, ty - y + 4, 2);
+}
+
+/*! \brief Draw text input box
+ * \param info Input box message
+ * \param input Text entered in the input area
+ * \param cursor Cursor position in the input area
+ * \param x Top left input box corner coordinate
+ * \param y Top left input box corner coordinate
+ * \param width Input box width
+ */
+void FWRenderer::drawInputBox(const char *info, const char *input, int cursor, int x, int y, int width) {
+	int i, tx, ty, tw;
+	int line = 0, words = 0, cw = 0;
+	int space = 0, extraSpace = 0;
+
+	drawPlainBox(x, y, width, 4, _messageBg);
+	tx = x + 4;
+	ty = info[0] ? y - 5 : y + 4;
+	tw = width - 8;
+
+	// input box info message
+	for (i = 0; info[i]; i++, line--) {
+		// fit line of text
+		if (!line) {
+			line = fitLine(info + i, tw, words, cw);
+
+			if ( info[i + line] != '\0' && words) {
+				space = (tw - cw) / words;
+				extraSpace = (tw - cw) % words;
+			} else {
+				space = 5;
+				extraSpace = 0;
+			}
+
+			ty += 9;
+			drawPlainBox(x, ty, width, 9, _messageBg);
+			tx = x + 4;
+		}
+
+		// draw characters
+		if (info[i] == ' ') {
+			tx += space + extraSpace;
+
+			if (extraSpace) {
+				extraSpace = 0;
+			}
+		} else {
+			tx = drawChar(info[i], tx, ty);
+		}
+	}
+
+	// input area background
+	ty += 9;
+	drawPlainBox(x, ty, width, 9, _messageBg);
+	drawPlainBox(x + 16, ty - 1, width - 32, 9, 0);
+	tx = x + 20;
+
+	// text in input area
+	for (i = 0; input[i]; i++) {
+		tx = drawChar(input[i], tx, ty);
+
+		if (cursor == i + 2) {
+			drawLine(tx, ty - 1, 1, 9, 2);
+		}
+	}
+
+	if (!input[0] || cursor == 1) {
+		drawLine(x + 20, ty - 1, 1, 9, 2);
+	}
+
+	ty += 9;
+	drawPlainBox(x, ty, width, 4, _messageBg);
+	drawDoubleBorder(x, y, width, ty - y + 4, 2);
+}
+
+/*! \brief Fade to black
+ */
+void FWRenderer::fadeToBlack() {
+	assert(_activeLowPal);
+
+	for (int i = 0; i < 8; i++) {
+		for (int j = 0; j < 16; j++) {
+			_activeLowPal[j] = transformColor(_activeLowPal[j], -1, -1, -1);
+		}
+
+		refreshPalette();
+		g_system->updateScreen();
+		g_system->delayMillis(50);
+	}
+}
+
+/*! \brief Initialize Operation Stealth renderer
+ */
+OSRenderer::OSRenderer() : _activeHiPal(NULL), _currentBg(0), _scrollBg(0),
+	_bgShift(0) {
+
+	int i;
+	for (i = 0; i < 9; i++) {
+		_bgTable[i].bg = NULL;
+		_bgTable[i].lowPal = NULL;
+		_bgTable[i].hiPal = NULL;
+		memset(_bgTable[i].name, 0, sizeof (_bgTable[i].name));
+	}
+}
+
+/*! \brief Destroy Operation Stealth renderer
+ */
+OSRenderer::~OSRenderer() {
+	delete[] _activeHiPal;
+
+	for (int i = 0; i < 9; i++) {
+		delete[] _bgTable[i].bg;
+		delete[] _bgTable[i].lowPal;
+		delete[] _bgTable[i].hiPal;
+	}
+}
+
+/*! \brief Reset Operation Stealth renderer state
+ */
+void OSRenderer::clear() {
+	delete[] _activeHiPal;
+	_activeHiPal = NULL;
+
+	for (int i = 0; i < 9; i++) {
+		delete[] _bgTable[i].bg;
+		delete[] _bgTable[i].lowPal;
+		delete[] _bgTable[i].hiPal;
+
+		_bgTable[i].bg = NULL;
+		_bgTable[i].lowPal = NULL;
+		_bgTable[i].hiPal = NULL;
+		memset(_bgTable[i].name, 0, sizeof (_bgTable[i].name));
+	}
+
+	_currentBg = 0;
+	_scrollBg = 0;
+	_bgShift = 0;
+
+	FWRenderer::clear();
+}
+
+/*! \brief Draw 1bpp sprite using selected color on backgrounds
+ * \param obj Object info
+ * \param fillColor Sprite color
+ */
+void OSRenderer::incrustMask(const objectStruct &obj, uint8 color) {
+	const byte *data = animDataTable[obj.frame].data();
+	int x, y, width, height, i;
+
+	x = obj.x;
+	y = obj.y;
+	width = animDataTable[obj.frame]._realWidth;
+	height = animDataTable[obj.frame]._height;
+
+	for (i = 0; i < 8; i++) {
+		if (!_bgTable[i].bg) {
+			continue;
+		}
+
+		gfxFillSprite(data, width, height, _bgTable[i].bg, x, y, color);
+	}
+}
+
+/*! \brief Draw color sprite
+ * \param obj Object info
+ */
+void OSRenderer::drawSprite(const objectStruct &obj) {
+	const byte *data = animDataTable[obj.frame].data();
+	int x, y, width, height, transColor;
+
+	x = obj.x;
+	y = obj.y;
+	transColor = obj.part;
+	width = animDataTable[obj.frame]._realWidth;
+	height = animDataTable[obj.frame]._height;
+
+	drawSpriteRaw2(data, transColor, width, height, _backBuffer, x, y);
+}
+
+/*! \brief Draw color sprite
+ * \param obj Object info
+ */
+void OSRenderer::incrustSprite(const objectStruct &obj) {
+	const byte *data = animDataTable[obj.frame].data();
+	int x, y, width, height, transColor, i;
+
+	x = obj.x;
+	y = obj.y;
+	transColor = obj.part;
+	width = animDataTable[obj.frame]._realWidth;
+	height = animDataTable[obj.frame]._height;
+
+	for (i = 0; i < 8; i++) {
+		if (!_bgTable[i].bg) {
+			continue;
+		}
+
+		drawSpriteRaw2(data, transColor, width, height, _bgTable[i].bg, x, y);
+	}
+}
+
+/*! \brief Draw text character on screen
+ * \param character Character to draw
+ * \param x Character coordinate
+ * \param y Character coordinate
+ */
+int OSRenderer::drawChar(char character, int x, int y) {
+	int width, idx;
+
+	if (character == ' ') {
+		x += 5;
+	} else if ((width = fontParamTable[character].characterWidth)) {
+		idx = fontParamTable[character].characterIdx;
+		drawSpriteRaw2(textTable[idx][0], 0, 16, 8, _backBuffer, x, y);
+		x += width + 1;
+	}
+
+	return x;
+}
+
+/*! \brief Draw background to backbuffer
+ */
+void OSRenderer::drawBackground() {
+	byte *main;
+
+	main = _bgTable[_currentBg].bg;
+	assert(main);
+
+	if (!_bgShift) {
+		memcpy(_backBuffer, main, _screenSize);
+	} else {
+		byte *scroll = _bgTable[_scrollBg].bg;
+		int mainShift = _bgShift * _screenWidth;
+		int mainSize = _screenSize - mainShift;
+
+		assert(scroll);
+
+		memcpy(_backBuffer, main + mainShift, mainSize);
+		memcpy(_backBuffer + mainSize, scroll, mainShift);
+	}
+}
+
+/*! \brief Draw one overlay
+ * \param it Overlay info
+ */
+void OSRenderer::renderOverlay(const Common::List<overlay>::iterator &it) {
+	int len;
+	objectStruct *obj;
+	AnimData *sprite;
+	byte *mask;
+
+	switch (it->type) {
+	// color sprite
+	case 0:
+		sprite = animDataTable + objectTable[it->objIdx].frame;
+		len = sprite->_realWidth * sprite->_height;
+		mask = new byte[len];
+		generateMask(sprite->data(), mask, len, objectTable[it->objIdx].part);
+		remaskSprite(mask, it);
+		drawMaskedSprite(objectTable[it->objIdx], mask);
+		delete[] mask;
+		break;
+
+	// masked background
+	case 20:
+		assert(it->objIdx < NUM_MAX_OBJECT);
+		obj = objectTable + it->objIdx;
+		sprite = animDataTable + obj->frame;
+
+		if (obj->frame < 0 || it->x > 8 || !_bgTable[it->x].bg || sprite->_bpp != 1) {
+			break;
+		}
+
+		maskBgOverlay(_bgTable[it->x].bg, sprite->data(), sprite->_realWidth, sprite->_height, _backBuffer, obj->x, obj->y);
+		break;
+
+	// something else
+	default:
+		FWRenderer::renderOverlay(it);
+		break;
+	}
+}
+
+/*! \brief Refresh current palette
+ */
+void OSRenderer::refreshPalette() {
+	if (!_activeHiPal) {
+		FWRenderer::refreshPalette();
+		return;
+	}
+
+	int i;
+	byte pal[256*4];
+
+	for (i = 0; i < 256; i++) {
+		pal[i * 4 + 0] = _activeHiPal[i * 3 + 0];
+		pal[i * 4 + 1] = _activeHiPal[i * 3 + 1];
+		pal[i * 4 + 2] = _activeHiPal[i * 3 + 2];
+		pal[i * 4 + 3] = 0;
+	}
+
+	g_system->setPalette(pal, 0, 256);
+	_changePal = 0;
+}
+
+/*! \brief Load palette of current background
+ */
+void OSRenderer::reloadPalette() {
+	// selected background in plane takeoff scene has swapped colors 12
+	// and 14, shift background has it right
+	palBg *bg = _bgShift ? &_bgTable[_scrollBg] : &_bgTable[_currentBg];
+
+	assert(bg->lowPal || bg->hiPal);
+
+	if (bg->lowPal) {
+		if (!_activeLowPal) {
+			_activeLowPal = new uint16[_lowPalSize];
+		}
+
+		assert(_activeLowPal);
+
+		delete[] _activeHiPal;
+		_activeHiPal = NULL;
+
+		memcpy(_activeLowPal, bg->lowPal, _lowPalSize * sizeof (uint16));
+	} else {
+		if (!_activeHiPal) {
+			_activeHiPal = new byte[_hiPalSize];
+		}
+
+		assert(_activeHiPal);
+
+		delete[] _activeLowPal;
+		_activeLowPal = NULL;
+
+		memcpy(_activeHiPal, bg->hiPal, _hiPalSize);
+	}
+	_changePal = 1;
+}
+
+/*! \brief Rotate active palette
+ * \param a First color to rotate
+ * \param b Last color to rotate
+ * \param c Possibly rotation step, must be equal to 1 at the moment
+ */
+void OSRenderer::rotatePalette(int a, int b, int c) {
+	if (_activeLowPal) {
+		FWRenderer::rotatePalette(a, b, c);
+		return;
+	}
+
+	palRotate(_activeHiPal, a, b, c);
+	refreshPalette();
+}
+
+/*! \brief Copy part of backup palette to active palette and transform
+ * \param first First color to transform
+ * \param last Last color to transform
+ * \param r Red channel transformation
+ * \param g Green channel transformation
+ * \param b Blue channel transformation
+ */
+void OSRenderer::transformPalette(int first, int last, int r, int g, int b) {
+	palBg *bg = _bgShift ? &_bgTable[_scrollBg] : &_bgTable[_currentBg];
+
+	if (!bg->lowPal) {
+		if (!_activeHiPal) {
+			_activeHiPal = new byte[_hiPalSize];
+			memset(_activeHiPal, 0, _hiPalSize);
+		}
+
+		delete[] _activeLowPal;
+		_activeLowPal = NULL;
+
+		transformPaletteRange(_activeHiPal, bg->hiPal, first, last, r, g, b);
+	} else {
+		if (!_activeLowPal) {
+			_activeLowPal = new uint16[_lowPalSize];
+			memset(_activeLowPal, 0, _lowPalSize * sizeof (uint16));
+		}
+
+		delete[] _activeHiPal;
+		_activeHiPal = NULL;
+
+		transformPaletteRange(_activeLowPal, bg->lowPal, first, last, r, g, b);
+	}
+
+	refreshPalette();
+}
+
+/*! \brief Load 16 color background into renderer
+ * \param bg Raw background data
+ * \param name Background filename
+ */
+void OSRenderer::loadBg16(const byte *bg, const char *name) {
+	loadBg16(bg, name, 0);
+}
+
+/*! \brief Load 16 color background into renderer
+ * \param bg Raw background data
+ * \param name Background filename
+ * \param pos Background index
+ */
+void OSRenderer::loadBg16(const byte *bg, const char *name, unsigned int idx) {
+	int i;
+	assert(idx < 9);
+
+	if (!_bgTable[idx].bg) {
+		_bgTable[idx].bg = new byte[_screenSize];
+	}
+
+	if (!_bgTable[idx].lowPal) {
+		_bgTable[idx].lowPal = new uint16[_lowPalSize];
+	}
+
+	assert(_bgTable[idx].bg && _bgTable[idx].lowPal);
+
+	delete[] _bgTable[idx].hiPal;
+	_bgTable[idx].hiPal = NULL;
+
+	strcpy(_bgTable[idx].name, name);
+
+	for (i = 0; i < _lowPalSize; i++, bg += 2) {
+		_bgTable[idx].lowPal[i] = READ_BE_UINT16(bg);
+	}
+
+	gfxConvertSpriteToRaw(_bgTable[idx].bg, bg, 160, 200);
+}
+
+/*! \brief Load 16 color CT data as background into renderer
+ * \param ct Raw CT data
+ * \param name Background filename
+ */
+void OSRenderer::loadCt16(const byte *ct, const char *name) {
+	loadBg16(ct, name, 8);
+}
+
+/*! \brief Load 256 color background into renderer
+ * \param bg Raw background data
+ * \param name Background filename
+ */
+void OSRenderer::loadBg256(const byte *bg, const char *name) {
+	loadBg256(bg, name, 0);
+}
+
+/*! \brief Load 256 color background into renderer
+ * \param bg Raw background data
+ * \param name Background filename
+ * \param pos Background index
+ */
+void OSRenderer::loadBg256(const byte *bg, const char *name, unsigned int idx) {
+	assert(idx < 9);
+
+	if (!_bgTable[idx].bg) {
+		_bgTable[idx].bg = new byte[_screenSize];
+	}
+
+	if (!_bgTable[idx].hiPal) {
+		_bgTable[idx].hiPal = new byte[_hiPalSize];
+	}
+
+	assert(_bgTable[idx].bg && _bgTable[idx].hiPal);
+
+	delete[] _bgTable[idx].lowPal;
+	_bgTable[idx].lowPal = NULL;
+
+	strcpy(_bgTable[idx].name, name);
+	memcpy(_bgTable[idx].hiPal, bg, _hiPalSize);
+	memcpy(_bgTable[idx].bg, bg + _hiPalSize, _screenSize);
+}
+
+/*! \brief Load 256 color CT data as background into renderer
+ * \param ct Raw CT data
+ * \param name Background filename
+ */
+void OSRenderer::loadCt256(const byte *ct, const char *name) {
+	loadBg256(ct, name, 8);
+}
+
+/*! \brief Select active background and load its palette
+ * \param idx Background index
+ */
+void OSRenderer::selectBg(unsigned int idx) {
+	assert(idx < 9 && _bgTable[idx].bg);
+	assert(_bgTable[idx].lowPal || _bgTable[idx].hiPal);
+
+	_currentBg = idx;
+	reloadPalette();
+}
+
+/*! \brief Select scroll background
+ * \param idx Scroll background index
+ */
+void OSRenderer::selectScrollBg(unsigned int idx) {
+	assert(idx < 9);
+
+	if (_bgTable[idx].bg) {
+		_scrollBg = idx;
+	}
+	reloadPalette();
+}
+
+/*! \brief Set background scroll
+ * \param shift Background scroll in pixels
+ */
+void OSRenderer::setScroll(unsigned int shift) {
+	assert(shift <= 200);
+
+	_bgShift = shift;
+}
+
+/*! \brief Unload background from renderer
+ * \param idx Background to unload
+ */
+void OSRenderer::removeBg(unsigned int idx) {
+	assert(idx > 0 && idx < 9);
+
+	if (_currentBg == idx) {
+		_currentBg = 0;
+	}
+
+	if (_scrollBg == idx) {
+		_scrollBg = 0;
+	}
+
+	delete[] _bgTable[idx].bg;
+	delete[] _bgTable[idx].lowPal;
+	delete[] _bgTable[idx].hiPal;
+	_bgTable[idx].bg = NULL;
+	_bgTable[idx].lowPal = NULL;
+	_bgTable[idx].hiPal = NULL;
+	memset(_bgTable[idx].name, 0, sizeof (_bgTable[idx].name));
+}
+
+/*! \brief Fade to black
+ * \bug Operation Stealth sometimes seems to fade to black using
+ * transformPalette resulting in double fadeout
+ */
+void OSRenderer::fadeToBlack() {
+	if (!_activeHiPal) {
+		FWRenderer::fadeToBlack();
+		return;
+	}
+
+	for (int i = 0; i < 8; i++) {
+		for (int j = 0; j < _hiPalSize; j++) {
+			_activeHiPal[j] = CLIP(_activeHiPal[j] - 32, 0, 255);
+		}
+
+		refreshPalette();
+		g_system->updateScreen();
+		g_system->delayMillis(50);
+	}
 }
 
 void setMouseCursor(int cursor) {
@@ -147,21 +1299,6 @@ void setMouseCursor(int cursor) {
 	}
 }
 
-static uint16 transformColor(uint16 baseColor, int8 r, int8 g, int8 b) {
-	int8 oriR = CLIP( (baseColor & 0x007)       + r, 0, 7);
-	int8 oriG = CLIP(((baseColor & 0x070) >> 4) + g, 0, 7);
-	int8 oriB = CLIP(((baseColor & 0x700) >> 8) + b, 0, 7);
-
-	return oriR | (oriG << 4) | (oriB << 8);
-}
-
-void transformPaletteRange(byte startColor, byte stopColor, int8 r, int8 g, int8 b) {
-	for (byte i = startColor; i <= stopColor; i++) {
-		c_palette[i] = transformColor(tempPalette[i], b, g, r);
-	}
-	//gfxFlipPage(page2);
-}
-
 void gfxFillSprite(const byte *spritePtr, uint16 width, uint16 height, byte *page, int16 x, int16 y, uint8 fillColor) {
 	int16 i, j;
 
@@ -170,17 +1307,12 @@ void gfxFillSprite(const byte *spritePtr, uint16 width, uint16 height, byte *pag
 		destPtr += i * 320;
 
 		for (j = 0; j < width; j++) {
-			if (x + j >= 0 && x + j < 320 && i + y >= 0
-			    && i + y < 200) {
-				if (!*(spritePtr++)) {
-					*(destPtr++) = fillColor;
-				} else {
-					destPtr++;
-				}
-			} else {
-				destPtr++;
-				spritePtr++;
+			if (x + j >= 0 && x + j < 320 && i + y >= 0 && i + y < 200 && !*spritePtr) {
+				*destPtr = fillColor;
 			}
+
+			destPtr++;
+			spritePtr++;
 		}
 	}
 }
@@ -360,53 +1492,7 @@ void gfxConvertSpriteToRaw(byte *dst, const byte *src, uint16 w, uint16 h) {
 	}
 }
 
-void gfxCopyRawPage(byte *source, byte *dest) {
-	memcpy(dest, source, 320 * 200);
-}
-
-void gfxFlipRawPage(byte *frontBuffer) {
-	byte *page = frontBuffer;
-	int x, y, i;
-	byte *pixels = (byte *) screenBuffer;
-	byte c;
-	byte pal[256 * 4];
-
-	for (y = 0; y < 200; y++) {
-		for (x = 0; x < 320; x++) {
-			c = *(page++);
-
-			if (!colorMode256) {
-				c = c & 15;
-			}
-
-			pixels[x + 0 + y * 320] = c;
-		}
-	}
-
-	if (colorMode256) {
-		for (i = 0; i < 256; i++) {
-			pal[i * 4 + 0] = palette256[i * 3 + 0];
-			pal[i * 4 + 1] = palette256[i * 3 + 1];
-			pal[i * 4 + 2] = palette256[i * 3 + 2];
-			pal[i * 4 + 3] = 0;
-		}
-		g_system->setPalette(pal, 0, 256);
-	} else {
-		for (i = 0; i < 16; i++) {
-			// This seems to match the output from DOSbox.
-			pal[i * 4 + 2] = ((c_palette[i] & 0x00f) >> 0) * 32;
-			pal[i * 4 + 1] = ((c_palette[i] & 0x0f0) >> 4) * 32;
-			pal[i * 4 + 0] = ((c_palette[i] & 0xf00) >> 8) * 32;
-			pal[i * 4 + 3] = 0;
-		}
-		g_system->setPalette(pal, 0, 16);
-	}
-
-	g_system->copyRectToScreen(screenBuffer, 320, 0, 0, 320, 200);
-}
-
-void drawSpriteRaw(const byte *spritePtr, const byte *maskPtr, int16 width, int16 height,
-				   byte *page, int16 x, int16 y) {
+void drawSpriteRaw(const byte *spritePtr, const byte *maskPtr, int16 width, int16 height, byte *page, int16 x, int16 y) {
 	int16 i, j;
 
 	// FIXME: Is it a bug if maskPtr == NULL?
@@ -417,9 +1503,8 @@ void drawSpriteRaw(const byte *spritePtr, const byte *maskPtr, int16 width, int1
 		byte *destPtr = page + x + y * 320;
 		destPtr += i * 320;
 
-		for (j = 0; j < width * 8; j++) {
-			if (((g_cine->getGameType() == Cine::GType_FW && (!maskPtr || !(*maskPtr))) || (g_cine->getGameType() == Cine::GType_OS)) && (x + j >= 0
-					&& x + j < 320 && i + y >= 0 && i + y < 200)) {
+		for (j = 0; j < width; j++) {
+			if ((!maskPtr || !(*maskPtr)) && x + j >= 0 && x + j < 320 && i + y >= 0 && i + y < 200) {
 				*(destPtr++) = *(spritePtr++);
 			} else {
 				destPtr++;
@@ -432,21 +1517,19 @@ void drawSpriteRaw(const byte *spritePtr, const byte *maskPtr, int16 width, int1
 	}
 }
 
-void drawSpriteRaw2(const byte *spritePtr, byte transColor, int16 width, int16 height,
-					byte *page, int16 x, int16 y) {
+void drawSpriteRaw2(const byte *spritePtr, byte transColor, int16 width, int16 height, byte *page, int16 x, int16 y) {
 	int16 i, j;
 
 	for (i = 0; i < height; i++) {
 		byte *destPtr = page + x + y * 320;
 		destPtr += i * 320;
 
-		for (j = 0; j < width * 8; j++) {
-			if ((*(spritePtr) != transColor) && (x + j >= 0 && x + j < 320 && i + y >= 0 && i + y < 200)) {
-				*(destPtr++) = *(spritePtr++);
-			} else {
-				destPtr++;
-				spritePtr++;
+		for (j = 0; j < width; j++) {
+			if ((*spritePtr != transColor) && (x + j >= 0 && x + j < 320 && i + y >= 0 && i + y < 200)) {
+				*destPtr = *spritePtr;
 			}
+			destPtr++;
+			spritePtr++;
 		}
 	}
 }
@@ -499,93 +1582,4 @@ void maskBgOverlay(const byte *bgPtr, const byte *maskPtr, int16 width, int16 he
 	}
 }
 
-/*! \todo Fix rendering to prevent fadein artifacts
- */
-void fadeFromBlack() {
-	int i, j;
-	int r, g, b, tr, tg, tb;
-	if (newColorMode == 2) {
-		colorMode256 = 1;
-		memset(palette256, 0, 256*3);
-	} else if (newColorMode == 1) {
-		colorMode256 = 0;
-		memset(c_palette, 0, 16 * sizeof(uint16));
-	}
-
-	for (i = 0; i < 8; i++ ) {
-		gfxFlipRawPage(page1Raw);
-		g_system->updateScreen();
-		g_system->delayMillis(50);
-
-		if (colorMode256) {
-			for (j = 0; j < 256*3; j++) {
-				r = palette256[j] + (newPalette[j] + 7) / 8;
-				palette256[j] = CLIP(r, 0, (int)newPalette[j]);
-			}
-		} else {
-			for (j = 0; j < 16; j++) {
-				r = c_palette[j] & 0xf;
-				g = (c_palette[j] & 0xf0) >> 4;
-				b = (c_palette[j] & 0xf00) >> 8;
-
-				tr = tempPalette[j] & 0xf;
-				tg = (tempPalette[j] & 0xf0) >> 4;
-				tb = (tempPalette[j] & 0xf00) >> 8;
-
-				r = CLIP(r + (tr + 7) / 8, 0, tr);
-				g = CLIP(g + (tg + 7) / 8, 0, tg);
-				b = CLIP(b + (tb + 7) / 8, 0, tb);
-
-				c_palette[j] = r | (g << 4) | (b << 8);
-			}
-
-		}
-	}
-
-	if (colorMode256) {
-		memcpy(palette256, newPalette, 256*3);
-	} else {
-		memcpy(c_palette, tempPalette, sizeof(uint16) * 16);
-	}
-}
-
-void fadeToBlack() {
-	for (int i = 0; i < 8; i++) {
-		if (colorMode256) {
-			for (int j = 0; j < 256*3; j++) {
-				palette256[j] = CLIP(palette256[j] - 32, 0, 255);
-			}
-		} else {
-			for (int j = 0; j < 16; j++) {
-				c_palette[j] = transformColor(c_palette[j], -1, -1, -1);
-			}
-		}
-		gfxFlipRawPage(page1Raw);
-		g_system->updateScreen();
-		g_system->delayMillis(50);
-	}
-}
-
-void blitRawScreen(byte *frontBuffer) {
-	gfxFlipRawPage(frontBuffer);
-}
-
-void flip(void) {
-	blitRawScreen(page1Raw);
-	if (fadeRequired) {
-		if (newColorMode == 3) {
-			newColorMode = ctColorMode + 1;
-		}
-
-		if (newColorMode == 2) {
-			colorMode256 = 1;
-			memcpy(palette256, newPalette, 256*3);
-		} else {
-			colorMode256 = 0;
-			memcpy(c_palette, tempPalette, sizeof(uint16) * 16);
-		}
-		fadeRequired = false;
-	}
-}
-
 } // End of namespace Cine
diff --git a/engines/cine/gfx.h b/engines/cine/gfx.h
index 3812b52113..c63c79ac82 100644
--- a/engines/cine/gfx.h
+++ b/engines/cine/gfx.h
@@ -26,24 +26,158 @@
 #ifndef CINE_GFX_H
 #define CINE_GFX_H
 
+#include "common/noncopyable.h"
+#include "cine/object.h"
+
 namespace Cine {
 
+/*! \brief Background with palette
+ */
+struct palBg {
+	byte *bg; ///< Background data
+	byte *hiPal; ///< 256 color palette
+	uint16 *lowPal; ///< 16 color palette
+	char name[15]; ///< Background filename
+};
+
+/*! \brief Future Wars renderer
+ *
+ * Screen backbuffer is not cleared between frames, you can draw menus etc.
+ * without calling drawFrame() all the time
+ */
+class FWRenderer : public Common::NonCopyable {
+private:
+	byte *_background; ///< Current background
+	char _bgName[13]; ///< Background filename
+	uint16 *_palette; ///< 16 color backup palette
+
+	Common::String _cmd; ///< Player command string
+
+protected:
+	static const int _screenSize = 320 * 200; ///< Screen size
+	static const int _screenWidth = 320; ///< Screen width
+	static const int _screenHeight = 200; ///< Screen height
+	static const int _lowPalSize = 16; ///< 16 color palette size
+
+	byte *_backBuffer; ///< Screen backbuffer
+	uint16 *_activeLowPal; ///< Active 16 color palette
+	int _changePal; ///< Load active palette to video backend on next frame
+
+	void fillSprite(const objectStruct &obj, uint8 color = 0);
+	void drawMaskedSprite(const objectStruct &obj, const byte *mask);
+	virtual void drawSprite(const objectStruct &obj);
+
+	void drawCommand();
+	void drawMessage(const char *str, int x, int y, int width, byte color);
+	void drawPlainBox(int x, int y, int width, int height, byte color);
+	void drawBorder(int x, int y, int width, int height, byte color);
+	void drawDoubleBorder(int x, int y, int width, int height, byte color);
+	virtual int drawChar(char character, int x, int y);
+	void drawLine(int x, int y, int width, int height, byte color);
+	void remaskSprite(byte *mask, Common::List<overlay>::iterator it);
+	virtual void drawBackground();
+
+	virtual void renderOverlay(const Common::List<overlay>::iterator &it);
+	void drawOverlays();
+
+public:
+	uint16 _messageBg; ///< Message box background color
+	uint16 _cmdY; ///< Player command string position on screen
+
+	FWRenderer();
+	virtual ~FWRenderer();
+
+	/*! \brief Test if renderer is ready to draw */
+	virtual bool ready() { return _background != NULL; }
+
+	virtual void clear();
+
+	void drawFrame();
+	void blit();
+	void setCommand(const char *cmd);
+
+	virtual void incrustMask(const objectStruct &obj, uint8 color = 0);
+	virtual void incrustSprite(const objectStruct &obj);
+
+	virtual void loadBg16(const byte *bg, const char *name);
+	virtual void loadBg16(const byte *bg, const char *name, unsigned int idx);
+	virtual void loadCt16(const byte *ct, const char *name);
+	virtual void loadBg256(const byte *bg, const char *name);
+	virtual void loadBg256(const byte *bg, const char *name, unsigned int idx);
+	virtual void loadCt256(const byte *ct, const char *name);
+	virtual void selectBg(unsigned int idx);
+	virtual void selectScrollBg(unsigned int idx);
+	virtual void setScroll(unsigned int shift);
+	virtual void removeBg(unsigned int idx);
+	void saveBg(Common::OutSaveFile &fHandle);
+
+	virtual void refreshPalette();
+	virtual void reloadPalette();
+	void restorePalette(Common::InSaveFile &fHandle);
+	void savePalette(Common::OutSaveFile &fHandle);
+	virtual void rotatePalette(int a, int b, int c);
+	virtual void transformPalette(int first, int last, int r, int g, int b);
+
+	void drawMenu(const CommandeType *items, unsigned int height, int x, int y, int width, int selected);
+	void drawInputBox(const char *info, const char *input, int cursor, int x, int y, int width);
+
+	virtual void fadeToBlack();
+};
+
+/*! \brief Operation Stealth renderer
+ */
+class OSRenderer : public FWRenderer {
+private:
+	palBg _bgTable[9]; ///< Table of backgrounds loaded into renderer
+	byte *_activeHiPal; ///< Active 256 color palette
+	unsigned int _currentBg; ///< Current background
+	unsigned int _scrollBg; ///< Current scroll background
+	unsigned int _bgShift; ///< Background shift
+
+protected:
+	static const int _hiPalSize = 256 * 3; ///< 256 color palette size
+
+	void drawSprite(const objectStruct &obj);
+	int drawChar(char character, int x, int y);
+	void drawBackground();
+	void renderOverlay(const Common::List<overlay>::iterator &it);
+
+public:
+	OSRenderer();
+	~OSRenderer();
+
+	/*! \brief Test if renderer is ready to draw */
+	bool ready() { return _bgTable[_currentBg].bg != NULL; }
+
+	void clear();
+
+	void incrustMask(const objectStruct &obj, uint8 color = 0);
+	void incrustSprite(const objectStruct &obj);
+
+	void loadBg16(const byte *bg, const char *name);
+	void loadBg16(const byte *bg, const char *name, unsigned int idx);
+	void loadCt16(const byte *ct, const char *name);
+	void loadBg256(const byte *bg, const char *name);
+	void loadBg256(const byte *bg, const char *name, unsigned int idx);
+	void loadCt256(const byte *ct, const char *name);
+	void selectBg(unsigned int idx);
+	void selectScrollBg(unsigned int idx);
+	void setScroll(unsigned int shift);
+	void removeBg(unsigned int idx);
+
+	void refreshPalette();
+	void reloadPalette();
+	void rotatePalette(int a, int b, int c);
+	void transformPalette(int first, int last, int r, int g, int b);
+
+	void fadeToBlack();
+};
+
 void gfxDrawSprite(byte *src4, uint16 sw, uint16 sh, byte *dst4, int16 sx, int16 sy);
 
-extern byte *page1Raw;
-extern byte *page2Raw;
 extern byte *page3Raw;
+extern FWRenderer *renderer;
 
-extern uint16 c_palette[256];
-extern byte colorMode256;
-extern byte palette256[256 * 3];
-extern byte newPalette[256 * 3];
-extern byte newColorMode;
-extern byte ctColorMode;
-extern byte bgColorMode;
-
-void gfxInit();
-void gfxDestroy();
 void setMouseCursor(int cursor);
 void gfxCopyPage(byte *source, byte *dest);
 
diff --git a/engines/cine/main_loop.cpp b/engines/cine/main_loop.cpp
index 098ce84ae5..0c5096c0d6 100644
--- a/engines/cine/main_loop.cpp
+++ b/engines/cine/main_loop.cpp
@@ -182,7 +182,6 @@ int getKeyData() {
 void CineEngine::mainLoop(int bootScriptIdx) {
 	bool playerAction;
 	uint16 quitFlag;
-	uint16 i;
 	byte di;
 	uint16 mouseButton;
 
@@ -190,7 +189,6 @@ void CineEngine::mainLoop(int bootScriptIdx) {
 	exitEngine = 0;
 
 	if (_preLoad == false) {
-		resetSeqList();
 		resetBgIncrustList();
 
 		setTextWindow(0, 0, 20, 200);
@@ -224,17 +222,10 @@ void CineEngine::mainLoop(int bootScriptIdx) {
 			globalVars[VAR_LOW_MEMORY] = 0; // set to 1 to disable some animations, sounds etc.
 		}
 
-		for (i = 0; i < 16; i++) {
-			c_palette[i] = 0;
-		}
-
-		_paletteNeedUpdate = true;
-
 		strcpy(newPrcName, "");
 		strcpy(newRelName, "");
 		strcpy(newObjectName, "");
 		strcpy(newMsgName, "");
-		strcpy(currentBgName[0], "");
 		strcpy(currentCtName, "");
 		strcpy(currentPartName, "");
 
@@ -258,8 +249,9 @@ void CineEngine::mainLoop(int bootScriptIdx) {
 			setMouseCursor(MOUSE_CURSOR_CROSS);
 		}
 
-		drawOverlays();
-		flip();
+		if (renderer->ready()) {
+			renderer->drawFrame();
+		}
 
 		if (waitForPlayerClick) {
 			playerAction = false;
@@ -290,6 +282,8 @@ void CineEngine::mainLoop(int bootScriptIdx) {
 			} while (mouseButton != 0);
 
 			waitForPlayerClick = 0;
+
+			removeMessages();
 		}
 
 		if (checkForPendingDataLoadSwitch) {
diff --git a/engines/cine/object.cpp b/engines/cine/object.cpp
index 36f7b17a69..89d6b99592 100644
--- a/engines/cine/object.cpp
+++ b/engines/cine/object.cpp
@@ -236,6 +236,10 @@ uint16 compareObjectParam(byte objIdx, byte type, int16 value) {
 	return compareResult;
 }
 
+/*! \bug In Operation Stealth, if you try to go downstairs to the sea in the
+ * location between bank and hotel, getObjectParam is called with paramIdx 16
+ * and crashes
+ */
 int16 getObjectParam(uint16 objIdx, uint16 paramIdx) {
 	assert(objIdx <= NUM_MAX_OBJECT);
 
diff --git a/engines/cine/pal.cpp b/engines/cine/pal.cpp
index 9341563898..3e6f5adf40 100644
--- a/engines/cine/pal.cpp
+++ b/engines/cine/pal.cpp
@@ -28,8 +28,6 @@
 
 namespace Cine {
 
-uint16 tempPalette[256];
-
 uint16 palEntriesCount;
 
 PalEntry *palPtr = NULL;
@@ -113,4 +111,64 @@ void loadRelatedPalette(const char *fileName) {
 	}
 }
 
+void palRotate(uint16 *pal, byte a, byte b, byte c) {
+	assert(pal);
+
+	if (c == 1) {
+		uint16 currentColor = pal[b];
+
+		for (int i = b; i > a; i--) {
+			pal[i] = pal[i - 1];
+		}
+
+		pal[a] = currentColor;
+	}
+}
+
+void palRotate(byte *pal, byte a, byte b, byte c) {
+	assert(pal);
+
+	if (c == 1) {
+		byte currentR = pal[3 * b + 0];
+		byte currentG = pal[3 * b + 1];
+		byte currentB = pal[3 * b + 2];
+
+		for (int i = b; i > a; i--) {
+			pal[3 * i + 0] = pal[3 * (i - 1) + 0];
+			pal[3 * i + 1] = pal[3 * (i - 1) + 1];
+			pal[3 * i + 2] = pal[3 * (i - 1) + 2];
+		}
+
+		pal[3 * a + 0] = currentR;
+		pal[3 * a + 1] = currentG;
+		pal[3 * a + 2] = currentB;
+	}
+}
+
+uint16 transformColor(uint16 baseColor, int r, int g, int b) {
+	int8 oriR = CLIP( (baseColor & 0x007)       + b, 0, 7);
+	int8 oriG = CLIP(((baseColor & 0x070) >> 4) + g, 0, 7);
+	int8 oriB = CLIP(((baseColor & 0x700) >> 8) + r, 0, 7);
+
+	return oriR | (oriG << 4) | (oriB << 8);
+}
+
+void transformPaletteRange(uint16 *dstPal, uint16 *srcPal, int startColor, int stopColor, int r, int g, int b) {
+	assert(srcPal && dstPal);
+
+	for (int i = startColor; i <= stopColor; i++) {
+		dstPal[i] = transformColor(srcPal[i], r, g, b);
+	}
+}
+
+void transformPaletteRange(byte *dstPal, byte *srcPal, int startColor, int stopColor, int r, int g, int b) {
+	assert(srcPal && dstPal);
+
+	for (int i = startColor; i <= stopColor; i++) {
+		dstPal[3 * i + 0] = CLIP(srcPal[3 * i + 0] + r * 32, 0, 255);
+		dstPal[3 * i + 1] = CLIP(srcPal[3 * i + 1] + g * 32, 0, 255);
+		dstPal[3 * i + 2] = CLIP(srcPal[3 * i + 2] + b * 32, 0, 255);
+	}
+}
+
 } // End of namespace Cine
diff --git a/engines/cine/pal.h b/engines/cine/pal.h
index da822fa1a1..70fcc0d98a 100644
--- a/engines/cine/pal.h
+++ b/engines/cine/pal.h
@@ -36,10 +36,14 @@ struct PalEntry {
 
 void loadPal(const char *fileName);
 
-extern uint16 tempPalette[256];
-
 void loadRelatedPalette(const char *fileName);
 
+void palRotate(uint16 *pal, byte a, byte b, byte c);
+void palRotate(byte *pal, byte a, byte b, byte c);
+uint16 transformColor(uint16 baseColor, int r, int g, int b);
+void transformPaletteRange(uint16 *srcPal, uint16 *dstPal, int startColor, int stopColor, int r, int g, int b);
+void transformPaletteRange(byte *srcPal, byte *dstPal, int startColor, int stopColor, int r, int g, int b);
+
 } // End of namespace Cine
 
 #endif
diff --git a/engines/cine/prc.cpp b/engines/cine/prc.cpp
index 0f068a197e..402c97b1a6 100644
--- a/engines/cine/prc.cpp
+++ b/engines/cine/prc.cpp
@@ -98,10 +98,10 @@ void loadPrc(const char *pPrcName) {
 		char buffer[256];
 
 		for (s = 0; s < numScripts; s++) {
-			if (scriptTable[s].size) {
+			if (scriptTable[s]->_size) {
 				sprintf(buffer, "%s_%03d.txt", pPrcName, s);
 
-				decompileScript(scriptTable[s].ptr, scriptTable[s].stack, scriptTable[s].size, s);
+				decompileScript((const byte *)scriptTable[s]->getString(0), scriptTable[s]->_size, s);
 				dumpScript(buffer);
 			}
 		}
diff --git a/engines/cine/rel.cpp b/engines/cine/rel.cpp
index f550efed27..dd2d0f68b6 100644
--- a/engines/cine/rel.cpp
+++ b/engines/cine/rel.cpp
@@ -81,10 +81,10 @@ void loadRel(char *pRelName) {
 		char buffer[256];
 
 		for (s = 0; s < numEntry; s++) {
-			if (relTable[s].size) {
+			if (relTable[s]->_size) {
 				sprintf(buffer, "%s_%03d.txt", pRelName, s);
 
-				decompileScript(relTable[s].data, NULL, relTable[s].size, s);
+				decompileScript((const byte *)relTable[s]->getString(0), relTable[s]->_size, s);
 				dumpScript(buffer);
 			}
 		}
diff --git a/engines/cine/script.h b/engines/cine/script.h
index 4a2e7072ee..23bb179ee5 100644
--- a/engines/cine/script.h
+++ b/engines/cine/script.h
@@ -230,6 +230,7 @@ protected:
 	int o1_unloadMask5();
 
 	// pointers to member functions in C++ suck...
+	int o2_loadCt();
 	int o2_loadPart();
 	int o2_addSeqListElement();
 	int o2_removeSeq();
@@ -362,7 +363,7 @@ extern ScriptVars globalVars;
 
 void setupOpcodes();
 
-void decompileScript(byte *scriptPtr, int16 *stackPtr, uint16 scriptSize, uint16 scriptIdx);
+void decompileScript(const byte *scriptPtr, uint16 scriptSize, uint16 scriptIdx);
 void dumpScript(char *dumpName);
 
 #define OP_loadPart                     0x3F
diff --git a/engines/cine/script_fw.cpp b/engines/cine/script_fw.cpp
index f833d7c30b..4f6749517e 100644
--- a/engines/cine/script_fw.cpp
+++ b/engines/cine/script_fw.cpp
@@ -41,11 +41,6 @@ namespace Cine {
 ScriptVars globalVars(NUM_MAX_VAR);
 
 uint16 compareVars(int16 a, int16 b);
-void palRotate(byte a, byte b, byte c);
-void removeSeq(uint16 param1, uint16 param2, uint16 param3);
-uint16 isSeqRunning(uint16 param1, uint16 param2, uint16 param3);
-void addGfxElementA0(int16 param1, int16 param2);
-void removeGfxElementA0(int16 idx, int16 param);
 
 const Opcode FWScript::_opcodeTable[] = {
 	/* 00 */
@@ -1299,7 +1294,7 @@ int FWScript::o1_loadCt() {
 	const char *param = getNextString();
 
 	debugC(5, kCineDebugScript, "Line: %d: loadCt(\"%s\")", _line, param);
-	loadCt(param);
+	loadCtFW(param);
 	return 0;
 }
 
@@ -1355,31 +1350,29 @@ int FWScript::o1_blitAndFade() {
 	debugC(5, kCineDebugScript, "Line: %d: request fadein", _line);
 	// TODO: use real code
 
-	drawOverlays();
-	fadeRequired = true;
-	flip();
-
 //	fadeFromBlack();
+
+	renderer->reloadPalette();
 	return 0;
 }
 
 int FWScript::o1_fadeToBlack() {
 	debugC(5, kCineDebugScript, "Line: %d: request fadeout", _line);
 
-	fadeToBlack();
+	renderer->fadeToBlack();
 	return 0;
 }
 
 int FWScript::o1_transformPaletteRange() {
 	byte startColor = getNextByte();
 	byte numColor = getNextByte();
-	uint16 r = getNextWord();
-	uint16 g = getNextWord();
-	uint16 b = getNextWord();
+	int16 r = getNextWord();
+	int16 g = getNextWord();
+	int16 b = getNextWord();
 
 	debugC(5, kCineDebugScript, "Line: %d: transformPaletteRange(from:%d,numIdx:%d,r:%d,g:%d,b:%d)", _line, startColor, numColor, r, g, b);
 
-	transformPaletteRange(startColor, numColor, r, g, b);
+	renderer->transformPalette(startColor, numColor, r, g, b);
 	return 0;
 }
 
@@ -1387,7 +1380,8 @@ int FWScript::o1_setDefaultMenuColor2() {
 	byte param = getNextByte();
 
 	debugC(5, kCineDebugScript, "Line: %d: setDefaultMenuColor2(%d)", _line, param);
-	defaultMenuBoxColor2 = param;
+
+	renderer->_messageBg = param;
 	return 0;
 }
 
@@ -1397,7 +1391,8 @@ int FWScript::o1_palRotate() {
 	byte c = getNextByte();
 
 	debugC(5, kCineDebugScript, "Line: %d: palRotate(%d,%d,%d)", _line, a, b, c);
-	palRotate(a, b, c);
+
+	renderer->rotatePalette(a, b, c);
 	return 0;
 }
 
@@ -1475,11 +1470,7 @@ int FWScript::o1_compareGlobalVar() {
 
 		debugC(5, kCineDebugScript, "Line: %d: compare globalVars[%d] and %d", _line, varIdx, value);
 
-		if (varIdx == 255 && (g_cine->getGameType() == Cine::GType_FW)) {	// TODO: fix
-			_compare = 1;
-		} else {
-			_compare = compareVars(_globalVars[varIdx], value);
-		}
+		_compare = compareVars(_globalVars[varIdx], value);
 	}
 
 	return 0;
@@ -1558,7 +1549,8 @@ int FWScript::o1_setDefaultMenuColor() {
 	byte param = getNextByte();
 
 	debugC(5, kCineDebugScript, "Line: %d: setDefaultMenuColor(%d)", _line, param);
-	defaultMenuBoxColor = param;
+
+	renderer->_cmdY = param;
 	return 0;
 }
 
@@ -1728,18 +1720,6 @@ int FWScript::o1_unloadMask5() {
 
 //-----------------------------------------------------------------------
 
-void palRotate(byte a, byte b, byte c) {
-	if (c == 1) {
-		uint16 currentColor = c_palette[b];
-
-		for (int16 i = b; i > a; i--) {
-			c_palette[i] = c_palette[i - 1];
-		}
-
-		c_palette[a] = currentColor;
-	}
-}
-
 void addScriptToList0(uint16 idx) {
 	ScriptPtr tmp(scriptInfo->create(*scriptTable[idx], idx));
 	assert(tmp);
@@ -1863,14 +1843,13 @@ const char *getObjPramName(byte paramIdx) {
 	}
 }
 
-void decompileScript(byte *scriptPtr, int16 *stackPtr, uint16 scriptSize, uint16 scriptIdx) {
+void decompileScript(const byte *scriptPtr, uint16 scriptSize, uint16 scriptIdx) {
 	char lineBuffer[256];
-	byte *localScriptPtr = scriptPtr;
+	const byte *localScriptPtr = scriptPtr;
 	uint16 exitScript;
 	uint32 position = 0;
 
 	assert(scriptPtr);
-	// assert(stackPtr);
 
 	exitScript = 0;
 
@@ -2292,7 +2271,7 @@ void decompileScript(byte *scriptPtr, int16 *stackPtr, uint16 scriptSize, uint16
 					sprintf(lineBuffer, "loadPart(%s)\n", localScriptPtr + position);
 				}
 
-				position += strlen((char *)localScriptPtr + position) + 1;
+				position += strlen((const char *)localScriptPtr + position) + 1;
 				break;
 			}
 		case 0x40:
@@ -2309,7 +2288,7 @@ void decompileScript(byte *scriptPtr, int16 *stackPtr, uint16 scriptSize, uint16
 
 				sprintf(lineBuffer, "loadPrc(%d,%s)\n", param, localScriptPtr + position);
 
-				position += strlen((char *)localScriptPtr + position) + 1;
+				position += strlen((const char *)localScriptPtr + position) + 1;
 				break;
 			}
 		case OP_requestCheckPendingDataLoad:	// nop
@@ -2461,7 +2440,7 @@ void decompileScript(byte *scriptPtr, int16 *stackPtr, uint16 scriptSize, uint16
 			{
 				sprintf(lineBuffer, "comment: %s\n", localScriptPtr + position);
 
-				position += strlen((char *)localScriptPtr + position);
+				position += strlen((const char *)localScriptPtr + position);
 				break;
 			}
 		case 0x5A:
@@ -2540,7 +2519,7 @@ void decompileScript(byte *scriptPtr, int16 *stackPtr, uint16 scriptSize, uint16
 			{
 				sprintf(lineBuffer, "loadDat(%s)\n", localScriptPtr + position);
 
-				position += strlen((char *)localScriptPtr + position) + 1;
+				position += strlen((const char *)localScriptPtr + position) + 1;
 				break;
 			}
 		case 0x6E:	// nop
@@ -2801,7 +2780,7 @@ void decompileScript(byte *scriptPtr, int16 *stackPtr, uint16 scriptSize, uint16
 
 				sprintf(lineBuffer, "ADDBG(%d,%s)\n", param1, localScriptPtr + position);
 
-				position += strlen((char *)localScriptPtr + position);
+				position += strlen((const char *)localScriptPtr + position);
 
 				break;
 			}
@@ -2825,7 +2804,7 @@ void decompileScript(byte *scriptPtr, int16 *stackPtr, uint16 scriptSize, uint16
 
 				sprintf(lineBuffer, "loadABS(%d,%s)\n", param1, localScriptPtr + position);
 
-				position += strlen((char *)localScriptPtr + position);
+				position += strlen((const char *)localScriptPtr + position);
 
 				break;
 			}
diff --git a/engines/cine/script_os.cpp b/engines/cine/script_os.cpp
index 1f5ea2b838..7c88e3ffe3 100644
--- a/engines/cine/script_os.cpp
+++ b/engines/cine/script_os.cpp
@@ -73,7 +73,7 @@ const Opcode OSScript::_opcodeTable[] = {
 	{ &FWScript::o1_loadMask4, "b" },
 	{ &FWScript::o1_unloadMask4, "b" },
 	{ &FWScript::o1_addSpriteFilledToBgList, "b" },
-	{ &FWScript::o1_op1B, "" },
+	{ &FWScript::o1_op1B, "" }, /* TODO: Name this opcode properly. */
 	/* 1C */
 	{ 0, 0 },
 	{ &FWScript::o1_label, "l" },
@@ -116,7 +116,7 @@ const Opcode OSScript::_opcodeTable[] = {
 	{ &FWScript::o1_loadAnim, "s" },
 	/* 3C */
 	{ &FWScript::o1_loadBg, "s" },
-	{ &FWScript::o1_loadCt, "s" },
+	{ &FWScript::o2_loadCt, "s" },
 	{ 0, 0 },
 	{ &FWScript::o2_loadPart, "s" },
 	/* 40 */
@@ -173,7 +173,7 @@ const Opcode OSScript::_opcodeTable[] = {
 	{ &FWScript::o1_setDefaultMenuColor, "b" },
 	{ &FWScript::o1_allowPlayerInput, "" },
 	{ &FWScript::o1_disallowPlayerInput, "" },
-	{ &FWScript::o1_changeDataDisk, "b" },
+	{ &FWScript::o1_changeDataDisk, "b" }, /* Same as opcodes 0x95 and 0xA9. */
 	/* 6C */
 	{ 0, 0 },
 	{ &FWScript::o1_loadMusic, "s" },
@@ -181,9 +181,9 @@ const Opcode OSScript::_opcodeTable[] = {
 	{ &FWScript::o1_fadeOutMusic, "" },
 	/* 70 */
 	{ &FWScript::o1_stopSample, "" },
-	{ &FWScript::o1_op71, "bw" },
-	{ &FWScript::o1_op72, "wbw" },
-	{ &FWScript::o1_op72, "wbw" },
+	{ &FWScript::o1_op71, "bw" }, /* TODO: Name this opcode properly. */
+	{ &FWScript::o1_op72, "wbw" }, /* Same as opcode 0x73. TODO: Name this opcode properly. */
+	{ &FWScript::o1_op72, "wbw" }, /* Same as opcode 0x72. */
 	/* 74 */
 	{ 0, 0 },
 	{ 0, 0 },
@@ -193,7 +193,7 @@ const Opcode OSScript::_opcodeTable[] = {
 	{ &FWScript::o2_playSampleAlt, "bbwbww" },
 	{ &FWScript::o1_disableSystemMenu, "b" },
 	{ &FWScript::o1_loadMask5, "b" },
-	{ &FWScript::o1_unloadMask5, "b" },
+	{ &FWScript::o1_unloadMask5, "b" }, /* Last opcode used by Future Wars. */
 	/* 7C */
 	{ 0, 0 },
 	{ 0, 0 },
@@ -201,8 +201,8 @@ const Opcode OSScript::_opcodeTable[] = {
 	{ &FWScript::o2_addSeqListElement, "bbbbwww" },
 	/* 80 */
 	{ &FWScript::o2_removeSeq, "bb" },
-	{ &FWScript::o2_op81, "" },
-	{ &FWScript::o2_op82, "bbw" },
+	{ &FWScript::o2_op81, "" }, /* TODO: Name this opcode properly. */
+	{ &FWScript::o2_op82, "bbwwb" }, /* TODO: Name this opcode properly. */
 	{ &FWScript::o2_isSeqRunning, "bb" },
 	/* 84 */
 	{ &FWScript::o2_gotoIfSupNearest, "b" },
@@ -216,7 +216,7 @@ const Opcode OSScript::_opcodeTable[] = {
 	{ &FWScript::o2_startObjectScript, "b" },
 	/* 8C */
 	{ &FWScript::o2_stopObjectScript, "b" },
-	{ &FWScript::o2_op8D, "wwwwwwww" },
+	{ &FWScript::o2_op8D, "wwwwwwww" }, /* TODO: Name this opcode properly. */
 	{ &FWScript::o2_addBackground, "bs" },
 	{ &FWScript::o2_removeBackground, "b" },
 	/* 90 */
@@ -226,32 +226,32 @@ const Opcode OSScript::_opcodeTable[] = {
 	{ 0, 0 },
 	/* 94 */
 	{ 0, 0 },
-	{ &FWScript::o1_changeDataDisk, "b" },
+	{ &FWScript::o1_changeDataDisk, "b" }, /* Same as opcodes 0x6B and 0xA9. */
 	{ 0, 0 },
 	{ 0, 0 },
 	/* 98 */
 	{ 0, 0 },
 	{ 0, 0 },
-	{ &FWScript::o2_wasZoneChecked, "" },
-	{ &FWScript::o2_op9B, "wwwwwwww" },
+	{ &FWScript::o2_wasZoneChecked, "b" },
+	{ &FWScript::o2_op9B, "wwwwwwww" }, /* TODO: Name this opcode properly. */
 	/* 9C */
-	{ &FWScript::o2_op9C, "wwww" },
+	{ &FWScript::o2_op9C, "wwww" }, /* TODO: Name this opcode properly. */
 	{ &FWScript::o2_useBgScroll, "b" },
 	{ &FWScript::o2_setAdditionalBgVScroll, "c" },
-	{ &FWScript::o2_op9F, "ww" },
+	{ &FWScript::o2_op9F, "ww" }, /* TODO: Name this opcode properly. */
 	/* A0 */
-	{ &FWScript::o2_addGfxElementA0, "ww" },
-	{ &FWScript::o2_removeGfxElementA0, "ww" },
-	{ &FWScript::o2_opA2, "ww" },
-	{ &FWScript::o2_opA3, "ww" },
+	{ &FWScript::o2_addGfxElementA0, "ww" }, /* TODO: Name this opcode properly. */
+	{ &FWScript::o2_removeGfxElementA0, "ww" }, /* TODO: Name this opcode properly. */
+	{ &FWScript::o2_opA2, "ww" }, /* TODO: Name this opcode properly. */
+	{ &FWScript::o2_opA3, "ww" }, /* TODO: Name this opcode properly. */
 	/* A4 */
-	{ &FWScript::o2_loadMask22, "b" },
-	{ &FWScript::o2_unloadMask22, "b" },
+	{ &FWScript::o2_loadMask22, "b" }, /* TODO: Name this opcode properly. */
+	{ &FWScript::o2_unloadMask22, "b" }, /* TODO: Name this opcode properly. */
 	{ 0, 0 },
 	{ 0, 0 },
 	/* A8 */
 	{ 0, 0 },
-	{ &FWScript::o1_changeDataDisk, "b" }
+	{ &FWScript::o1_changeDataDisk, "b" } /* Same as opcodes 0x6B and 0x95. */
 };
 const unsigned int OSScript::_numOpcodes = ARRAYSIZE(OSScript::_opcodeTable);
 
@@ -365,6 +365,14 @@ FWScript *OSScriptInfo::create(const RawObjectScript &script, int16 index, const
 // OPERATION STEALTH opcodes
 // ------------------------------------------------------------------------
 
+int FWScript::o2_loadCt() {
+	const char *param = getNextString();
+
+	debugC(5, kCineDebugScript, "Line: %d: loadCt(\"%s\")", _line, param);
+	loadCtOS(param);
+	return 0;
+}
+
 int FWScript::o2_loadPart() {
 	const char *param = getNextString();
 
@@ -447,7 +455,9 @@ int FWScript::o2_op82() {
 	byte a = getNextByte();
 	byte b = getNextByte();
 	uint16 c = getNextWord();
-	warning("STUB: o2_op82(%x, %x, %x)", a, b, c);
+	uint16 d = getNextWord();
+	byte e = getNextByte();
+	warning("STUB: o2_op82(%x, %x, %x, %x, %x)", a, b, c, d, e);
 	return 0;
 }
 
@@ -615,20 +625,7 @@ int FWScript::o2_removeBackground() {
 
 	debugC(5, kCineDebugScript, "Line: %d: removeBackground(%d)", _line, param);
 
-	if (additionalBgTable[param]) {
-		free(additionalBgTable[param]);
-		additionalBgTable[param] = NULL;
-	}
-
-	if (currentAdditionalBgIdx == param) {
-		currentAdditionalBgIdx = 0;
-	}
-
-	if (currentAdditionalBgIdx2 == param) {
-		currentAdditionalBgIdx2 = 0;
-	}
-
-	strcpy(currentBgName[param], "");
+	renderer->removeBg(param);
 	return 0;
 }
 
@@ -644,29 +641,20 @@ int FWScript::o2_loadAbs() {
 int FWScript::o2_loadBg() {
 	byte param = getNextByte();
 
-	assert(param <= 8);
+	assert(param < 9);
 
 	debugC(5, kCineDebugScript, "Line: %d: useBg(%d)", _line, param);
 
-	if (additionalBgTable[param]) {
-		currentAdditionalBgIdx = param;
-		if (param == 8) {
-			newColorMode = 3;
-		} else {
-			newColorMode = bgColorMode + 1;
-		}
-		//if (_screenNeedFadeOut == 0) {
-		//	adBgVar1 = 1;
-		//}
-		fadeRequired = true;
-	}
+	renderer->selectBg(param);
 	return 0;
 }
 
-/*! \todo Implement this instruction
+/*! \todo Check the current implementation for correctness
  */
 int FWScript::o2_wasZoneChecked() {
-	warning("STUB: o2_wasZoneChecked()");
+	byte param = getNextByte();
+	_compare = (param < 16 && zoneData[param]);
+	debugC(5, kCineDebugScript, "Line: %d: o2_wasZoneChecked(%d)", _line, param);
 	return 0;
 }
 
@@ -699,13 +687,11 @@ int FWScript::o2_op9C() {
 int FWScript::o2_useBgScroll() {
 	byte param = getNextByte();
 
-	assert(param <= 8);
+	assert(param < 9);
 
 	debugC(5, kCineDebugScript, "Line: %d: useBgScroll(%d)", _line, param);
 
-	if (additionalBgTable[param]) {
-		currentAdditionalBgIdx2 = param;
-	}
+	renderer->selectScrollBg(param);
 	return 0;
 }
 
@@ -716,12 +702,12 @@ int FWScript::o2_setAdditionalBgVScroll() {
 		byte param2 = getNextByte();
 
 		debugC(5, kCineDebugScript, "Line: %d: additionalBgVScroll = var[%d]", _line, param2);
-		additionalBgVScroll = _localVars[param2];
+		renderer->setScroll(_localVars[param2]);
 	} else {
 		uint16 param2 = getNextWord();
 
 		debugC(5, kCineDebugScript, "Line: %d: additionalBgVScroll = %d", _line, param2);
-		additionalBgVScroll = param2;
+		renderer->setScroll(param2);
 	}
 	return 0;
 }
diff --git a/engines/cine/texte.cpp b/engines/cine/texte.cpp
index e41626cad1..91a209074d 100644
--- a/engines/cine/texte.cpp
+++ b/engines/cine/texte.cpp
@@ -611,65 +611,49 @@ void freePoldatDat() {
 	fontParamTable = 0;
 }
 
-uint16 computeMessageLength(const byte *ptr, uint16 width, uint16 *numWords, uint16 *messageWidth, uint16 *lineResult) {
-	const byte *localPtr = ptr;
-
-	uint16 var_2 = 0;
-	uint16 localLineResult = 0;
-	uint16 var_6 = 0;
-	uint16 var_8 = 0;
-	uint16 localMessageWidth = 0;
-	uint16 var_16 = 0;
-	uint16 finished = 0;
-	uint16 si = 0;
-	uint16 di = 0;
-
-	while (!finished) {
-		byte character = *(localPtr++);
-
-		if (character == ' ') {
-			var_8 = var_16;
-			var_6 = localMessageWidth;
-			localLineResult = si;
-			var_2 = di;
-
-			if (si + 5 < width) {
-				var_16++;
-				si += 5;
-			} else {
-				finished = 1;
-			}
-		} else if (character == 0x7C || character == 0) {
-			finished = 1;
-			si = 0;
+/*! \brief Fit a substring of text into one line of fixed width text box
+ * \param str Text to fit
+ * \param maxWidth Text box width
+ * \param[out] words Number of words that fit
+ * \param[out] width Total width of nonblank characters that fit
+ * \return Length of substring which fits
+ */
+int fitLine(const char *str, int maxWidth, int &words, int &width) {
+	int i, bkpWords = 0, bkpWidth = 0, bkpLen = 0;
+	int charWidth = 0, fullWidth = 0;
+
+	words = 0;
+	width = 0;
+
+	for (i = 0; str[i]; i++) {
+		if (str[i] == 0x7C) {
+			i++;
+			break;
+		} else if (str[i] == ' ') {
+			charWidth = 5;
+			bkpWords = words++;
+			bkpWidth = width;
+			bkpLen = i + 1;
 		} else {
-			if (fontParamTable[character].characterWidth) {
-				uint16 var_C = fontParamTable[character].characterWidth + 1;
-
-				if (si + var_C < width) {
-					si += var_C;
-					localMessageWidth += var_C;
-				} else {
-					finished = 1;
-
-					if (localLineResult) {
-						var_16 = var_8;
-						localMessageWidth = var_6;
-						si = localLineResult;
-						di = var_2;
-					}
-				}
-			}
+			charWidth = fontParamTable[str[i]].characterWidth + 1;
+			width += charWidth;
 		}
 
-		di++;
-	}
+		if (!charWidth) {
+			continue;
+		}
 
-	*numWords = var_16;
-	*messageWidth = localMessageWidth;
-	*lineResult = si;
+		if (fullWidth + charWidth < maxWidth) {
+			fullWidth += charWidth;
+		} else if (fullWidth) {
+			words = bkpWords;
+			width = bkpWidth;
+			i = bkpLen;
+			break;
+		}
+	}
 
-	return di;
+	return i;
 }
 
 } // End of namespace Cine
diff --git a/engines/cine/texte.h b/engines/cine/texte.h
index b5eaef9211..ae82832aea 100644
--- a/engines/cine/texte.h
+++ b/engines/cine/texte.h
@@ -56,7 +56,7 @@ void freeErrmessDat(void);
 void loadPoldatDat(const char *fname);
 void freePoldatDat(void);
 
-uint16 computeMessageLength(const byte *ptr, uint16 width, uint16 *numWords, uint16 *messageWidth, uint16 *lineResult);
+int fitLine(const char *ptr, int maxWidth, int &words, int &width);
 
 } // End of namespace Cine
 
diff --git a/engines/cine/various.cpp b/engines/cine/various.cpp
index a6bd9964c0..9b98ddb253 100644
--- a/engines/cine/various.cpp
+++ b/engines/cine/various.cpp
@@ -87,7 +87,6 @@ char newPrcName[20];
 char newRelName[20];
 char newObjectName[20];
 char newMsgName[20];
-char currentBgName[8][15];
 char currentCtName[15];
 char currentPartName[15];
 char currentDatName[30];
@@ -96,8 +95,6 @@ int16 saveVar2;
 
 byte isInPause = 0;
 
-uint16 defaultMenuBoxColor;
-
 byte inputVar1 = 0;
 uint16 inputVar2 = 0, inputVar3 = 0;
 
@@ -114,7 +111,6 @@ CommandeType objectListCommand[20];
 int16 objListTab[20];
 
 uint16 exitEngine;
-uint16 defaultMenuBoxColor2;
 uint16 zoneData[NUM_MAX_ZONE];
 
 
@@ -140,6 +136,7 @@ void addPlayerCommandMessage(int16 cmd) {
 	tmp.type = 3;
 
 	overlayList.push_back(tmp);
+	waitForPlayerClick = 1;
 }
 
 int16 getRelEntryForObject(uint16 param1, uint16 param2, SelectedObjStruct *pSelectedObject) {
@@ -393,11 +390,14 @@ bool brokenSave(Common::InSaveFile &fHandle) {
 	return broken;
 }
 
+/*! \todo Implement Operation Stealth loading, this is obviously Future Wars only
+ */
 bool CineEngine::makeLoad(char *saveName) {
 	int16 i;
 	int16 size;
 	bool broken;
 	Common::InSaveFile *fHandle;
+	char bgName[13];
 
 	fHandle = g_saveFileMan->openForLoading(saveName);
 
@@ -440,7 +440,6 @@ bool CineEngine::makeLoad(char *saveName) {
 	strcpy(newRelName, "");
 	strcpy(newObjectName, "");
 	strcpy(newMsgName, "");
-	strcpy(currentBgName[0], "");
 	strcpy(currentCtName, "");
 
 	allowPlayerInput = 0;
@@ -455,9 +454,7 @@ bool CineEngine::makeLoad(char *saveName) {
 
 	fadeRequired = false;
 
-	for (i = 0; i < 16; i++) {
-		c_palette[i] = 0;
-	}
+	renderer->clear();
 
 	checkForPendingDataLoadSwitch = 0;
 
@@ -473,7 +470,7 @@ bool CineEngine::makeLoad(char *saveName) {
 	fHandle->read(currentPrcName, 13);
 	fHandle->read(currentRelName, 13);
 	fHandle->read(currentMsgName, 13);
-	fHandle->read(currentBgName[0], 13);
+	fHandle->read(bgName, 13);
 	fHandle->read(currentCtName, 13);
 
 	checkDataDisk(currentDisk);
@@ -490,12 +487,12 @@ bool CineEngine::makeLoad(char *saveName) {
 		loadRel(currentRelName);
 	}
 
-	if (strlen(currentBgName[0])) {
-		loadBg(currentBgName[0]);
+	if (strlen(bgName)) {
+		loadBg(bgName);
 	}
 
 	if (strlen(currentCtName)) {
-		loadCt(currentCtName);
+		loadCtFW(currentCtName);
 	}
 
 	fHandle->readUint16BE();
@@ -511,13 +508,7 @@ bool CineEngine::makeLoad(char *saveName) {
 		objectTable[i].part = fHandle->readUint16BE();
 	}
 
-	for (i = 0; i < 16; i++) {
-		c_palette[i] = fHandle->readUint16BE();
-	}
-
-	for (i = 0; i < 16; i++) {
-		tempPalette[i] = fHandle->readUint16BE();
-	}
+	renderer->restorePalette(*fHandle);
 
 	globalVars.load(*fHandle, NUM_MAX_VAR - 1);
 
@@ -530,8 +521,10 @@ bool CineEngine::makeLoad(char *saveName) {
 	}
 
 	fHandle->read(commandBuffer, 0x50);
+	renderer->setCommand(commandBuffer);
+
+	renderer->_cmdY = fHandle->readUint16BE();
 
-	defaultMenuBoxColor = fHandle->readUint16BE();
 	bgVar0 = fHandle->readUint16BE();
 	allowPlayerInput = fHandle->readUint16BE();
 	playerCommand = fHandle->readSint16BE();
@@ -542,7 +535,8 @@ bool CineEngine::makeLoad(char *saveName) {
 	var3 = fHandle->readUint16BE();
 	var2 = fHandle->readUint16BE();
 	commandVar2 = fHandle->readSint16BE();
-	defaultMenuBoxColor2 = fHandle->readUint16BE();
+
+	renderer->_messageBg = fHandle->readUint16BE();
 
 	fHandle->readUint16BE();
 	fHandle->readUint16BE();
@@ -615,7 +609,7 @@ void makeSave(char *saveFileName) {
 	fHandle->write(currentPrcName, 13);
 	fHandle->write(currentRelName, 13);
 	fHandle->write(currentMsgName, 13);
-	fHandle->write(currentBgName[0], 13);
+	renderer->saveBg(*fHandle);
 	fHandle->write(currentCtName, 13);
 
 	fHandle->writeUint16BE(0xFF);
@@ -631,13 +625,7 @@ void makeSave(char *saveFileName) {
 		fHandle->writeUint16BE(objectTable[i].part);
 	}
 
-	for (i = 0; i < 16; i++) {
-		fHandle->writeUint16BE(c_palette[i]);
-	}
-
-	for (i = 0; i < 16; i++) {
-		fHandle->writeUint16BE(tempPalette[i]);
-	}
+	renderer->savePalette(*fHandle);
 
 	globalVars.save(*fHandle, NUM_MAX_VAR - 1);
 
@@ -651,7 +639,8 @@ void makeSave(char *saveFileName) {
 
 	fHandle->write(commandBuffer, 0x50);
 
-	fHandle->writeUint16BE(defaultMenuBoxColor);
+	fHandle->writeUint16BE(renderer->_cmdY);
+
 	fHandle->writeUint16BE(bgVar0);
 	fHandle->writeUint16BE(allowPlayerInput);
 	fHandle->writeUint16BE(playerCommand);
@@ -662,7 +651,8 @@ void makeSave(char *saveFileName) {
 	fHandle->writeUint16BE(var3);
 	fHandle->writeUint16BE(var2);
 	fHandle->writeUint16BE(commandVar2);
-	fHandle->writeUint16BE(defaultMenuBoxColor2);
+
+	fHandle->writeUint16BE(renderer->_messageBg);
 
 	fHandle->writeUint16BE(0xFF);
 	fHandle->writeUint16BE(0x1E);
@@ -864,26 +854,6 @@ void CineEngine::makeSystemMenu(void) {
 	}
 }
 
-int drawChar(byte character, int16 x, int16 y) {
-	if (character == ' ') {
-		x += 5;
-	} else {
-		byte characterWidth = fontParamTable[character].characterWidth;
-
-		if (characterWidth) {
-			byte characterIdx = fontParamTable[character].characterIdx;
-			if (g_cine->getGameType() == Cine::GType_OS) {
-				drawSpriteRaw2(textTable[characterIdx][0], 0, 2, 8, page1Raw, x, y);
-			} else {
-				drawSpriteRaw(textTable[characterIdx][0], textTable[characterIdx][1], 2, 8, page1Raw, x, y);
-			}
-			x += characterWidth + 1;
-		}
-	}
-
-	return x;
-}
-
 void drawMessageBox(int16 x, int16 y, int16 width, int16 currentY, int16 offset, int16 color, byte* page) {
 	gfxDrawLine(x + offset, y + offset, x + width - offset, y + offset, color, page);	// top
 	gfxDrawLine(x + offset, currentY + 4 - offset, x + width - offset, currentY + 4 - offset, color, page);	// bottom
@@ -896,49 +866,6 @@ void drawDoubleMessageBox(int16 x, int16 y, int16 width, int16 currentY, int16 c
 	drawMessageBox(x, y, width, currentY, 0, color, page);
 }
 
-void makeTextEntry(const CommandeType commandList[], uint16 height, uint16 X, uint16 Y, uint16 width) {
-	byte color = 2;
-	byte color2 = defaultMenuBoxColor2;
-	int16 paramY = (height * 9) + 10;
-	int16 currentX, currentY;
-	int16 i;
-	uint16 j;
-	byte currentChar;
-
-	if (X + width > 319) {
-		X = 319 - width;
-	}
-
-	if (Y + paramY > 199) {
-		Y = 199 - paramY;
-	}
-
-	hideMouse();
-	blitRawScreen(page1Raw);
-
-	gfxDrawPlainBoxRaw(X, Y, X + width, Y + 4, color2, page1Raw);
-
-	currentX = X + 4;
-	currentY = Y + 4;
-
-	for (i = 0; i < height; i++) {
-		gfxDrawPlainBoxRaw(X, currentY, X + width, currentY + 9, color2, page1Raw);
-		currentX = X + 4;
-
-		for (j = 0; j < strlen(commandList[i]); j++) {
-			currentChar = commandList[i][j];
-			currentX = drawChar(currentChar, currentX, currentY);
-		}
-
-		currentY += 9;
-	}
-
-	gfxDrawPlainBoxRaw(X, currentY, X + width, currentY + 4, color2, page1Raw);	// bottom part
-	drawDoubleMessageBox(X, Y, width, currentY, color, page1Raw);
-
-	blitRawScreen(page1Raw);
-}
-
 void processInventory(int16 x, int16 y) {
 	int16 listSize = buildObjectListCommand(-2);
 	uint16 button;
@@ -946,7 +873,8 @@ void processInventory(int16 x, int16 y) {
 	if (!listSize)
 		return;
 
-	makeTextEntry(objectListCommand, listSize, x, y, 140);
+	renderer->drawMenu(objectListCommand, listSize, x, y, 140, -1);
+	renderer->blit();
 
 	do {
 		manageEvents();
@@ -1085,7 +1013,7 @@ void makeCommandLine(void) {
 	}
 
 	if (!disableSystemMenu) {
-		isDrawCommandEnabled = 1;
+		renderer->setCommand(commandBuffer);
 	}
 }
 
@@ -1094,13 +1022,8 @@ uint16 needMouseSave = 0;
 uint16 menuVar4 = 0;
 uint16 menuVar5 = 0;
 
-int16 makeMenuChoice(const CommandeType commandList[], uint16 height, uint16 X, uint16 Y,
-    uint16 width, bool recheckValue) {
-	byte color = 2;
-	byte color2 = defaultMenuBoxColor2;
+int16 makeMenuChoice(const CommandeType commandList[], uint16 height, uint16 X, uint16 Y, uint16 width, bool recheckValue) {
 	int16 paramY;
-	int16 currentX, currentY;
-	int16 i;
 	uint16 button;
 	int16 var_A;
 	int16 di;
@@ -1110,7 +1033,6 @@ int16 makeMenuChoice(const CommandeType commandList[], uint16 height, uint16 X,
 	int16 var_14;
 	int16 currentSelection, oldSelection;
 	int16 var_4;
-	byte currentChar;
 
 	if (disableSystemMenu)
 		return -1;
@@ -1125,30 +1047,8 @@ int16 makeMenuChoice(const CommandeType commandList[], uint16 height, uint16 X,
 		Y = 199 - paramY;
 	}
 
-	hideMouse();
-	blitRawScreen(page1Raw);
-
-	gfxDrawPlainBoxRaw(X, Y, X + width, Y + 4, color2, page1Raw);
-
-	currentX = X + 4;
-	currentY = Y + 4;
-
-	for (i = 0; i < height; i++) {
-		gfxDrawPlainBoxRaw(X, currentY, X + width, currentY + 9, color2, page1Raw);
-		currentX = X + 4;
-
-		for (j = 0; j < strlen(commandList[i]); j++) {
-			currentChar = commandList[i][j];
-			currentX = drawChar(currentChar, currentX, currentY);
-		}
-
-		currentY += 9;
-	}
-
-	gfxDrawPlainBoxRaw(X, currentY, X + width, currentY + 4, color2, page1Raw);	// bottom part
-	drawDoubleMessageBox(X, Y, width, currentY, color, page1Raw);
-
-	blitRawScreen(page1Raw);
+	renderer->drawMenu(commandList, height, X, Y, width, -1);
+	renderer->blit();
 
 	do {
 		manageEvents();
@@ -1160,15 +1060,9 @@ int16 makeMenuChoice(const CommandeType commandList[], uint16 height, uint16 X,
 	currentSelection = 0;
 
 	di = currentSelection * 9 + Y + 4;
-	gfxDrawPlainBoxRaw(X + 2, di - 1, X + width - 2, di + 7, 0, page1Raw);	// draw black box behind selection
-	currentX = X + 4;
-
-	for (j = 0; j < strlen(commandList[currentSelection]); j++) {
-		currentChar = commandList[currentSelection][j];
-		currentX = drawChar(currentChar, currentX, di);
-	}
 
-	blitRawScreen(page1Raw);
+	renderer->drawMenu(commandList, height, X, Y, width, currentSelection);
+	renderer->blit();
 
 	manageEvents();
 	getMouseData(mouseUpdateStatus, &button, (uint16 *)&mouseX, (uint16 *)&mouseY);
@@ -1219,29 +1113,10 @@ int16 makeMenuChoice(const CommandeType commandList[], uint16 height, uint16 X,
 				hideMouse();
 			}
 
-			di = oldSelection * 9 + Y + 4;
-
-			gfxDrawPlainBoxRaw(X + 2, di - 1, X + width - 2, di + 7, color2, page1Raw);	// restore color
-
-			currentX = X + 4;
-
-			for (j = 0; j < strlen(commandList[oldSelection]); j++) {
-				currentChar = commandList[oldSelection][j];
-				currentX = drawChar(currentChar, currentX, di);
-			}
-
 			di = currentSelection * 9 + Y + 4;
 
-			gfxDrawPlainBoxRaw(X + 2, di - 1, X + width - 2, di + 7, 0, page1Raw);	// black new
-
-			currentX = X + 4;
-
-			for (j = 0; j < strlen(commandList[currentSelection]); j++) {
-				currentChar = commandList[currentSelection][j];
-				currentX = drawChar(currentChar, currentX, di);
-			}
-
-			blitRawScreen(page1Raw);
+			renderer->drawMenu(commandList, height, X, Y, width, currentSelection);
+			renderer->blit();
 
 //			if (needMouseSave) {
 //				gfxRedrawMouseCursor();
@@ -1271,38 +1146,6 @@ int16 makeMenuChoice(const CommandeType commandList[], uint16 height, uint16 X,
 	return currentSelection;
 }
 
-void drawMenuBox(char *command, int16 x, int16 y) {
-	byte j;
-	byte lColor = 2;
-
-	hideMouse();
-
-	gfxDrawPlainBoxRaw(x, y, x + 300, y + 10, 0, page2Raw);
-
-	drawMessageBox(x, y, 300, y + 6, -1, lColor, page2Raw);
-
-	x += 2;
-	y += 2;
-
-	for (j = 0; j < strlen(command); j++) {
-		byte currentChar = command[j];
-
-		if (currentChar == ' ') {
-			x += 5;
-		} else {
-			byte characterWidth = fontParamTable[currentChar].characterWidth;
-
-			if (characterWidth) {
-				byte characterIdx = fontParamTable[currentChar].characterIdx;
-				drawSpriteRaw(textTable[characterIdx][0], textTable[characterIdx][1], 2, 8, page2Raw, x, y);
-				x += characterWidth + 1;
-			}
-		}
-	}
-
-//	gfxRedrawMouseCursor();
-}
-
 void makeActionMenu(void) {
 	uint16 mouseButton;
 	uint16 mouseX;
@@ -1342,11 +1185,6 @@ uint16 executePlayerInput(void) {
 	}
 
 	if (allowPlayerInput) {
-		if (isDrawCommandEnabled) {
-			drawMenuBox(commandBuffer, 10, defaultMenuBoxColor);
-			isDrawCommandEnabled = 0;
-		}
-
 		getMouseData(mouseUpdateStatus, &mouseButton, &mouseX, &mouseY);
 
 		while (mouseButton && currentEntry < 200) {
@@ -1393,7 +1231,6 @@ uint16 executePlayerInput(void) {
 						if (choiceResultTable[playerCommand] == commandVar1) {
 							int16 relEntry;
 
-							drawMenuBox(commandBuffer, 10, defaultMenuBoxColor);
 							SelectedObjStruct obj;
 							obj.idx = commandVar3[0];
 							obj.param = commandVar3[1];
@@ -1410,41 +1247,40 @@ uint16 executePlayerInput(void) {
 
 							commandVar1 = 0;
 							strcpy(commandBuffer, "");
+							renderer->setCommand("");
 						}
 					} else {
 						globalVars[VAR_MOUSE_X_POS] = mouseX;
 						globalVars[VAR_MOUSE_Y_POS] = mouseY;
 					}
 				}
-			} else {
-				if (mouseButton & 2) {
-					if (mouseButton & 1) {
-						g_cine->makeSystemMenu();
-					}
+			} else if (mouseButton & 2) {
+				if (mouseButton & 1) {
+					g_cine->makeSystemMenu();
+				}
 
-					makeActionMenu();
-					makeCommandLine();
-				} else {
-					int16 objIdx;
+				makeActionMenu();
+				makeCommandLine();
+			} else {
+				int16 objIdx;
 
-					objIdx = getObjectUnderCursor(mouseX, mouseY);
+				objIdx = getObjectUnderCursor(mouseX, mouseY);
 
-					if (commandVar2 != objIdx) {
-						if (objIdx != -1) {
-							char command[256];
+				if (commandVar2 != objIdx) {
+					if (objIdx != -1) {
+						char command[256];
 
-							strcpy(command, commandBuffer);
-							strcat(command, " ");
-							strcat(command, objectTable[objIdx].name);
+						strcpy(command, commandBuffer);
+						strcat(command, " ");
+						strcat(command, objectTable[objIdx].name);
 
-							drawMenuBox(command, 10, defaultMenuBoxColor);
-						} else {
-							isDrawCommandEnabled = 1;
-						}
+						renderer->setCommand(command);
+					} else {
+						isDrawCommandEnabled = 1;
 					}
-
-					commandVar2 = objIdx;
 				}
+
+				commandVar2 = objIdx;
 			}
 		} else {
 			if (mouseButton & 2) {
@@ -1653,257 +1489,9 @@ void drawSprite(Common::List<overlay>::iterator it, const byte *spritePtr, const
 	free(msk);
 }
 
-int16 additionalBgVScroll = 0;
-
-void backupOverlayPage(void) {
-	byte *scrollBg;
-	byte *bgPage = additionalBgTable[currentAdditionalBgIdx];
-
-	if (bgPage) {
-		if (!additionalBgVScroll) {
-			memcpy(page1Raw, bgPage, 320 * 200);
-		} else {
-			scrollBg = additionalBgTable[currentAdditionalBgIdx2];
-
-			for (int16 i = additionalBgVScroll; i < 200 + additionalBgVScroll; i++) {
-				if (i > 200) {
-					memcpy(page1Raw + (i - additionalBgVScroll) * 320, scrollBg + (i - 200) * 320, 320);
-				} else {
-					memcpy(page1Raw + (i - additionalBgVScroll) * 320, bgPage + (i-1) * 320, 320);
-				}
-			}
-		}
-	}
-}
-
-void drawMessage(const char *messagePtr, int16 x, int16 y, int16 width, int16 color) {
-	byte color2 = 2;
-	byte endOfMessageReached = 0;
-	int16 localX, localY, localWidth;
-	uint16 messageLength = 0, numWords = 0, messageWidth = 0;
-	uint16 lineResult, fullLineWidth;
-	uint16 interWordSize, interWordSizeRemain;
-	const char *endOfMessagePtr;
-	byte currentChar; //, characterWidth;
-
-	gfxDrawPlainBoxRaw(x, y, x + width, y + 4, color, page1Raw);
-
-	localX = x + 4;
-	localY = y + 4;
-	localWidth = width - 8;
-
-	do {
-		messageLength = 0;
-
-		while (messagePtr[messageLength] == ' ') {
-			messageLength++;
-		}
-
-		messagePtr += messageLength;
-
-		messageLength = computeMessageLength((const byte *)messagePtr, localWidth, &numWords, &messageWidth, &lineResult);
-
-		endOfMessagePtr = messagePtr + messageLength;
-
-		if (lineResult) {
-			fullLineWidth = localWidth - messageWidth;
-
-			if (numWords) {
-				interWordSize = fullLineWidth / numWords;
-				interWordSizeRemain = fullLineWidth % numWords;
-			} else {
-				interWordSize = 5;
-				interWordSizeRemain = 0;
-			}
-		} else {
-			interWordSize = 5;
-			interWordSizeRemain = 0;
-		}
-
-		gfxDrawPlainBoxRaw(x, localY, x + width, localY + 9, color, page1Raw);
-
-		do {
-			currentChar = *(messagePtr++);
-
-			if (currentChar == 0) {
-				endOfMessageReached = 1;
-			} else if (currentChar == ' ') {
-				localX += interWordSizeRemain + interWordSize;
-
-				if (interWordSizeRemain)
-					interWordSizeRemain = 0;
-			} else {
-				localX = drawChar(currentChar, localX, localY);
-			}
-		} while ((messagePtr < endOfMessagePtr) && !endOfMessageReached);
-
-		localX = x + 4;
-		localY += 9;
-	} while (!endOfMessageReached);
-
-	gfxDrawPlainBoxRaw(x, localY, x + width, localY + 4, color, page1Raw);
-
-	drawDoubleMessageBox(x, y, width, localY, color2, page1Raw);
-}
-
-void drawDialogueMessage(byte msgIdx, int16 x, int16 y, int16 width, int16 color) {
-	if (msgIdx >= messageTable.size()) {
-//		removeOverlay(msgIdx, 2);
-		return;
-	}
-
-	_messageLen += messageTable[msgIdx].size();
-	drawMessage(messageTable[msgIdx].c_str(), x, y, width, color);
-
-	// this invalidates the iterator in drawOverlays()
-//	removeOverlay(msgIdx, 2);
-}
-
-void drawFailureMessage(byte cmd) {
-	byte msgIdx = cmd * 4 + g_cine->_rnd.getRandomNumber(3);
-
-	const char *messagePtr = failureMessages[msgIdx];
-	int len = strlen(messagePtr);
-
-	_messageLen += len;
-
-	int16 width = 6 * len + 20;
-
-	if (width > 300)
-		width = 300;
-
-	int16 x = (320 - width) / 2;
-	int16 y = 80;
-	int16 color = 4;
-
-	drawMessage(messagePtr, x, y, width, color);
-
-	// this invalidates the iterator in drawOverlays()
-//	removeOverlay(cmd, 3);
-}
-
-void drawOverlays(void) {
-	uint16 width, height;
-	AnimData *pPart;
-	int16 x, y;
-	objectStruct *objPtr;
-	byte messageIdx;
+void removeMessages() {
 	Common::List<overlay>::iterator it;
 
-	backupOverlayPage();
-
-	_messageLen = 0;
-
-	for (it = overlayList.begin(); it != overlayList.end(); ++it) {
-		switch (it->type) {
-		case 0: // sprite
-			assert(it->objIdx < NUM_MAX_OBJECT);
-
-			objPtr = &objectTable[it->objIdx];
-			x = objPtr->x;
-			y = objPtr->y;
-
-			if (objPtr->frame < 0) {
-				continue;
-			}
-
-			pPart = &animDataTable[objPtr->frame];
-			width = pPart->_realWidth;
-			height = pPart->_height;
-
-			if (!pPart->data()) {
-				continue;
-			}
-
-			// drawSprite ignores masks of Operation Stealth sprites
-			drawSprite(it, pPart->data(), pPart->mask(), width, height, page1Raw, x, y);
-			break;
-
-		case 2:	// text
-			// gfxWaitVSync();
-			// hideMouse();
-
-			messageIdx = it->objIdx;
-			x = it->x;
-			y = it->y;
-			width = it->width;
-			height = it->color;
-
-			blitRawScreen(page1Raw);
-
-			drawDialogueMessage(messageIdx, x, y, width, height);
-
-			// blitScreen(page0, NULL);
-			// gfxRedrawMouseCursor();
-
-			waitForPlayerClick = 1;
-
-			break;
-
-		case 3:
-			// gfxWaitSync()
-			// hideMouse();
-
-			blitRawScreen(page1Raw);
-
-			drawFailureMessage(it->objIdx);
-
-			// blitScreen(page0, NULL);
-			// gfxRedrawMouseCursor();
-
-			waitForPlayerClick = 1;
-
-			break;
-
-		case 4:
-			assert(it->objIdx < NUM_MAX_OBJECT);
-
-			objPtr = &objectTable[it->objIdx];
-			x = objPtr->x;
-			y = objPtr->y;
-
-			if (objPtr->frame < 0) {
-				continue;
-			}
-
-			assert(objPtr->frame < NUM_MAX_ANIMDATA);
-
-			pPart = &animDataTable[objPtr->frame];
-
-			width = pPart->_realWidth;
-			height = pPart->_height;
-
-			if (!pPart->data()) {
-				continue;
-			}
-
-			gfxFillSprite(pPart->data(), width, height, page1Raw, x, y);
-			break;
-
-		case 20:
-			assert(it->objIdx < NUM_MAX_OBJECT);
-
-			objPtr = &objectTable[it->objIdx];
-			x = objPtr->x;
-			y = objPtr->y;
-			var5 = it->x;
-
-			if (objPtr->frame < 0 || var5 > 8 || !additionalBgTable[var5] || animDataTable[objPtr->frame]._bpp != 1) {
-				continue;
-			}
-
-			width = animDataTable[objPtr->frame]._realWidth;
-			height = animDataTable[objPtr->frame]._height;
-
-			if (!animDataTable[objPtr->frame].data()) {
-				continue;
-			}
-
-			maskBgOverlay(additionalBgTable[var5], animDataTable[objPtr->frame].data(), width, height, page1Raw, x, y);
-			break;
-		}
-	}
-
 	for (it = overlayList.begin(); it != overlayList.end(); ) {
 		if (it->type == 2 || it->type == 3) {
 			it = overlayList.erase(it);
@@ -1978,115 +1566,96 @@ void addMessage(byte param1, int16 param2, int16 param3, int16 param4, int16 par
 	tmp.color = param5;
 
 	overlayList.push_back(tmp);
+	waitForPlayerClick = 1;
 }
 
-SeqListElement seqList;
+Common::List<SeqListElement> seqList;
 
 void removeSeq(uint16 param1, uint16 param2, uint16 param3) {
-	SeqListElement *currentHead = &seqList;
-	SeqListElement *tempHead = currentHead;
+	Common::List<SeqListElement>::iterator it;
 
-	while (currentHead && (currentHead->var6 != param1 || currentHead->var4 != param2 || currentHead->varE != param3)) {
-		tempHead = currentHead;
-		currentHead = tempHead->next;
-	}
-
-	if (currentHead && currentHead->var6 == param1 && currentHead->var4 == param2 && currentHead->varE == param3) {
-		currentHead->var4 = -1;
+	for (it = seqList.begin(); it != seqList.end(); ++it) {
+		if (it->objIdx == param1 && it->var4 == param2 && it->varE == param3) {
+			it->var4 = -1;
+			break;
+		}
 	}
 }
 
 uint16 isSeqRunning(uint16 param1, uint16 param2, uint16 param3) {
-	SeqListElement *currentHead = &seqList;
-	SeqListElement *tempHead = currentHead;
-
-	while (currentHead && (currentHead->var6 != param1 || currentHead->var4 != param2 || currentHead->varE != param3)) {
-		tempHead = currentHead;
-		currentHead = tempHead->next;
-	}
+	Common::List<SeqListElement>::iterator it;
 
-	if (currentHead && currentHead->var6 == param1 && currentHead->var4 == param2 && currentHead->varE == param3) {
-		return 1;
+	for (it = seqList.begin(); it != seqList.end(); ++it) {
+		if (it->objIdx == param1 && it->var4 == param2 && it->varE == param3) {
+			return 1;
+		}
 	}
 
 	return 0;
 }
 
-void addSeqListElement(int16 param0, int16 param1, int16 param2, int16 param3, int16 param4, int16 param5, int16 param6, int16 param7, int16 param8) {
-	SeqListElement *currentHead = &seqList;
-	SeqListElement *tempHead = currentHead;
-	SeqListElement *newElement;
-
-	currentHead = tempHead->next;
-
-	while (currentHead && currentHead->varE < param7) {
-		tempHead = currentHead;
-		currentHead = tempHead->next;
-	}
-
-	newElement = new SeqListElement;
-
-	newElement->next = tempHead->next;
-	tempHead->next = newElement;
-
-	newElement->var6 = param0;
-	newElement->var4 = param1;
-	newElement->var8 = param2;
-	newElement->varA = param3;
-	newElement->varC = param4;
-	newElement->var14 = 0;
-	newElement->var16 = 0;
-	newElement->var18 = param5;
-	newElement->var1A = param6;
-	newElement->varE = param7;
-	newElement->var10 = param8;
-	newElement->var12 = param8;
-	newElement->var1C = 0;
-	newElement->var1E = 0;
-}
-
-void resetSeqList() {
-	seqList.next = NULL;
+void addSeqListElement(uint16 objIdx, int16 param1, int16 param2, int16 frame, int16 param4, int16 param5, int16 param6, int16 param7, int16 param8) {
+	Common::List<SeqListElement>::iterator it;
+	SeqListElement tmp;
+
+	for (it = seqList.begin(); it != seqList.end() && it->varE < param7; ++it) ;
+
+	tmp.objIdx = objIdx;
+	tmp.var4 = param1;
+	tmp.var8 = param2;
+	tmp.frame = frame;
+	tmp.varC = param4;
+	tmp.var14 = 0;
+	tmp.var16 = 0;
+	tmp.var18 = param5;
+	tmp.var1A = param6;
+	tmp.varE = param7;
+	tmp.var10 = param8;
+	tmp.var12 = param8;
+	tmp.var1C = 0;
+	tmp.var1E = 0;
+
+	seqList.insert(it, tmp);
 }
 
-void computeMove1(SeqListElement *element, int16 x, int16 y, int16 param1,
+void computeMove1(SeqListElement &element, int16 x, int16 y, int16 param1,
     int16 param2, int16 x2, int16 y2) {
-	element->var16 = 0;
-	element->var14 = 0;
+	element.var16 = 0;
+	element.var14 = 0;
 
 	if (y2) {
 		if (y - param2 > y2) {
-			element->var16 = 2;
+			element.var16 = 2;
 		}
 
 		if (y + param2 < y2) {
-			element->var16 = 1;
+			element.var16 = 1;
 		}
 	}
 
 	if (x2) {
 		if (x - param1 > x2) {
-			element->var14 = 2;
+			element.var14 = 2;
 		}
 
 		if (x + param1 < x2) {
-			element->var14 = 1;
+			element.var14 = 1;
 		}
 	}
 }
 
-uint16 computeMove2(SeqListElement *element) {
+uint16 computeMove2(SeqListElement &element) {
 	int16 returnVar = 0;
 
-	if (element->var16 == 1) {
+	if (element.var16 == 1) {
 		returnVar = 4;
-	} else if (element->var16 == 2) {
+	} else if (element.var16 == 2) {
 		returnVar = 3;
 	}
 
-	if (element->var14 == 1) {
+	if (element.var14 == 1) {
 		returnVar = 1;
-	} else if (element->var14 == 2) {
+	} else if (element.var14 == 2) {
 		returnVar = 2;
 	}
 
@@ -2165,14 +1734,13 @@ void resetGfxEntityEntry(uint16 objIdx) {
 #endif
 }
 
-uint16 addAni(uint16 param1, uint16 param2, const byte *ptr, SeqListElement *element, uint16 param3, int16 *param4) {
+uint16 addAni(uint16 param1, uint16 objIdx, const byte *ptr, SeqListElement &element, uint16 param3, int16 *param4) {
 	const byte *currentPtr = ptr;
 	const byte *ptrData;
 	const byte *ptr2;
 	int16 di;
 
 	assert(ptr);
-	assert(element);
 	assert(param4);
 
 	dummyU16 = READ_BE_UINT16((currentPtr + param1 * 2) + 8);
@@ -2181,25 +1749,25 @@ uint16 addAni(uint16 param1, uint16 param2, const byte *ptr, SeqListElement *ele
 
 	assert(*ptrData);
 
-	di = (objectTable[param2].costume + 1) % (*ptrData);
+	di = (objectTable[objIdx].costume + 1) % (*ptrData);
 	ptr2 = (ptrData + (di * 8)) + 1;
 
-	if ((checkCollision(param2, ptr2[0], ptr2[1], ptr2[2], ptr[0]) & 1)) {
+	if ((checkCollision(objIdx, ptr2[0], ptr2[1], ptr2[2], ptr[0]) & 1)) {
 		return 0;
 	}
 
-	objectTable[param2].x += (int8)ptr2[4];
-	objectTable[param2].y += (int8)ptr2[5];
-	objectTable[param2].mask += (int8)ptr2[6];
+	objectTable[objIdx].x += (int8)ptr2[4];
+	objectTable[objIdx].y += (int8)ptr2[5];
+	objectTable[objIdx].mask += (int8)ptr2[6];
 
-	if (objectTable[param2].frame) {
-		resetGfxEntityEntry(param2);
+	if (objectTable[objIdx].frame) {
+		resetGfxEntityEntry(objIdx);
 	}
 
-	objectTable[param2].frame = ptr2[7] + element->var8;
+	objectTable[objIdx].frame = ptr2[7] + element.var8;
 
-	if (param3 || !element->var14) {
-		objectTable[param2].costume = di;
+	if (param3 || !element.var14) {
+		objectTable[objIdx].costume = di;
 	} else {
 		*param4 = di;
 	}
@@ -2207,86 +1775,86 @@ uint16 addAni(uint16 param1, uint16 param2, const byte *ptr, SeqListElement *ele
 	return 1;
 }
 
-void processSeqListElement(SeqListElement *element) {
-	int16 x = objectTable[element->var6].x;
-	int16 y = objectTable[element->var6].y;
-	const byte *ptr1 = animDataTable[element->varA].data();
+void processSeqListElement(SeqListElement &element) {
+	int16 x = objectTable[element.objIdx].x;
+	int16 y = objectTable[element.objIdx].y;
+	const byte *ptr1 = animDataTable[element.frame].data();
 	int16 var_10;
 	int16 var_4;
 	int16 var_2;
 
-	if (element->var12 < element->var10) {
-		element->var12++;
+	if (element.var12 < element.var10) {
+		element.var12++;
 		return;
 	}
 
-	element->var12 = 0;
+	element.var12 = 0;
 
 	if (ptr1) {
 		uint16 param1 = ptr1[1];
 		uint16 param2 = ptr1[2];
 
-		if (element->varC != 255) {
+		if (element.varC != 255) {
 			// FIXME: Why is this here? Fingolfin gets lots of these
 			// in his copy of Operation Stealth (value 0 or 236) under
 			// Mac OS X. Maybe it's a endian issue? At least the graphics
 			// in the copy protection screen are partially messed up.
-			warning("processSeqListElement: varC = %d", element->varC);
+			warning("processSeqListElement: varC = %d", element.varC);
 		}
 
 		if (globalVars[VAR_MOUSE_X_POS] || globalVars[VAR_MOUSE_Y_POS]) {
 			computeMove1(element, ptr1[4] + x, ptr1[5] + y, param1, param2, globalVars[VAR_MOUSE_X_POS], globalVars[VAR_MOUSE_Y_POS]);
 		} else {
-			element->var16 = 0;
-			element->var14 = 0;
+			element.var16 = 0;
+			element.var14 = 0;
 		}
 
 		var_10 = computeMove2(element);
 
 		if (var_10) {
-			element->var1C = var_10;
-			element->var1E = var_10;
+			element.var1C = var_10;
+			element.var1E = var_10;
 		}
 
 		var_4 = -1;
 
-		if ((element->var16 == 1
-			&& !addAni(3, element->var6, ptr1, element, 0, &var_4)) || (element->var16 == 2	&& !addAni(2, element->var6, ptr1, element, 0,
+		if ((element.var16 == 1
+			&& !addAni(3, element.objIdx, ptr1, element, 0, &var_4)) || (element.var16 == 2	&& !addAni(2, element.objIdx, ptr1, element, 0,
 			    &var_4))) {
-			if (element->varC == 255) {
+			if (element.varC == 255) {
 				globalVars[VAR_MOUSE_Y_POS] = 0;
 			}
 		}
 
-		if ((element->var14 == 1
-			&& !addAni(0, element->var6, ptr1, element, 1, &var_2))) {
-			if (element->varC == 255) {
+		if ((element.var14 == 1
+			&& !addAni(0, element.objIdx, ptr1, element, 1, &var_2))) {
+			if (element.varC == 255) {
 				globalVars[VAR_MOUSE_X_POS] = 0;
 
 				if (var_4 != -1) {
-					objectTable[element->var6].costume = var_4;
+					objectTable[element.objIdx].costume = var_4;
 				}
 			}
 		}
 
-		if ((element->var14 == 2 && !addAni(1, element->var6, ptr1, element, 1, &var_2))) {
-			if (element->varC == 255) {
+		if ((element.var14 == 2 && !addAni(1, element.objIdx, ptr1, element, 1, &var_2))) {
+			if (element.varC == 255) {
 				globalVars[VAR_MOUSE_X_POS] = 0;
 
 				if (var_4 != -1) {
-					objectTable[element->var6].costume = var_4;
+					objectTable[element.objIdx].costume = var_4;
 				}
 			}
 		}
 
-		if (element->var16 + element->var14) {
-			if (element->var1C) {
-				if (element->var1E) {
-					objectTable[element->var6].costume = 0;
-					element->var1E = 0;
+		if (element.var16 + element.var14) {
+			if (element.var1C) {
+				if (element.var1E) {
+					objectTable[element.objIdx].costume = 0;
+					element.var1E = 0;
 				}
 
-				addAni(element->var1C + 3, element->var6, ptr1, element, 1, (int16 *) & var2);
+				addAni(element.var1C + 3, element.objIdx, ptr1, element, 1, (int16 *) & var2);
 
 			}
 		}
@@ -2295,119 +1863,28 @@ void processSeqListElement(SeqListElement *element) {
 }
 
 void processSeqList(void) {
-	SeqListElement *currentHead = &seqList;
-	SeqListElement *tempHead = currentHead;
+	Common::List<SeqListElement>::iterator it;
 
-	currentHead = tempHead->next;
-
-	while (currentHead) {
-		if (currentHead->var4 != -1) {
-			processSeqListElement(currentHead);
+	for (it = seqList.begin(); it != seqList.end(); ++it) {
+		if (it->var4 == -1) {
+			continue;
 		}
 
-		tempHead = currentHead;
-		currentHead = tempHead->next;
+		processSeqListElement(*it);
 	}
 }
 
 
 bool makeTextEntryMenu(const char *messagePtr, char *inputString, int stringMaxLength, int y) {
-	int16 color = 2;
-	byte color2 = defaultMenuBoxColor2;
-	byte endOfMessageReached = 0;
-	int16 localX, localY, localWidth;
-	int margins = 16;
 	int len = strlen(messagePtr);
 	int16 width = 6 * len + 20;
-	uint16 messageLength = 0, numWords = 0, messageWidth = 0;
-	uint16 lineResult, fullLineWidth;
-	uint16 interWordSize, interWordSizeRemain;
-	const char *endOfMessagePtr;
-	byte currentChar, characterWidth;
 
 	width = CLIP((int)width, 180, 250);
 
 	int16 x = (320 - width) / 2;
 
-	gfxDrawPlainBoxRaw(x - margins, y, x + width + margins, y + 4, color2, page1Raw);
-
-	localX = x + 4;
-	localY = y + 4;
-	localWidth = width;
-
 	getKeyData(); // clear input key
 
-	do {
-		messageLength = 0;
-
-		while (messagePtr[messageLength] == ' ') {
-			messageLength++;
-		}
-
-		messagePtr += messageLength;
-
-		messageLength = computeMessageLength((const byte *)messagePtr, localWidth, &numWords, &messageWidth, &lineResult);
-
-		endOfMessagePtr = messagePtr + messageLength;
-
-		if (lineResult) {
-			fullLineWidth = localWidth - messageWidth;
-
-			if (numWords) {
-				interWordSize = fullLineWidth / numWords;
-				interWordSizeRemain = fullLineWidth % numWords;
-			} else {
-				interWordSize = 5;
-				interWordSizeRemain = 0;
-			}
-		} else {
-			interWordSize = 5;
-			interWordSizeRemain = 0;
-		}
-
-		gfxDrawPlainBoxRaw(x - margins, localY, x + width + margins, localY + 9, color2, page1Raw);
-
-		do {
-			currentChar = *(messagePtr++);
-
-			if (currentChar == 0) {
-				endOfMessageReached = 1;
-			} else if (currentChar == ' ') {
-				localX += interWordSizeRemain + interWordSize;
-
-				if (interWordSizeRemain)
-					interWordSizeRemain = 0;
-			} else {
-				characterWidth = fontParamTable[currentChar].characterWidth;
-
-				if (characterWidth) {
-					byte characterIdx = fontParamTable[currentChar].characterIdx;
-					drawSpriteRaw(textTable[characterIdx][0], textTable[characterIdx][1], 2, 8, page1Raw, localX, localY);
-					localX += characterWidth + 1;
-				}
-			}
-		} while ((messagePtr < endOfMessagePtr) && !endOfMessageReached);
-
-		localX = x + 4;
-		localY += 9;
-	} while (!endOfMessageReached);
-
-	// Input string
-	gfxDrawPlainBoxRaw(x - margins, localY, x + width + margins, localY + 9, color2, page1Raw);
-	localY += 9;
-
-	x -= margins;
-	width += margins * 2;
-
-	gfxDrawPlainBoxRaw(x, localY, x + width, localY + 4, color2, page1Raw);
-
-	drawDoubleMessageBox(x, y, width, localY, color, page1Raw);
-
-	x += margins;
-	width -= margins * 2;
-	localY -= 9;
-
-
 	int quit = 0;
 	bool redraw = true;
 	CommandeType tempString;
@@ -2416,24 +1893,8 @@ bool makeTextEntryMenu(const char *messagePtr, char *inputString, int stringMaxL
 
 	while (!quit) {
 		if (redraw) {
-			gfxDrawPlainBoxRaw(x, localY - 1, x + width, localY + 8, 0, page1Raw);
-
-			int currentX = x + 4;
-
-			for (uint j = 0; j < strlen(inputString); j++) {
-				currentChar = inputString[j];
-				currentX = drawChar(currentChar, currentX, localY);
-
-				// draw cursor here
-				if (inputPos == (int)(j + 2))
-					gfxDrawLine(currentX, localY - 1, currentX, localY + 8, color, page1Raw);
-
-			}
-
-			if (strlen(inputString) == 0 || inputPos == 1) // cursor wasn't yet drawn
-				gfxDrawLine(x + 4, localY - 1, x + 4, localY + 8, color, page1Raw);
-
-			blitRawScreen(page1Raw);
+			renderer->drawInputBox(messagePtr, inputString, inputPos, x - 16, y, width + 32);
+			renderer->blit();
 			redraw = false;
 		}
 
diff --git a/engines/cine/various.h b/engines/cine/various.h
index f906b2aa19..91662c16ff 100644
--- a/engines/cine/various.h
+++ b/engines/cine/various.h
@@ -43,11 +43,10 @@ extern bool disableSystemMenu;
 extern bool inMenu;
 
 struct SeqListElement {
-	struct SeqListElement *next;
 	int16 var4;
-	int16 var6;
+	uint16 objIdx;
 	int16 var8;
-	int16 varA;
+	int16 frame;
 	int16 varC;
 	int16 varE;
 	int16 var10;
@@ -60,7 +59,7 @@ struct SeqListElement {
 	int16 var1E;
 };
 
-extern SeqListElement seqList;
+extern Common::List<SeqListElement> seqList;
 
 extern uint16 var2;
 extern uint16 var3;
@@ -97,7 +96,6 @@ extern char newRelName[20];
 extern char newObjectName[20];
 extern char newMsgName[20];
 
-extern char currentBgName[8][15];
 extern char currentCtName[15];
 extern char currentPartName[15];
 
@@ -130,20 +128,16 @@ struct SelectedObjStruct {
 	int16 param;
 };
 
-extern uint16 defaultMenuBoxColor;
-extern uint16 defaultMenuBoxColor2;
-
 #define NUM_MAX_ZONE 16
 extern uint16 zoneData[NUM_MAX_ZONE];
 
 void addMessage(byte param1, int16 param2, int16 param3, int16 param4, int16 param5);
 
-extern int16 additionalBgVScroll;
+void removeMessages();
 
 void removeSeq(uint16 param1, uint16 param2, uint16 param3);
 uint16 isSeqRunning(uint16 param1, uint16 param2, uint16 param3);
-void addSeqListElement(int16 param0, int16 param1, int16 param2, int16 param3, int16 param4, int16 param5, int16 param6, int16 param7, int16 param8);
-void resetSeqList();
+void addSeqListElement(uint16 objIdx, int16 param1, int16 param2, int16 frame, int16 param4, int16 param5, int16 param6, int16 param7, int16 param8);
 void processSeqList(void);
 
 bool makeTextEntryMenu(const char *caption, char *string, int strLen, int y);
diff --git a/engines/cine/xref.txt b/engines/cine/xref.txt
index 3640ef83d6..5a8d2eef0f 100644
--- a/engines/cine/xref.txt
+++ b/engines/cine/xref.txt
@@ -1,4 +1,4 @@
-script.cpp:
+script_fw.cpp:
 setupOpcodes() - replaced with FWScript/OSScript class members
 getNextByte() - replaced with RawScript/FWScript class members
 getNextWord() - replaced with RawScript/FWScript class members
@@ -89,6 +89,9 @@ o1_disableSystemMenu() - replaced with FWScript::o1_disableSystemMenu()
 o1_loadMask5() - replaced with FWScript::o1_loadMask5()
 o1_unloadMask5() - replaced with FWScript::o1_unloadMask5()
 
+palRotate() - modified and moved to pal.cpp
+
+script_os.cpp:
 o2_loadPart() - replaced with FWScript::o2_loadPart()
 o2_addSeqListElement() - replaced with FWScript::o2_addSeqListElement()
 o2_removeSeq() - replaced with FWScript::o2_removeSeq()
@@ -134,20 +137,48 @@ releaseObjectScripts() - removed (obsoleted by Common::List::clear())
 various.cpp:
 setupScriptList() - removed (obsoleted by new makeLoad() and
 	loadScriptFromSave() implementation)
+drawChar() - removed (obsoleted by FWRenderer::drawChar())
+makeTextEntry() - removed (obsoleted by FWRenderer::drawMenu())
+drawMenuBox() - removed (obsoleted by FWRenderer::drawCommand())
+backupOverlayPage() - removed (obsoleted by FWRenderer::drawBackground())
+drawMessage() - removed (obsoleted by FWRenderer::drawMessage())
+drawDialogueMessage() - removed (obsoleted by FWRenderer::renderOverlay())
+drawFailureMessage() - removed (obsoleted by FWRenderer::renderOverlay())
+drawOverlays() - removed (obsoleted by FWRenderer::drawOverlays())
+resetSeqList() - removed (obsoleted by Common::List)
 
 anim.cpp:
 freeAnimData() - replaced with animData::clear()
 allocFrame() - replaced with animData::load()
 reserveFrame() - replaced with animData::load()
 
-bg_list.cpp
+bg_list.cpp:
 reincrustAllBg() - removed (obsoleted by new loadResourcesFromSave() and
 	loadBgIncrustFromSave() implementation)
 freeBgIncrustList() - removed (obsoleted by Common::List::clear())
 
-object.cpp
+object.cpp:
 unloadAllMasks() - removed (obsoleted by Common::List::clear())
 resetMessageHead() - removed (obsoleted by Common::List)
 freeOverlay() - removed (duplicate of removeOverlay)
 removeOverlayElement() - renamed to removeOverlay
 loadOverlayElement() - renamed to addOverlay
+
+gfx.cpp:
+gfxInit() - removed (obsoleted by FWRenderer)
+gfxDestroy() - removed (obsoleted by FWRenderer)
+transformColor() - moved to pal.cpp
+transformPaletteRange() - modified and moved to pal.cpp
+gfxCopyRawPage() - removed (obsoleted by FWRenderer)
+gfxFlipRawPage() - removed (obsoleted by FWRenderer::blit() and
+	FWRenderer::refreshPalette())
+fadeToBlack() - removed (obsoleted by FWRenderer::fadeToBlack())
+blitRawScreen() - removed (obsoleted by FWRenderer)
+flip() - removed (obsoleted by FWRenderer::reloadPalette())
+
+bg.cpp:
+loadCt() - split into loadCtFW() and loadCtOS()
+loadBgHigh() - removed (obsoleted by OSRenderer::loadBg256())
+
+texte.cpp:
+computeMessageLength() - replaced with fitLine()
diff --git a/engines/drascula/animation.cpp b/engines/drascula/animation.cpp
index 7c0d167299..a2cd43eac2 100644
--- a/engines/drascula/animation.cpp
+++ b/engines/drascula/animation.cpp
@@ -65,7 +65,7 @@ void DrasculaEngine::animation_1_1() {
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 		color_abc(RED);
-		centra_texto("Transilvanya, 1993 d.c.", 160, 100);
+		centra_texto(_textmisc[_lang][1], 160, 100);
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
@@ -81,15 +81,13 @@ void DrasculaEngine::animation_1_1() {
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 		clearRoom();
-		comienza_sound("s5.als");
+		playSound("s5.als");
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
-		anima("scr2.bin", 17);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("scr2.bin", 17))
 			break;
-		fin_sound_corte();
-		anima("scr3.bin", 17);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		stopSound_corte();
+		if (anima("scr3.bin", 17))
 			break;
 		loadPic("cielo2.alg");
 		decompressPic(dir_zona_pantalla, 256);
@@ -198,11 +196,9 @@ void DrasculaEngine::animation_1_1() {
 		talk_dr_izq(_textd[_lang][3], "d3.als");
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
-		anima("lib.bin", 16);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("lib.bin", 16))
 			break;
-		anima("lib2.bin", 16);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("lib2.bin", 16))
 			break;
 		clearRoom();
 		color_solo = RED;
@@ -219,8 +215,7 @@ void DrasculaEngine::animation_1_1() {
 		talk_solo(_textd[_lang][5], "d5.als");
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
-		anima("lib2.bin", 16);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("lib2.bin", 16))
 			break;
 		clearRoom();
 		loadPic("plan2.alg");
@@ -230,8 +225,7 @@ void DrasculaEngine::animation_1_1() {
 		talk_solo(_textd[_lang][6], "d6.als");
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
-		anima("lib2.bin", 16);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("lib2.bin", 16))
 			break;
 		clearRoom();
 		loadPic("plan3.alg");
@@ -269,23 +263,18 @@ void DrasculaEngine::animation_1_1() {
 		talk_dr_izq(_textd[_lang][10], "d10.als");
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
-		anima("rayo1.bin", 16);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("rayo1.bin", 16))
 			break;
-		comienza_sound("s5.als");
-		anima("rayo2.bin", 15);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		playSound("s5.als");
+		if (anima("rayo2.bin", 15))
 			break;
-		anima("frel2.bin", 16);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("frel2.bin", 16))
 			break;
-		anima("frel.bin", 16);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("frel.bin", 16))
 			break;
-		anima("frel.bin", 16);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("frel.bin", 16))
 			break;
-		fin_sound_corte();
+		stopSound_corte();
 		clearRoom();
 		black();
 		playMusic(23);
@@ -388,18 +377,12 @@ void DrasculaEngine::animation_1_1() {
 }
 
 void DrasculaEngine::talk_dr_grande(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
 	int x_talk[4] = {47, 93, 139, 185};
 	int cara;
 	int l = 0;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(RED);
 
@@ -444,8 +427,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 }
@@ -462,10 +445,12 @@ void DrasculaEngine::animation_2_1() {
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 
-		anima("ag.bin", 14);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("ag.bin", 14))
 			break;
 
+		if (_lang == kSpanish)
+			dir_texto = dir_hare_frente;
+
 		loadPic("an11y13.alg");
 		decompressPic(dir_hare_dch, 1);
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
@@ -475,15 +460,18 @@ void DrasculaEngine::animation_2_1() {
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 
+		if (_lang == kSpanish)
+			dir_texto = dir_hare_dch;
+
 		loadPic("97.alg");
 		decompressPic(dir_hare_dch, 1);
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 
 		pause(4);
-		comienza_sound("s1.als");
+		playSound("s1.als");
 		hipo(18);
-		fin_sound();
+		stopSound();
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 
@@ -524,7 +512,7 @@ void DrasculaEngine::animation_2_1() {
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 
-		strcpy(num_room, "16.alg");
+		roomNumber = 16;
 
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
@@ -545,8 +533,7 @@ void DrasculaEngine::animation_2_1() {
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 
-		anima("lev.bin", 15);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("lev.bin", 15))
 			break;
 
 		lleva_al_hare(100 + ancho_hare / 2, 99 + alto_hare);
@@ -556,28 +543,28 @@ void DrasculaEngine::animation_2_1() {
 		hare_x = 100;
 		hare_y = 95;
 
-		talk_bj(_textbj[_lang][2], "BJ2.als");
-		talk(_text[_lang][215], "215.als");
-		talk_bj(_textbj[_lang][3], "BJ3.als");
-		talk(_text[_lang][216], "216.als");
-		talk_bj(_textbj[_lang][4], "BJ4.als");
-		talk_bj(_textbj[_lang][5], "BJ5.als");
-		talk_bj(_textbj[_lang][6], "BJ6.als");
-		talk(_text[_lang][217], "217.als");
-		talk_bj(_textbj[_lang][7], "BJ7.als");
-		talk(_text[_lang][218], "218.als");
-		talk_bj(_textbj[_lang][8], "BJ8.als");
-		talk(_text[_lang][219], "219.als");
-		talk_bj(_textbj[_lang][9], "BJ9.als");
-		talk(_text[_lang][220], "220.als");
-		talk(_text[_lang][221], "221.als");
-		talk_bj(_textbj[_lang][10], "BJ10.als");
-		talk(_text[_lang][222], "222.als");
-		anima("gaf.bin", 15);
-		anima("bjb.bin", 14);
-		playMusic(9);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		talk_bj(2);
+		talk(215);
+		talk_bj(3);
+		talk(216);
+		talk_bj(4);
+		talk_bj(5);
+		talk_bj(6);
+		talk(217);
+		talk_bj(7);
+		talk(218);
+		talk_bj(8);
+		talk(219);
+		talk_bj(9);
+		talk(220);
+		talk(221);
+		talk_bj(10);
+		talk(222);
+		if (anima("gaf.bin", 15))
+			break;
+		if (anima("bjb.bin", 14))
 			break;
+		playMusic(9);
 		loadPic("97.alg");
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
@@ -616,33 +603,41 @@ void DrasculaEngine::animation_2_1() {
 		pause(60);
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
-		talk(_text[_lang][224], "224.als");
+		talk(224);
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
-		talk_bj(_textbj[_lang][12], "BJ12.als");
+		talk_bj(12);
 		lleva_al_hare(157, 98 + alto_hare);
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
-		anima("bes.bin", 16);
+		if (anima("bes.bin", 16))
+			break;
 		playMusic(11);
-		anima("rap.bin", 16);
-		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
+		if (anima("rap.bin", 16))
 			break;
 		sentido_hare = 3;
-		strcpy(num_room, "no_bj.alg");
+		// The room number was originally changed here to "no_bj.alg",
+		// which doesn't exist. In reality, this was just a hack to
+		// set the room number to a non-existant one, so that BJ does
+		// not appear again when the room is refreshed after the
+		// animation where Count Drascula abducts her. We set the
+		// room number to -1 for the same purpose
+		// Also check animation_9_6(), where the same hack was used by
+		// the original
+		roomNumber = -1;
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 		pause(8);
 		updateRoom();
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-		talk(_text[_lang][225], "225.als");
+		talk(225);
 		pause(76);
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 		sentido_hare = 1;
 		updateRoom();
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-		talk(_text[_lang][226], "226.als");
+		talk(226);
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
 		updateRoom();
@@ -650,13 +645,16 @@ void DrasculaEngine::animation_2_1() {
 		pause(30);
 		if ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE))
 			break;
-		talk(_text[_lang][227],"227.als");
+		talk(227);
 		FundeAlNegro(0);
 		break;
 	}
 }
 
 void DrasculaEngine::animation_3_1() {
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_frente;
+
 	loadPic("an11y13.alg");
 	decompressPic(dir_hare_dch, 1);
 
@@ -683,11 +681,17 @@ void DrasculaEngine::animation_3_1() {
 
 	flags[0] = 1;
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+
 	loadPic("97.alg");
 	decompressPic(dir_hare_dch, 1);
 }
 
 void DrasculaEngine::animation_4_1() {
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_frente;
+
 	loadPic("an12.alg");
 	decompressPic(dir_hare_dch, 1);
 
@@ -720,6 +724,9 @@ void DrasculaEngine::animation_4_1() {
 	talk_pianista(_textp[_lang][4], "p4.als");
 	talk(_text[_lang][209], "209.als");
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+
 	flags[11] = 0;
 	loadPic("97.alg");
 	decompressPic(dir_hare_dch, 1);
@@ -775,7 +782,7 @@ void DrasculaEngine::animation_2_2() {
 	}
 
 	x = 0;
-	comienza_sound("s2.als");
+	playSound("s2.als");
 
 	for (n = 0; n < 6; n++) {
 		x++;
@@ -807,13 +814,13 @@ void DrasculaEngine::animation_2_2() {
 	copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 
-	fin_sound();
+	stopSound();
 
 	pause (4);
 
-	comienza_sound("s1.als");
+	playSound("s1.als");
 	hipo_sin_nadie(12);
-	fin_sound();
+	stopSound();
 }
 
 void DrasculaEngine::animation_3_2() {
@@ -842,6 +849,9 @@ void DrasculaEngine::animation_4_2() {
 	loadPic("ciego5.alg");
 	decompressPic(dir_hare_frente, 1);
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_frente;
+
 	copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 
@@ -868,7 +878,7 @@ void DrasculaEngine::animation_4_2() {
 	talk_ciego(_textd[_lang][75],"d75.als", _textd1[_lang][75 - TEXTD_START]);
 	copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-	_system->delayMillis(1);
+	_system->delayMillis(1000);
 	talk_hacker(_textd[_lang][64], "d64.als");
 	talk_ciego(_textd[_lang][76], "d76.als", _textd1[_lang][76 - TEXTD_START]);
 
@@ -892,6 +902,9 @@ void DrasculaEngine::animation_4_2() {
 	decompressPic(dir_hare_fondo, 1);
 	withoutVerb();
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+
 	flags[9] = 0;
 	flags[4] = 1;
 }
@@ -953,10 +966,10 @@ void DrasculaEngine::animation_14_2() {
 
 	decompressPic(dir_dibujo1, 1);
 
-	comienza_sound("s7.als");
+	playSound("s7.als");
 	hipo(15);
 
-	fin_sound();
+	stopSound();
 
 	loadPic("99.alg");
 	decompressPic(dir_hare_fondo, 1);
@@ -1011,9 +1024,9 @@ void DrasculaEngine::animation_16_2() {
 		goto asco;
 
 	if (_lang == kSpanish)
-		_system->delayMillis(3);
+		_system->delayMillis(3000);
 	else
-		_system->delayMillis(4);
+		_system->delayMillis(4000);
 
 	key = getscan();
 	if (key != 0)
@@ -1038,9 +1051,9 @@ void DrasculaEngine::animation_16_2() {
 		goto asco;
 
 	if (_lang == kSpanish)
-		_system->delayMillis(3);
+		_system->delayMillis(3000);
 	else
-		_system->delayMillis(4);
+		_system->delayMillis(4000);
 
 	key = getscan();
 	if (key != 0)
@@ -1065,9 +1078,9 @@ void DrasculaEngine::animation_16_2() {
 		goto asco;
 
 	if (_lang == kSpanish)
-		_system->delayMillis(3);
+		_system->delayMillis(3000);
 	else
-		_system->delayMillis(4);
+		_system->delayMillis(4000);
 
 	key = getscan();
 	if (key != 0)
@@ -1092,9 +1105,9 @@ void DrasculaEngine::animation_16_2() {
 		goto asco;
 
 	if (_lang == kSpanish)
-		_system->delayMillis(2);
+		_system->delayMillis(2000);
 	else
-		_system->delayMillis(4);
+		_system->delayMillis(4000);
 
 	key = getscan();
 	if (key != 0)
@@ -1116,7 +1129,9 @@ void DrasculaEngine::animation_16_2() {
 asco:
 	loadPic(roomDisk);
 	decompressPic(dir_dibujo3, 1);
-	loadPic(num_room);
+	char rm[20];
+	sprintf(rm, "%i.alg", roomNumber);
+	loadPic(rm);
 	decompressPic(dir_dibujo1, HALF_PAL);
 	black();
 	updateRoom();
@@ -1135,24 +1150,24 @@ void DrasculaEngine::animation_17_2() {
 }
 
 void DrasculaEngine::animation_19_2() {
-	talk_vbpuerta(_textvb[_lang][5], "VB5.als");
+	talk_vbpuerta(5);
 }
 
 void DrasculaEngine::animation_20_2() {
-	talk_vbpuerta(_textvb[_lang][7], "VB7.als");
-	talk_vbpuerta(_textvb[_lang][8], "VB8.als");
-	talk(_text[_lang][383], "383.als");
-	talk_vbpuerta(_textvb[_lang][9], "VB9.als");
-	talk(_text[_lang][384], "384.als");
-	talk_vbpuerta(_textvb[_lang][10], "VB10.als");
-	talk(_text[_lang][385], "385.als");
-	talk_vbpuerta(_textvb[_lang][11], "VB11.als");
+	talk_vbpuerta(7);
+	talk_vbpuerta(8);
+	talk(383);
+	talk_vbpuerta(9);
+	talk(384);
+	talk_vbpuerta(10);
+	talk(385);
+	talk_vbpuerta(11);
 	if (flags[23] == 0) {
-		talk(_text[_lang][350], "350.als");
-		talk_vbpuerta(_textvb[_lang][57], "VB57.als");
+		talk(350);
+		talk_vbpuerta(57);
 	} else {
-		talk(_text[_lang][386], "386.als");
-		talk_vbpuerta(_textvb[_lang][12], "VB12.als");
+		talk(386);
+		talk_vbpuerta(12);
 		flags[18] = 0;
 		flags[14] = 1;
 		openDoor(15, 1);
@@ -1169,7 +1184,7 @@ void DrasculaEngine::animation_20_2() {
 }
 
 void DrasculaEngine::animation_21_2() {
-	talk_vbpuerta(_textvb[_lang][6], "VB6.als");
+	talk_vbpuerta(6);
 }
 
 void DrasculaEngine::animation_23_2() {
@@ -1179,26 +1194,26 @@ void DrasculaEngine::animation_23_2() {
 	flags[21] = 1;
 
 	if (flags[25] == 0) {
-		talk_vb(_textvb[_lang][13], "VB13.als");
-		talk_vb(_textvb[_lang][14], "VB14.als");
+		talk_vb(13);
+		talk_vb(14);
 		pause(10);
-		talk(_text[_lang][387], "387.als");
+		talk(387);
 	}
 
-	talk_vb(_textvb[_lang][15], "VB15.als");
+	talk_vb(15);
 	lleva_vb(42);
 	sentido_vb = 1;
-	talk_vb(_textvb[_lang][16], "VB16.als");
+	talk_vb(16);
 	sentido_vb = 2;
 	lleva_al_hare(157, 147);
 	lleva_al_hare(131, 149);
 	sentido_hare = 0;
 	animation_14_2();
 	if (flags[25] == 0)
-		talk_vb(_textvb[_lang][17], "VB17.als");
+		talk_vb(17);
 	pause(8);
 	sentido_vb = 1;
-	talk_vb(_textvb[_lang][18], "VB18.als");
+	talk_vb(18);
 
 	if (flags[29] == 0)
 		animation_23_anexo();
@@ -1210,9 +1225,9 @@ void DrasculaEngine::animation_23_2() {
 	lleva_vb(99);
 
 	if (flags[29] == 0) {
-		talk_vb(_textvb[_lang][19], "VB19.als");
+		talk_vb(19);
 		if (flags[25] == 0) {
-			talk_vb(_textvb[_lang][20],"VB20.als");
+			talk_vb(20);
 			if (resta_objeto(7) == 0)
 				flags[30] = 1;
 			if (resta_objeto(18) == 0)
@@ -1220,7 +1235,7 @@ void DrasculaEngine::animation_23_2() {
 			if (resta_objeto(19) == 0)
 				flags[32] = 1;
 		}
-		talk_vb(_textvb[_lang][21], "VB21.als");
+		talk_vb(21);
 	} else
 		animation_27_2();
 
@@ -1289,7 +1304,7 @@ void DrasculaEngine::animation_25_2() {
 
 	flags[24] = 0;
 
-	comienza_sound("s6.als");
+	playSound("s6.als");
 
 	for (n = 0; n >= -160; n = n - 8) {
 		copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
@@ -1306,7 +1321,7 @@ void DrasculaEngine::animation_25_2() {
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 	}
 
-	fin_sound();
+	stopSound();
 
 	loadPic("99.alg");
 	decompressPic(dir_hare_fondo, 1);
@@ -1319,63 +1334,63 @@ void DrasculaEngine::animation_27_2() {
 	resta_objeto(23);
 	suma_objeto(11);
 
-	talk_vb(_textvb[_lang][23], "VB23.als");
-	talk_vb(_textvb[_lang][24], "VB24.als");
+	talk_vb(23);
+	talk_vb(24);
 	if (flags[30] == 1)
 		suma_objeto(7);
 	if (flags[31] == 1)
 		suma_objeto(18);
 	if (flags[32] == 1)
 		suma_objeto(19);
-	talk_vb(_textvb[_lang][25],"VB25.als");
-	talk_vb(_textvb[_lang][26],"VB26.als");
+	talk_vb(25);
+	talk_vb(26);
 }
 
 void DrasculaEngine::animation_28_2() {
-	talk_vb(_textvb[_lang][27], "VB27.als");
-	talk_vb(_textvb[_lang][28], "VB28.als");
-	talk_vb(_textvb[_lang][29], "VB29.als");
-	talk_vb(_textvb[_lang][30], "VB30.als");
+	talk_vb(27);
+	talk_vb(28);
+	talk_vb(29);
+	talk_vb(30);
 }
 
 void DrasculaEngine::animation_29_2() {
 	if (flags[33] == 0) {
-		talk_vb(_textvb[_lang][32], "VB32.als");
-		talk(_text[_lang][398], "398.als");
-		talk_vb(_textvb[_lang][33], "VB33.als");
-		talk(_text[_lang][399], "399.als");
-		talk_vb(_textvb[_lang][34], "VB34.als");
-		talk_vb(_textvb[_lang][35], "VB35.als");
-		talk(_text[_lang][400], "400.als");
-		talk_vb(_textvb[_lang][36], "VB36.als");
-		talk_vb(_textvb[_lang][37], "VB37.als");
-		talk(_text[_lang][386], "386.als");
-		talk_vb(_textvb[_lang][38], "VB38.als");
-		talk_vb(_textvb[_lang][39], "VB39.als");
-		talk(_text[_lang][401], "401.als");
-		talk_vb(_textvb[_lang][40], "VB40.als");
-		talk_vb(_textvb[_lang][41], "VB41.als");
+		talk_vb(32);
+		talk(398);
+		talk_vb(33);
+		talk(399);
+		talk_vb(34);
+		talk_vb(35);
+		talk(400);
+		talk_vb(36);
+		talk_vb(37);
+		talk(386);
+		talk_vb(38);
+		talk_vb(39);
+		talk(401);
+		talk_vb(40);
+		talk_vb(41);
 		flags[33] = 1;
 	} else
-		talk_vb(_textvb[_lang][43], "VB43.als");
+		talk_vb(43);
 
-	talk(_text[_lang][402], "402.als");
-	talk_vb(_textvb[_lang][42], "VB42.als");
+	talk(402);
+	talk_vb(42);
 
 	if (flags[38] == 0) {
-		talk(_text[_lang][403], "403.als");
+		talk(403);
 		rompo_y_salgo = 1;
 	} else
-		talk(_text[_lang][386], "386.als");
+		talk(386);
 }
 
 void DrasculaEngine::animation_30_2() {
-	talk_vb(_textvb[_lang][31], "VB31.als");
-	talk(_text[_lang][396], "396.als");
+	talk_vb(31);
+	talk(396);
 }
 
 void DrasculaEngine::animation_31_2() {
-	talk_vb(_textvb[_lang][44], "VB44.als");
+	talk_vb(44);
 	lleva_vb(-50);
 	pause(15);
 	lleva_al_hare(159, 140);
@@ -1389,25 +1404,25 @@ void DrasculaEngine::animation_31_2() {
 	updateRoom();
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 	pause(22);
-	talk(_text[_lang][406], "406.als");
+	talk(406);
 	lleva_vb(98);
-	talk_vb(_textvb[_lang][45], "VB45.als");
-	talk_vb(_textvb[_lang][46], "VB46.als");
-	talk_vb(_textvb[_lang][47], "VB47.als");
-	talk(_text[_lang][407], "407.als");
-	talk_vb(_textvb[_lang][48], "VB48.als");
-	talk_vb(_textvb[_lang][49], "VB49.als");
-	talk(_text[_lang][408], "408.als");
-	talk_vb(_textvb[_lang][50], "VB50.als");
-	talk_vb(_textvb[_lang][51], "VB51.als");
-	talk(_text[_lang][409], "409.als");
-	talk_vb(_textvb[_lang][52], "VB52.als");
-	talk_vb(_textvb[_lang][53], "VB53.als");
+	talk_vb(45);
+	talk_vb(46);
+	talk_vb(47);
+	talk(407);
+	talk_vb(48);
+	talk_vb(49);
+	talk(408);
+	talk_vb(50);
+	talk_vb(51);
+	talk(409);
+	talk_vb(52);
+	talk_vb(53);
 	pause(12);
-	talk_vb(_textvb[_lang][54], "VB54.als");
-	talk_vb(_textvb[_lang][55], "VB55.als");
-	talk(_text[_lang][410], "410.als");
-	talk_vb(_textvb[_lang][56], "VB56.als");
+	talk_vb(54);
+	talk_vb(55);
+	talk(410);
+	talk_vb(56);
 
 	rompo_y_salgo = 1;
 
@@ -1479,9 +1494,9 @@ void DrasculaEngine::animation_35_2() {
 
 	pause(19);
 
-	comienza_sound("s1.als");
+	playSound("s1.als");
 	hipo_sin_nadie(18);
-	fin_sound();
+	stopSound();
 
 	pause(10);
 
@@ -1793,7 +1808,7 @@ void DrasculaEngine::animation_rayo() {
 
 	pause(50);
 
-	comienza_sound("s5.als");
+	playSound("s5.als");
 
 	updateScreen(0, 0, 0, 0, 320, 200, dir_hare_dch);
 	pause(3);
@@ -1806,7 +1821,7 @@ void DrasculaEngine::animation_rayo() {
 	updateScreen(0, 0, 0, 0, 320, 200, dir_dibujo3);
 	pause(3);
 	updateScreen(0, 0, 0, 0, 320, 200, dir_hare_frente);
-	fin_sound();
+	stopSound();
 }
 
 void DrasculaEngine::animation_2_4() {
@@ -1848,26 +1863,26 @@ void DrasculaEngine::animation_7_4() {
 void DrasculaEngine::animation_1_5() {
 	if (flags[0] == 0) {
 		talk(_text[_lang][430], "430.als");
-		talk_bj(_textbj[_lang][16], "BJ16.als");
-		talk_bj(_textbj[_lang][17], "BJ17.als");
-		talk_bj(_textbj[_lang][18], "BJ18.als");
-		talk(_text[_lang][217], "217.als");
-		talk_bj(_textbj[_lang][19], "BJ19.als");
-		talk(_text[_lang][229], "229.als");
+		talk_bj(16);
+		talk_bj(17);
+		talk_bj(18);
+		talk(217);
+		talk_bj(19);
+		talk(229);
 		pause(5);
 		lleva_al_hare(114, 170);
 		sentido_hare = 3;
-		talk(_text[_lang][431], "431.als");
-		talk_bj(_textbj[_lang][20], "BJ20.als");
+		talk(431);
+		talk_bj(20);
 		sentido_hare = 2;
 		pause(4);
-		talk(_text[_lang][438], "438.als");
+		talk(438);
 		sitio_x = 120;
 		sitio_y = 157;
 		anda_a_objeto = 1;
 		sentido_final = 1;
 		empieza_andar();
-		talk_bj(_textbj[_lang][21], "BJ21.als");
+		talk_bj(21);
 
 		for (;;) {
 			if (hare_se_mueve == 0)
@@ -1877,7 +1892,7 @@ void DrasculaEngine::animation_1_5() {
 		}
 
 		sentido_hare = 1;
-		talk(_text[_lang][229], "229.als");
+		talk(229);
 		flags[0] = 1;
 	}
 
@@ -1886,11 +1901,11 @@ void DrasculaEngine::animation_1_5() {
 }
 
 void DrasculaEngine::animation_2_5() {
-	talk_bj(_textbj[_lang][22], "BJ22.als");
+	talk_bj(22);
 }
 
 void DrasculaEngine::animation_3_5() {
-	talk_bj(_textbj[_lang][23], "BJ23.als");
+	talk_bj(23);
 	pickObject(10);
 	rompo_y_salgo = 1;
 }
@@ -1986,8 +2001,8 @@ void DrasculaEngine::animation_5_5(){
 	}
 	updateScreen(0, 0, 0, 0, 320, 200, dir_dibujo1);
 
-	comienza_sound("s1.als");
-	fin_sound();
+	playSound("s1.als");
+	stopSound();
 
 	loadPic("99.alg");
 	decompressPic(dir_hare_fondo, 1);
@@ -2063,7 +2078,7 @@ void DrasculaEngine::animation_12_5() {
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 	pause(27);
 	anima("rayo1.bin", 23);
-	comienza_sound("s5.als");
+	playSound("s5.als");
 	anima("rayo2.bin", 17);
 	sentido_hare = 1;
 	updateRoom();
@@ -2073,9 +2088,9 @@ void DrasculaEngine::animation_12_5() {
 
 	for (color = 0; color < 255; color++)
 		for (componente = 0; componente < 3; componente++) {
-			palFondo1[color][componente] = palJuego[color][componente];
-			palFondo2[color][componente] = palJuego[color][componente];
-			palFondo3[color][componente] = palJuego[color][componente];
+			palFondo1[color][componente] = gamePalette[color][componente];
+			palFondo2[color][componente] = gamePalette[color][componente];
+			palFondo3[color][componente] = gamePalette[color][componente];
 		}
 
 	for (fundido = 1; fundido >= 0; fundido--) {
@@ -2114,13 +2129,13 @@ void DrasculaEngine::animation_12_5() {
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 	}
 
-	fin_sound_corte();
+	stopSound_corte();
 
 	for (frame = 0; frame < 15; frame++) {
 		if (frame == 2 || frame == 4 || frame == 7 || frame == 9)
 			setPalette((byte *)&palFondo1);
 		else if (frame == 1 || frame == 5)
-			setPalette((byte *)&palJuego);
+			setPalette((byte *)&gamePalette);
 		else
 			setPalette((byte *)&palFondo2);
 
@@ -2138,9 +2153,9 @@ void DrasculaEngine::animation_12_5() {
 	flags[1] = 1;
 
 	animation_13_5();
-	comienza_sound("s1.als");
+	playSound("s1.als");
 	hipo(12);
-	fin_sound();
+	stopSound();
 
 	loadPic("99.alg");
 	decompressPic(dir_hare_fondo, 1);
@@ -2204,19 +2219,19 @@ void DrasculaEngine::animation_13_5() {
 
 void DrasculaEngine::animation_14_5() {
 	flags[11] = 1;
-	comienza_sound("s3.als");
+	playSound("s3.als");
 	updateRoom();
 	updateScreen(0, 0, 0,0 , 320, 200, dir_zona_pantalla);
-	fin_sound();
+	stopSound();
 	pause(17);
 	sentido_hare = 3;
 	talk(_text[_lang][246],"246.als");
 	lleva_al_hare(89, 160);
 	flags[10] = 1;
-	comienza_sound("s7.als");
+	playSound("s7.als");
 	updateRoom();
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-	fin_sound();
+	stopSound();
 	pause(14);
 	sentido_hare = 3;
 	updateRoom();
@@ -2313,6 +2328,10 @@ void DrasculaEngine::animation_1_6() {
 	talk_dr_dch(_textd[_lang][34], "d34.als");
 	sentido_dr = 0;
 	talk_dr_izq(_textd[_lang][35], "d35.als");
+
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+
 	clearRoom();
 	carga_escoba("102.ald");
 	activa_pendulo();
@@ -2402,7 +2421,14 @@ void DrasculaEngine::animation_9_6() {
 	hare_x = -1;
 	obj_saliendo = 108;
 	carga_escoba("59.ald");
-	strcpy(num_room, "nada.alg");
+	// The room number was originally changed here to "nada.alg",
+	// which is a non-existant file. In reality, this was just a
+	// hack to set the room number to a non-existant one, so that
+	// room sprites do not appear again when the room is refreshed.
+	// We set the room number to -1 for the same purpose.
+	// Also check animation_2_1(), where the same hack was used
+	// by the original
+	roomNumber = -1;
 	loadPic("nota2.alg");
 	decompressPic(dir_dibujo1, HALF_PAL);
 	black();
@@ -2465,12 +2491,12 @@ void DrasculaEngine::animation_9_6() {
 }
 
 void DrasculaEngine::animation_10_6() {
-	comienza_sound ("s14.als");
+	playSound ("s14.als");
 	copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 	updateRefresh_pre();
 	copyBackground(164, 85, 155, 48, 113, 114, dir_dibujo3, dir_zona_pantalla);
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-	fin_sound();
+	stopSound();
 	talk_taber2(_textt[_lang][23], "t23.als");
 	flags[7] = 1;
 }
@@ -2520,12 +2546,15 @@ void DrasculaEngine::animation_19_6() {
 	pause(6);
 	updateRoom();
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-	comienza_sound("s4.als");
+	playSound("s4.als");
 	pause(6);
-	fin_sound();
+	stopSound();
 }
 
 void DrasculaEngine::animation_12_2() {
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_frente;
+
 	loadPic("an12.alg");
 	decompressPic(dir_hare_dch, 1);
 
@@ -2552,6 +2581,9 @@ void DrasculaEngine::animation_12_2() {
 	talk_pianista(_textp[_lang][5], "P5.als");
 	conversa("op_1.cal");
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+
 	flags[11] = 0;
 	loadPic("974.alg");
 	decompressPic(dir_hare_dch, 1);
@@ -2560,6 +2592,9 @@ void DrasculaEngine::animation_12_2() {
 void DrasculaEngine::animation_26_2() {
 	int n, x = 0;
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_frente;
+
 	loadPic("an12.alg");
 	decompressPic(dir_hare_dch, 1);
 
@@ -2606,11 +2641,11 @@ void DrasculaEngine::animation_26_2() {
 		updateScreen(225, 113, 225, 113, 50, 59, dir_zona_pantalla);
 		x = x + 50;
 		if (n == 2)
-			comienza_sound("s9.als");
+			playSound("s9.als");
 		pause(3);
 	}
 
-	fin_sound_corte();
+	stopSound_corte();
 	x = 0;
 	for (n = 0; n < 6; n++) {
 		x++;
@@ -2623,6 +2658,9 @@ void DrasculaEngine::animation_26_2() {
 	pickObject(11);
 	resta_objeto(12);
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+
 	flags[11] = 0;
 	flags[39] = 1;
 	loadPic("974.alg");
@@ -2631,6 +2669,9 @@ void DrasculaEngine::animation_26_2() {
 }
 
 void DrasculaEngine::animation_11_2() {
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_frente;
+
 	loadPic("an11y13.alg");
 	decompressPic(dir_hare_dch, 1);
 
@@ -2644,6 +2685,9 @@ void DrasculaEngine::animation_11_2() {
 	pause(40);
 	talk_tabernero("No, nada", "d82.als");
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+
 	loadPic("974.alg");
 	decompressPic(dir_hare_dch, 1);
 }
@@ -2671,8 +2715,8 @@ void DrasculaEngine::animation_13_2() {
 }
 
 void DrasculaEngine::animation_18_2() {
-	talk(_text[_lang][378], "378.als");
-	talk_vbpuerta(_textvb[_lang][4], "VB4.als");
+	talk(378);
+	talk_vbpuerta(4);
 	conversa("op_3.cal");
 }
 
@@ -2682,15 +2726,15 @@ void DrasculaEngine::animation_22_2() {
 	sentido_hare=2;
 	updateRoom();
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-	comienza_sound("s13.als");
-	fin_sound();
+	playSound("s13.als");
+	stopSound();
 	sentido_hare = 1;
 
-	talk_vbpuerta(_textvb[_lang][1], "VB1.als");
-	talk(_text[_lang][375], "375.als");
-	talk_vbpuerta(_textvb[_lang][2], "VB2.als");
-	talk(_text[_lang][376], "376.als");
-	talk_vbpuerta(_textvb[_lang][3], "VB3.als");
+	talk_vbpuerta(1);
+	talk(375);
+	talk_vbpuerta(2);
+	talk(376);
+	talk_vbpuerta(3);
 
 	flags[18] = 1;
 }
@@ -2703,7 +2747,7 @@ void DrasculaEngine::animation_24_2() {
 	pause(3);
 	sentido_hare = 0;
 
-	talk(_text[_lang][356], "356.als");
+	talk(356);
 
 	loadPic("an24.alg");
 	decompressPic(dir_hare_frente, 1);
@@ -2712,7 +2756,7 @@ void DrasculaEngine::animation_24_2() {
 
 	flags[21] = 1;
 
-	talk_vb(_textvb[_lang][22], "VB22.als");
+	talk_vb(22);
 
 	if (flags[22] == 0)
 		conversa("op_4.cal");
@@ -2805,7 +2849,7 @@ void DrasculaEngine::animation_34_2() {
 	}
 
 	x = 0;
-	comienza_sound("s8.als");
+	playSound("s8.als");
 
 	for (n = 0; n < 3; n++) {
 		x++;
@@ -2814,7 +2858,7 @@ void DrasculaEngine::animation_34_2() {
 		x = x + 83;
 		pause(3);
 	}
-	fin_sound();
+	stopSound();
 
 	pause(30);
 
@@ -2829,6 +2873,9 @@ void DrasculaEngine::animation_34_2() {
 }
 
 void DrasculaEngine::animation_36_2() {
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_frente;
+
 	loadPic("an11y13.alg");
 	decompressPic(dir_hare_dch, 1);
 
@@ -2840,6 +2887,9 @@ void DrasculaEngine::animation_36_2() {
 	pause(40);
 	talk_tabernero("No, nada", "d82.als");
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+
 	loadPic("974.alg");
 	decompressPic(dir_hare_dch, 1);
 }
@@ -3166,7 +3216,7 @@ void DrasculaEngine::animation_5_2() {
 		pause(3);
 	}
 
-	comienza_sound("s1.als");
+	playSound("s1.als");
 
 	x = 0;
 
@@ -3177,7 +3227,7 @@ void DrasculaEngine::animation_5_2() {
 		x = x + 52;
 		pause(3);
 	}
-	fin_sound_corte();
+	stopSound_corte();
 
 	x = 0;
 
@@ -3207,6 +3257,9 @@ void DrasculaEngine::animation_6_2() {
 	stopMusic();
 	flags[9] = 1;
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_frente;
+
 	clearRoom();
 	loadPic("ciego1.alg");
 	decompressPic(dir_dibujo1, HALF_PAL);
@@ -3251,6 +3304,9 @@ void DrasculaEngine::animation_6_2() {
 	decompressPic(dir_hare_fondo, 1);
 	withoutVerb();
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+
 	flags[9] = 0;
 }
 
@@ -3274,6 +3330,9 @@ void DrasculaEngine::animation_33_2() {
 	loadPic("ciego5.alg");
 	decompressPic(dir_hare_frente, 1);
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_frente;
+
 	copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 
@@ -3307,6 +3366,9 @@ void DrasculaEngine::animation_33_2() {
 	decompressPic(dir_hare_fondo, 1);
 	withoutVerb();
 
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+
 	flags[33] = 1;
 	flags[9] = 0;
 }
@@ -3400,10 +3462,9 @@ void DrasculaEngine::animation_5_4(){
 }
 
 void DrasculaEngine::animation_6_4() {
-	char room[13];
+	int prevRoom = roomNumber;
 
-	strcpy(room, num_room);
-	strcpy(num_room, "26.alg");
+	roomNumber = 26;
 	clearRoom();
 	loadPic("26.alg");
 	decompressPic(dir_dibujo1, HALF_PAL);
@@ -3419,13 +3480,15 @@ void DrasculaEngine::animation_6_4() {
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 	pause(40);
 	talk_igor_frente(_texti[_lang][26], "I26.als");
-	strcpy(num_room, room);
+	roomNumber = prevRoom;
 	clearRoom();
 	loadPic("96.alg");
 	decompressPic(dir_hare_frente, 1);
 	loadPic(roomDisk);
 	decompressPic(dir_dibujo3, 1);
-	loadPic(num_room);
+	char rm[20];
+	sprintf(rm, "%i.alg", roomNumber);
+	loadPic(rm);
 	decompressPic(dir_dibujo1, HALF_PAL);
 	withoutVerb();
 	updateRoom();
diff --git a/engines/drascula/detection.cpp b/engines/drascula/detection.cpp
index 80ea4f0eab..b3d8d964c8 100644
--- a/engines/drascula/detection.cpp
+++ b/engines/drascula/detection.cpp
@@ -58,6 +58,10 @@ uint16 DrasculaEngine::getVersion() const {
 	return _gameDescription->version;
 }
 
+Common::Language DrasculaEngine::getLanguage() const {
+	return _gameDescription->desc.language;
+}
+
 }
 
 static const PlainGameDescriptor drasculaGames[] = {
@@ -75,7 +79,7 @@ static const DrasculaGameDescription gameDescriptions[] = {
 		{
 			"drascula",
 			0,
-			AD_ENTRY1("14.ald", "09b2735953edcd43af115c65ae00b10e"),
+			AD_ENTRY1s("14.ald", "09b2735953edcd43af115c65ae00b10e", 1595),
 			Common::EN_ANY,
 			Common::kPlatformPC,
 			Common::ADGF_NO_FLAGS
@@ -85,13 +89,13 @@ static const DrasculaGameDescription gameDescriptions[] = {
 		0,
 		0,
 	},
-/*
+
 	{
 		// Drascula Spanish version
 		{
 			"drascula",
 			0,
-			AD_ENTRY1("14.ald", "0746ed1a5cc8d9728f790c29813f4b43"),
+			AD_ENTRY1s("14.ald", "0746ed1a5cc8d9728f790c29813f4b43", 23059),
 			Common::ES_ESP,
 			Common::kPlatformPC,
 			Common::ADGF_NO_FLAGS
@@ -100,7 +104,55 @@ static const DrasculaGameDescription gameDescriptions[] = {
 		0,
 		0,
 		0,
-	},*/
+	},
+
+	{
+		// Drascula German version
+		{
+			"drascula",
+			0,
+			AD_ENTRY1s("14.ald", "72e46089033d56bad1c179ac36e2a9d2", 610),
+			Common::DE_DEU,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		0,
+		0,
+		0,
+		0,
+	},
+
+	{
+		// Drascula French version
+		{
+			"drascula",
+			0,
+			AD_ENTRY1s("14.ald", "eeeee96b82169003630e08992248296c", 608),
+			Common::FR_FRA,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		0,
+		0,
+		0,
+		0,
+	},
+
+	{
+		// Drascula Italian version
+		{
+			"drascula",
+			0,
+			AD_ENTRY1s("14.ald", "02b49a18328d0bf2efe6ba658c9c7a1d", 2098),
+			Common::IT_ITA,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		0,
+		0,
+		0,
+		0,
+	},
 
 	{ AD_TABLE_END_MARKER, 0, 0, 0, 0 }
 };
@@ -182,7 +234,8 @@ const Common::ADGameDescription *DrasculaMetaEngine::fallbackDetect(const FSList
 	Drascula::g_fallbackDesc.features = 0;
 	Drascula::g_fallbackDesc.version = 0;
 
-	return (const Common::ADGameDescription *)&Drascula::g_fallbackDesc;
+	//return (const Common::ADGameDescription *)&Drascula::g_fallbackDesc;
+	return NULL;
 }
 
 #if PLUGIN_ENABLED_DYNAMIC(DRASCULA)
diff --git a/engines/drascula/drascula.cpp b/engines/drascula/drascula.cpp
index d6b1904689..5c274b1ef0 100644
--- a/engines/drascula/drascula.cpp
+++ b/engines/drascula/drascula.cpp
@@ -79,16 +79,30 @@ DrasculaEngine::~DrasculaEngine() {
 	delete _rnd;
 }
 
-static const int x_obj[44] = {0, X_OBJ1, X_OBJ2, X_OBJ3, X_OBJ4, X_OBJ5, X_OBJ6, X_OBJ7, X_OBJ8, X_OBJ9, X_OBJ10,
-				X_OBJ11, X_OBJ12, X_OBJ13, X_OBJ14, X_OBJ15, X_OBJ16, X_OBJ17, X_OBJ18, X_OBJ19, X_OBJ20,
-				X_OBJ21, X_OBJ22, X_OBJ23, X_OBJ24, X_OBJ25, X_OBJ26, X_OBJ27, X_OBJ28, X_OBJ29, X_OBJ30,
-				X_OBJ31, X_OBJ32, X_OBJ33, X_OBJ34, X_OBJ35, X_OBJ36, X_OBJ37, X_OBJ38, X_OBJ39, X_OBJ40,
-				X_OBJ41, X_OBJ42, X_OBJ43};
-static const int y_obj[44] = {0, Y_OBJ1, Y_OBJ2, Y_OBJ3, Y_OBJ4, Y_OBJ5, Y_OBJ6, Y_OBJ7, Y_OBJ8, Y_OBJ9, Y_OBJ10,
-				Y_OBJ11, Y_OBJ12, Y_OBJ13, Y_OBJ14, Y_OBJ15, Y_OBJ16, Y_OBJ17, Y_OBJ18, Y_OBJ19, Y_OBJ20,
-				Y_OBJ21, Y_OBJ22, Y_OBJ23, Y_OBJ24, Y_OBJ25, Y_OBJ26, Y_OBJ27, Y_OBJ28, Y_OBJ29, Y_OBJ30,
-				Y_OBJ31, Y_OBJ32, Y_OBJ33, Y_OBJ34, Y_OBJ35, Y_OBJ36, Y_OBJ37, Y_OBJ38, Y_OBJ39, Y_OBJ40,
-				Y_OBJ41, Y_OBJ42, Y_OBJ43};
+struct ItemLocation {
+	int x;
+	int y;
+};
+
+ItemLocation itemLocations[] = {
+	{   0,   0 },							  // empty
+	{   5,  10 }, {  50,  10 }, {  95,  10 }, // 1-3
+	{ 140,  10 }, { 185,  10 }, { 230,  10 }, // 4-6
+	{ 275,  10 }, {   5,  40 }, {  50,  40 }, // 7-9
+	{  95,  40 }, { 140,  40 }, { 185,  40 }, // 10-12
+	{ 230,  40 }, { 275,  40 }, {   5,  70 }, // 13-15
+	{  50,  70 }, {  95,  70 }, { 140,  70 }, // 16-18
+	{ 185,  70 }, { 230,  70 }, { 275,  70 }, // 19-21
+	{   5, 100 }, {  50, 100 }, {  95, 100 }, // 22-24
+	{ 140, 100 }, { 185, 100 }, { 230, 100 }, // 25-27
+	{ 275, 100 }, {   5, 130 }, {  50, 130 }, // 28-30
+	{  95, 130 }, { 140, 130 }, { 185, 130 }, // 31-33
+	{ 230, 130 }, { 275, 130 }, {   5, 160 }, // 34-36
+	{  50, 160 }, {  95, 160 }, { 140, 160 }, // 37-39
+	{ 185, 160 }, { 230, 160 }, { 275, 160 }, // 40-42
+	{ 275, 160 }							  // 43
+};
+
 static const int x_pol[44] = {0, 1, 42, 83, 124, 165, 206, 247, 83, 1, 206,
 				1, 42, 83, 124, 165, 206, 247, 83, 1, 206,
 				247, 83, 165, 1, 206, 42, 124, 83, 1, 247,
@@ -114,6 +128,27 @@ int DrasculaEngine::init() {
 	_system->initSize(320, 200);
 	_system->endGFXTransaction();
 
+	switch (getLanguage()) {
+	case Common::EN_ANY:
+		_lang = 0;
+		break;
+	case Common::ES_ESP:
+		_lang = 1;
+		break;
+	case Common::DE_DEU:
+		_lang = 2;
+		break;
+	case Common::FR_FRA:
+		_lang = 3;
+		break;
+	case Common::IT_ITA:
+		_lang = 4;
+		break;
+	default:
+		warning("Unknown game language. Falling back to English");
+		_lang = 0;
+	}
+
 	return 0;
 }
 
@@ -137,7 +172,7 @@ int DrasculaEngine::go() {
 		step_x = PASO_HARE_X; step_y = PASO_HARE_Y;
 		alto_hare = CHARACTER_HEIGHT; ancho_hare = CHARACTER_WIDTH; alto_pies = PIES_HARE;
 		alto_talk = ALTO_TALK_HARE; ancho_talk = ANCHO_TALK_HARE;
-		hay_respuesta = 0;
+		hay_answer = 0;
 		conta_ciego_vez = 0;
 		cambio_de_color = 0;
 		rompo_y_salgo = 0;
@@ -334,7 +369,7 @@ void DrasculaEngine::paleta_hare() {
 
 	for (color = 235; color < 253; color++)
 		for (componente = 0; componente < 3; componente++)
-			palHare[color][componente] = palJuego[color][componente];
+			palHare[color][componente] = gamePalette[color][componente];
 }
 
 void DrasculaEngine::hare_oscuro() {
@@ -342,7 +377,7 @@ void DrasculaEngine::hare_oscuro() {
 
 	for (color = 235; color < 253; color++ )
 		for (componente = 0; componente < 3; componente++)
-			palJuego[color][componente] = palHareOscuro[color][componente];
+			gamePalette[color][componente] = palHareOscuro[color][componente];
 
 	updatePalette();
 }
@@ -351,9 +386,9 @@ void DrasculaEngine::setRGB(byte *dir_lectura, int plt) {
 	int x, cnt = 0;
 
 	for (x = 0; x < plt; x++) {
-		palJuego[x][0] = dir_lectura[cnt++] / 4;
-		palJuego[x][1] = dir_lectura[cnt++] / 4;
-		palJuego[x][2] = dir_lectura[cnt++] / 4;
+		gamePalette[x][0] = dir_lectura[cnt++] / 4;
+		gamePalette[x][1] = dir_lectura[cnt++] / 4;
+		gamePalette[x][2] = dir_lectura[cnt++] / 4;
 	}
 	updatePalette();
 }
@@ -374,7 +409,7 @@ void DrasculaEngine::black() {
 }
 
 void DrasculaEngine::updatePalette() {
-	setPalette((byte *)&palJuego);
+	setPalette((byte *)&gamePalette);
 }
 
 void DrasculaEngine::setPalette(byte *PalBuf) {
@@ -393,10 +428,9 @@ void DrasculaEngine::setPalette(byte *PalBuf) {
 
 void DrasculaEngine::copyBackground(int xorg, int yorg, int xdes, int ydes, int width,
 								  int height, byte *src, byte *dest) {
-	int x;
 	dest += xdes + ydes * 320;
 	src += xorg + yorg * 320;
-	for (x = 0; x < height; x++) {
+	for (int x = 0; x < height; x++) {
 		memcpy(dest, src, width);
 		dest += 320;
 		src += 320;
@@ -450,12 +484,11 @@ void DrasculaEngine::copyRectClip(int *Array, byte *src, byte *dest) {
 }
 
 void DrasculaEngine::updateScreen(int xorg, int yorg, int xdes, int ydes, int width, int height, byte *buffer) {
-	int x;
 	byte *ptr = VGA;
 
 	ptr += xdes + ydes * 320;
 	buffer += xorg + yorg * 320;
-	for (x = 0; x < height; x++) {
+	for (int x = 0; x < height; x++) {
 		memcpy(ptr, buffer, width);
 		ptr += 320;
 		buffer += 320;
@@ -468,7 +501,10 @@ void DrasculaEngine::updateScreen(int xorg, int yorg, int xdes, int ydes, int wi
 bool DrasculaEngine::escoba() {
 	int n;
 
-	dir_texto = dir_mesa;
+	if (_lang == kSpanish)
+		dir_texto = dir_hare_dch;
+	else
+		dir_texto = dir_mesa;
 
 	previousMusic = -1;
 
@@ -481,7 +517,7 @@ bool DrasculaEngine::escoba() {
 	}
 
 	for (n = 1; n < 43; n++)
-		objetos_que_tengo[n] = 0;
+		inventoryObjects[n] = 0;
 
 	for (n = 0; n < NUM_FLAGS; n++)
 		flags[n] = 0;
@@ -493,7 +529,7 @@ bool DrasculaEngine::escoba() {
 	}
 
 	for (n = 1; n < 7; n++)
-		objetos_que_tengo[n] = n;
+		inventoryObjects[n] = n;
 
 	if (num_ejec == 1) {
 		pickObject(28);
@@ -609,11 +645,11 @@ bucles:
 	}
 
 	if (num_ejec == 2) {
-		if ((!strcmp(num_room, "3.alg")) && (hare_x == 279) && (hare_y + alto_hare == 101))
+		if (roomNumber == 3 && (hare_x == 279) && (hare_y + alto_hare == 101))
 			animation_1_2();
-		else if ((!strcmp(num_room, "14.alg")) && (hare_x == 214) && (hare_y + alto_hare == 121))
+		else if (roomNumber == 14 && (hare_x == 214) && (hare_y + alto_hare == 121))
 			lleva_al_hare(190, 130);
-		else if ((!strcmp(num_room, "14.alg")) && (hare_x == 246) && (hare_y + alto_hare == 112))
+		else if (roomNumber == 14 && (hare_x == 246) && (hare_y + alto_hare == 112))
 			lleva_al_hare(190, 130);
 	}
 
@@ -633,20 +669,20 @@ bucles:
 	if (menu_scr == 0 && lleva_objeto == 1)
 		comprueba_objetos();
 
-	if (boton_dch == 1 && menu_scr == 1) {
+	if (button_dch == 1 && menu_scr == 1) {
 		delay(100);
 		if (num_ejec == 2)
 			loadPic(fondo_y_menu);
 		else
 			loadPic("99.alg");
 		decompressPic(dir_hare_fondo, 1);
-		setPalette((byte *)&palJuego);
+		setPalette((byte *)&gamePalette);
 		menu_scr = 0;
 		espera_soltar();
 		if (num_ejec != 3)
 			cont_sv = 0;
 	}
-	if (boton_dch == 1 && menu_scr == 0) {
+	if (button_dch == 1 && menu_scr == 0) {
 		delay(100);
 		hare_se_mueve = 0;
 		if (sentido_hare == 2)
@@ -667,25 +703,25 @@ bucles:
 			cont_sv = 0;
 	}
 
-	if (boton_izq == 1 && menu_bar == 1) {
+	if (button_izq == 1 && menu_bar == 1) {
 		delay(100);
 		elige_en_barra();
 		if (num_ejec != 3)
 			cont_sv = 0;
-	} else if (boton_izq == 1 && lleva_objeto == 0) {
+	} else if (button_izq == 1 && lleva_objeto == 0) {
 		delay(100);
 		if (comprueba1())
 			return true;
 		if (num_ejec != 3)
 			cont_sv = 0;
-	} else if (boton_izq == 1 && lleva_objeto == 1) {
+	} else if (button_izq == 1 && lleva_objeto == 1) {
 		if (comprueba2())
 			return true;
 		if (num_ejec != 3)
 			cont_sv = 0;
 	}
 
-	if (y_raton < 24 && menu_scr == 0)
+	if (mouseY < 24 && menu_scr == 0)
 		menu_bar = 1;
 	else
 		menu_bar = 0;
@@ -746,7 +782,7 @@ bucles:
 			return false;
 		if (num_ejec != 3)
 			cont_sv = 0;
-	} else if (num_ejec == 6 && key == Common::KEYCODE_0 && !strcmp(num_room, "61.alg")) {
+	} else if (num_ejec == 6 && key == Common::KEYCODE_0 && roomNumber == 61) {
 		 loadPic("alcbar.alg");
 		 decompressPic(dir_dibujo1, 255);
 	} else if (cont_sv == 1500) {
@@ -780,32 +816,29 @@ void DrasculaEngine::pickObject(int objeto) {
 
 void DrasculaEngine::chooseObject(int objeto) {
 	if (num_ejec == 5) {
-		if (lleva_objeto == 1 && menu_scr == 0 && objeto_que_lleva != 16)
-			suma_objeto(objeto_que_lleva);
+		if (lleva_objeto == 1 && menu_scr == 0 && pickedObject != 16)
+			suma_objeto(pickedObject);
 	} else {
 		if (lleva_objeto == 1 && menu_scr == 0)
-			suma_objeto(objeto_que_lleva);
+			suma_objeto(pickedObject);
 	}
 	copyBackground(x1d_menu[objeto], y1d_menu[objeto], 0, 0, OBJWIDTH,OBJHEIGHT, dir_hare_fondo, dir_dibujo3);
 	lleva_objeto = 1;
-	objeto_que_lleva = objeto;
+	pickedObject = objeto;
 }
 
 int DrasculaEngine::resta_objeto(int osj) {
-	int h, q = 0;
+	int result = 1;
 
-	for (h = 1; h < 43; h++) {
-		if (objetos_que_tengo[h] == osj) {
-			objetos_que_tengo[h] = 0;
-			q = 1;
+	for (int h = 1; h < 43; h++) {
+		if (inventoryObjects[h] == osj) {
+			inventoryObjects[h] = 0;
+			result = 0;
 			break;
 		}
 	}
 
-	if (q == 1)
-		return 0;
-	else
-		return 1;
+	return result;
 }
 
 void DrasculaEngine::withoutVerb() {
@@ -813,11 +846,11 @@ void DrasculaEngine::withoutVerb() {
 	if (menu_scr == 1)
 		c = 0;
 	if (num_ejec == 5) {
-		if (lleva_objeto == 1 && objeto_que_lleva != 16)
-			suma_objeto(objeto_que_lleva);
+		if (lleva_objeto == 1 && pickedObject != 16)
+			suma_objeto(pickedObject);
 	} else {
 		if (lleva_objeto == 1)
-			suma_objeto(objeto_que_lleva);
+			suma_objeto(pickedObject);
 	}
 	copyBackground(0, c, 0, 0, OBJWIDTH,OBJHEIGHT, dir_hare_fondo, dir_dibujo3);
 
@@ -852,9 +885,7 @@ static char *getLine(Common::File *fp, char *buf, int len) {
 			c = ~fp->readByte();
 			if (c == '\r')
 				continue;
-			if (c == '\n')
-				break;
-			if (b - buf >= (len - 1))
+			if (c == '\n' || b - buf >= (len - 1))
 				break;
 			*b++ = c;
 		}
@@ -886,8 +917,7 @@ void DrasculaEngine::carga_escoba(const char *nom_fich) {
 	}
 	int size = ald->size();
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%s", num_room);
-	strcat(num_room, ".alg");
+	roomNumber = atoi(buffer);
 
 	getLine(ald, buffer, size);
 	sscanf(buffer, "%d", &roomMusic);
@@ -1024,7 +1054,9 @@ martini:
 	loadPic(roomDisk);
 	decompressPic(dir_dibujo3, 1);
 
-	loadPic(num_room);
+	char rm[20];
+	sprintf(rm, "%i.alg", roomNumber);
+	loadPic(rm);
 	decompressPic(dir_dibujo1, HALF_PAL);
 
 	copyBackground(0, 171, 0, 0, OBJWIDTH, OBJHEIGHT, dir_hare_fondo, dir_dibujo3);
@@ -1056,14 +1088,14 @@ martini:
 		}
 	}
 
-	if (!strcmp(num_room, "24.alg")) {
+	if (roomNumber == 24) {
 		for (l = suelo_y1 - 1; l > 74; l--) {
 			factor_red[l] = (int)(far - pequegnez);
 			pequegnez = pequegnez + chiquez;
 		}
 	}
 
-	if (num_ejec == 5 && !strcmp(num_room, "54.alg")) {
+	if (num_ejec == 5 && roomNumber == 54) {
 		for (l = suelo_y1 - 1; l > 84; l--) {
 			factor_red[l] = (int)(far - pequegnez);
 			pequegnez = pequegnez + chiquez;
@@ -1101,13 +1133,13 @@ martini:
 		isDoor[7] = 0;
 
 	if (num_ejec == 2) {
-		if (!strcmp(num_room, "14.alg") && flags[39] == 1)
+		if (roomNumber == 14 && flags[39] == 1)
 			roomMusic = 16;
-		else if (!strcmp(num_room, "15.alg") && flags[39] == 1)
+		else if (roomNumber == 15 && flags[39] == 1)
 			roomMusic = 16;
-		if (!strcmp(num_room, "14.alg") && flags[5] == 1)
+		if (roomNumber == 14 && flags[5] == 1)
 			roomMusic = 0;
-		else if (!strcmp(num_room, "15.alg") && flags[5] == 1)
+		else if (roomNumber == 15 && flags[5] == 1)
 			roomMusic = 0;
 
 		if (previousMusic != roomMusic && roomMusic != 0)
@@ -1120,21 +1152,21 @@ martini:
 	}
 
 	if (num_ejec == 2) {
-		if ((!strcmp(num_room, "9.alg")) || (strcmp(num_room, "2.alg")) || (!strcmp(num_room, "14.alg")) || (!strcmp(num_room, "18.alg")))
+		if (roomNumber == 9 || roomNumber == 2 || roomNumber == 14 || roomNumber == 18)
 			conta_ciego_vez = vez();
 	}
 	if (num_ejec == 4) {
-		if (!strcmp(num_room, "26.alg"))
+		if (roomNumber == 26)
 			conta_ciego_vez = vez();
 	}
 
-	if (num_ejec == 4 && !strcmp(num_room, "24.alg") && flags[29] == 1)
+	if (num_ejec == 4 && roomNumber == 24 && flags[29] == 1)
 		animation_7_4();
 
 	if (num_ejec == 5) {
-		if (!strcmp(num_room, "45.alg"))
+		if (roomNumber == 45)
 			hare_se_ve = 0;
-		if (!strcmp(num_room, "49.alg") && flags[7] == 0)
+		if (roomNumber == 49 && flags[7] == 0)
 			animation_4_5();
 	}
 
@@ -1190,7 +1222,7 @@ void DrasculaEngine::mueve_cursor() {
 	} else if (menu_scr == 0 && _color != LIGHT_GREEN)
 		color_abc(LIGHT_GREEN);
 	if (hay_nombre == 1 && menu_scr == 0)
-		centra_texto(texto_nombre, x_raton, y_raton);
+		centra_texto(texto_nombre, mouseX, mouseY);
 	if (menu_scr == 1)
 		menu_sin_volcar();
 	else if (menu_bar == 1)
@@ -1198,8 +1230,8 @@ void DrasculaEngine::mueve_cursor() {
 
 	pos_cursor[0] = 0;
 	pos_cursor[1] = 0;
-	pos_cursor[2] = x_raton - 20;
-	pos_cursor[3] = y_raton - 17;
+	pos_cursor[2] = mouseX - 20;
+	pos_cursor[3] = mouseY - 17;
 	pos_cursor[4] = OBJWIDTH;
 	pos_cursor[5] = OBJHEIGHT;
 	copyRectClip(pos_cursor, dir_dibujo3, dir_zona_pantalla);
@@ -1209,8 +1241,8 @@ void DrasculaEngine::comprueba_objetos() {
 	int l, veo = 0;
 
 	for (l = 0; l < numRoomObjs; l++) {
-		if (x_raton > x1[l] && y_raton > y1[l]
-				&& x_raton < x2[l] && y_raton < y2[l]
+		if (mouseX > x1[l] && mouseY > y1[l]
+				&& mouseX < x2[l] && mouseY < y2[l]
 				&& visible[l] == 1 && isDoor[l] == 0) {
 			strcpy(texto_nombre, objName[l]);
 			hay_nombre = 1;
@@ -1219,15 +1251,15 @@ void DrasculaEngine::comprueba_objetos() {
 	}
 
 	if (num_ejec == 2) {
-		if (x_raton > hare_x + 2 && y_raton > hare_y + 2
-				&& x_raton < hare_x + ancho_hare - 2 && y_raton < hare_y + alto_hare - 2) {
+		if (mouseX > hare_x + 2 && mouseY > hare_y + 2
+				&& mouseX < hare_x + ancho_hare - 2 && mouseY < hare_y + alto_hare - 2) {
 			strcpy(texto_nombre, "hacker");
 			hay_nombre = 1;
 			veo = 1;
 		}
 	} else {
-		if (x_raton > hare_x + 2 && y_raton > hare_y + 2
-				&& x_raton < hare_x + ancho_hare - 2 && y_raton < hare_y + alto_hare - 2 && veo == 0) {
+		if (mouseX > hare_x + 2 && mouseY > hare_y + 2
+				&& mouseX < hare_x + ancho_hare - 2 && mouseY < hare_y + alto_hare - 2 && veo == 0) {
 			strcpy(texto_nombre, "hacker");
 			hay_nombre = 1;
 			veo = 1;
@@ -1250,7 +1282,7 @@ void DrasculaEngine::elige_en_barra() {
 	int n, num_verbo = -1;
 
 	for (n = 0; n < 7; n++)
-		if (x_raton > x_barra[n] && x_raton < x_barra[n + 1])
+		if (mouseX > x_barra[n] && mouseX < x_barra[n + 1])
 			num_verbo = n;
 
 	if (num_verbo < 1)
@@ -1266,8 +1298,8 @@ bool DrasculaEngine::comprueba1() {
 		saca_objeto();
 	else {
 		for (l = 0; l < numRoomObjs; l++) {
-			if (x_raton >= x1[l] && y_raton >= y1[l]
-					&& x_raton <= x2[l] && y_raton <= y2[l] && rompo == 0) {
+			if (mouseX >= x1[l] && mouseY >= y1[l]
+					&& mouseX <= x2[l] && mouseY <= y2[l] && rompo == 0) {
 				if (sal_de_la_habitacion(l))
 					return true;
 				if (rompo == 1)
@@ -1275,13 +1307,13 @@ bool DrasculaEngine::comprueba1() {
 			}
 		}
 
-		if (x_raton > hare_x && y_raton > hare_y
-				&& x_raton < hare_x + ancho_hare && y_raton < hare_y + alto_hare)
+		if (mouseX > hare_x && mouseY > hare_y
+				&& mouseX < hare_x + ancho_hare && mouseY < hare_y + alto_hare)
 			rompo = 1;
 
 		for (l = 0; l < numRoomObjs; l++) {
-			if (x_raton > x1[l] && y_raton > y1[l]
-					&& x_raton < x2[l] && y_raton < y2[l] && rompo == 0) {
+			if (mouseX > x1[l] && mouseY > y1[l]
+					&& mouseX < x2[l] && mouseY < y2[l] && rompo == 0) {
 				sitio_x = sitiobj_x[l];
 				sitio_y = sitiobj_y[l];
 				sentido_final = sentidobj[l];
@@ -1292,8 +1324,8 @@ bool DrasculaEngine::comprueba1() {
 		}
 
 		if (rompo == 0) {
-			sitio_x = x_raton;
-			sitio_y = y_raton;
+			sitio_x = mouseX;
+			sitio_y = mouseY;
 
 			if (sitio_x < suelo_x1)
 				sitio_x = suelo_x1;
@@ -1324,8 +1356,8 @@ bool DrasculaEngine::comprueba2() {
 				return true;
 		} else {
 			for (l = 0; l < numRoomObjs; l++) {
-				if (x_raton > x1[l] && y_raton > y1[l]
-						&& x_raton < x2[l] && y_raton < y2[l] && visible[l] == 1) {
+				if (mouseX > x1[l] && mouseY > y1[l]
+						&& mouseX < x2[l] && mouseY < y2[l] && visible[l] == 1) {
 					sentido_final = sentidobj[l];
 					anda_a_objeto = 1;
 					lleva_al_hare(sitiobj_x[l], sitiobj_y[l]);
@@ -1362,20 +1394,20 @@ void DrasculaEngine::updateEvents() {
 			_keyPressed.keycode = Common::KEYCODE_INVALID;
 			break;
 		case Common::EVENT_MOUSEMOVE:
-			x_raton = event.mouse.x;
-			y_raton = event.mouse.y;
+			mouseX = event.mouse.x;
+			mouseY = event.mouse.y;
 			break;
 		case Common::EVENT_LBUTTONDOWN:
-			boton_izq = 1;
+			button_izq = 1;
 			break;
 		case Common::EVENT_LBUTTONUP:
-			boton_izq = 0;
+			button_izq = 0;
 			break;
 		case Common::EVENT_RBUTTONDOWN:
-			boton_dch = 1;
+			button_dch = 1;
 			break;
 		case Common::EVENT_RBUTTONUP:
-			boton_dch = 0;
+			button_dch = 0;
 			break;
 		case Common::EVENT_QUIT:
 			// TODO
@@ -1394,17 +1426,17 @@ void DrasculaEngine::elige_verbo(int verbo) {
 	if (menu_scr == 1)
 		c = 0;
 	if (num_ejec == 5) {
-		if (lleva_objeto == 1 && objeto_que_lleva != 16)
-			suma_objeto(objeto_que_lleva);
+		if (lleva_objeto == 1 && pickedObject != 16)
+			suma_objeto(pickedObject);
 	} else {
 		if (lleva_objeto == 1)
-			suma_objeto(objeto_que_lleva);
+			suma_objeto(pickedObject);
 	}
 
 	copyBackground(OBJWIDTH * verbo, c, 0, 0, OBJWIDTH, OBJHEIGHT, dir_hare_fondo, dir_dibujo3);
 
 	lleva_objeto = 1;
-	objeto_que_lleva = verbo;
+	pickedObject = verbo;
 }
 
 void DrasculaEngine::mesa() {
@@ -1432,35 +1464,35 @@ void DrasculaEngine::mesa() {
 
 		MirarRaton();
 
-		if (boton_dch == 1) {
+		if (button_dch == 1) {
 			delay(100);
 			break;
 		}
-		if (boton_izq == 1) {
+		if (button_izq == 1) {
 			delay(100);
-			if (x_raton > 80 && x_raton < 121) {
+			if (mouseX > 80 && mouseX < 121) {
 				int vol = _mixer->getVolumeForSoundType(Audio::Mixer::kPlainSoundType) / 16;
-				if (y_raton < nivel_master && vol < 15)
+				if (mouseY < nivel_master && vol < 15)
 					vol++;
-				if (y_raton > nivel_master && vol > 0)
+				if (mouseY > nivel_master && vol > 0)
 					vol--;
 				_mixer->setVolumeForSoundType(Audio::Mixer::kPlainSoundType, vol * 16);
 			}
 
-			if (x_raton > 136 && x_raton < 178) {
+			if (mouseX > 136 && mouseX < 178) {
 				int vol = _mixer->getVolumeForSoundType(Audio::Mixer::kSFXSoundType) / 16;
-				if (y_raton < nivel_voc && vol < 15)
+				if (mouseY < nivel_voc && vol < 15)
 					vol++;
-				if (y_raton > nivel_voc && vol > 0)
+				if (mouseY > nivel_voc && vol > 0)
 					vol--;
 				_mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, vol * 16);
 			}
 
-			if (x_raton > 192 && x_raton < 233) {
+			if (mouseX > 192 && mouseX < 233) {
 				int vol = _mixer->getVolumeForSoundType(Audio::Mixer::kMusicSoundType) / 16;
-				if (y_raton < nivel_cd && vol < 15)
+				if (mouseY < nivel_cd && vol < 15)
 					vol++;
-				if (y_raton > nivel_cd && vol > 0)
+				if (mouseY > nivel_cd && vol > 0)
 					vol--;
 				_mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, vol * 16);
 			}
@@ -1473,22 +1505,24 @@ void DrasculaEngine::mesa() {
 
 bool DrasculaEngine::saves() {
 	char nombres[10][23];
-	char fichero[13];
+	char fichero[50];
+	char fileEpa[50];
 	int n, n2, num_sav = 0, y = 27;
 	Common::InSaveFile *sav;
 
 	clearRoom();
 
-	if (!(sav = _saveFileMan->openForLoading("saves.epa"))) {
+	snprintf(fileEpa, 50, "%s.epa", _targetName.c_str());
+	if (!(sav = _saveFileMan->openForLoading(fileEpa))) {
 		Common::OutSaveFile *epa;
-		if (!(epa = _saveFileMan->openForSaving("saves.epa")))
-			error("Can't open saves.epa file.");
+		if (!(epa = _saveFileMan->openForSaving(fileEpa)))
+			error("Can't open %s file", fileEpa);
 		for (n = 0; n < NUM_SAVES; n++)
 			epa->writeString("*\n");
 		epa->finalize();
 		delete epa;
-		if (!(sav = _saveFileMan->openForLoading("saves.epa"))) {
-			error("Can't open saves.epa file.");
+		if (!(sav = _saveFileMan->openForLoading(fileEpa))) {
+			error("Can't open %s file", fileEpa);
 		}
 	}
 	for (n = 0; n < NUM_SAVES; n++)
@@ -1514,10 +1548,10 @@ bool DrasculaEngine::saves() {
 
 		MirarRaton();
 
-		if (boton_izq == 1) {
+		if (button_izq == 1) {
 			delay(100);
 			for (n = 0; n < NUM_SAVES; n++) {
-				if (x_raton > 115 && y_raton > y + (9 * n) && x_raton < 115 + 175 && y_raton < y + 10 + (9 * n)) {
+				if (mouseX > 115 && mouseY > y + (9 * n) && mouseX < 115 + 175 && mouseY < y + 10 + (9 * n)) {
 					strcpy(select, nombres[n]);
 
 					if (strcmp(select, "*"))
@@ -1526,11 +1560,11 @@ bool DrasculaEngine::saves() {
 						introduce_nombre();
 						strcpy(nombres[n], select);
 						if (hay_seleccion == 1) {
-							sprintf(fichero, "gsave%02d", n + 1);
+							snprintf(fichero, 50, "%s%02d", _targetName.c_str(), n + 1);
 							para_grabar(fichero);
 							Common::OutSaveFile *tsav;
-							if (!(tsav = _saveFileMan->openForSaving("saves.epa"))) {
-								error("Can't open saves.epa file.");
+							if (!(tsav = _saveFileMan->openForSaving(fileEpa))) {
+								error("Can't open %s file", fileEpa);
 							}
 							for (n = 0; n < NUM_SAVES; n++) {
 								tsav->writeString(nombres[n]);
@@ -1548,13 +1582,13 @@ bool DrasculaEngine::saves() {
 						y = y + 9;
 					}
 					if (hay_seleccion == 1) {
-						sprintf(fichero, "gsave%02d", n + 1);
+						snprintf(fichero, 50, "%s%02d", _targetName.c_str(), n + 1);
 					}
 					num_sav = n;
 				}
 			}
 
-			if (x_raton > 117 && y_raton > 15 && x_raton < 295 && y_raton < 24 && hay_seleccion == 1) {
+			if (mouseX > 117 && mouseY > 15 && mouseX < 295 && mouseY < 24 && hay_seleccion == 1) {
 				introduce_nombre();
 				strcpy(nombres[num_sav], select);
 				print_abc(select, 117, 15);
@@ -1565,15 +1599,15 @@ bool DrasculaEngine::saves() {
 				}
 			}
 
-			if (x_raton > 125 && y_raton > 123 && x_raton < 199 && y_raton < 149 && hay_seleccion == 1) {
+			if (mouseX > 125 && mouseY > 123 && mouseX < 199 && mouseY < 149 && hay_seleccion == 1) {
 				if (!para_cargar(fichero))
 					return false;
 				break;
-			} else if (x_raton > 208 && y_raton > 123 && x_raton < 282 && y_raton < 149 && hay_seleccion == 1) {
+			} else if (mouseX > 208 && mouseY > 123 && mouseX < 282 && mouseY < 149 && hay_seleccion == 1) {
 				para_grabar(fichero);
 				Common::OutSaveFile *tsav;
-				if (!(tsav = _saveFileMan->openForSaving("saves.epa"))) {
-					error("Can't open saves.epa file.");
+				if (!(tsav = _saveFileMan->openForSaving(fileEpa))) {
+					error("Can't open %s file", fileEpa);
 				}
 				for (n = 0; n < NUM_SAVES; n++) {
 					tsav->writeString(nombres[n]);
@@ -1581,7 +1615,7 @@ bool DrasculaEngine::saves() {
 				}
 				tsav->finalize();
 				delete tsav;
-			} else if (x_raton > 168 && y_raton > 154 && x_raton < 242 && y_raton < 180)
+			} else if (mouseX > 168 && mouseY > 154 && mouseX < 242 && mouseY < 180)
 				break;
 			else if (hay_seleccion == 0) {
 				print_abc("elige una partida", 117, 15);
@@ -1590,10 +1624,14 @@ bool DrasculaEngine::saves() {
 			delay(400);
 		}
 		y = 26;
+
+		delay(10);
 	}
 
 	clearRoom();
-	loadPic(num_room);
+	char rm[20];
+	sprintf(rm, "%i.alg", roomNumber);
+	loadPic(rm);
 	decompressPic(dir_dibujo1, HALF_PAL);
 	hay_seleccion = 0;
 
@@ -1602,11 +1640,11 @@ bool DrasculaEngine::saves() {
 
 void DrasculaEngine::print_abc(const char *said, int x_pantalla, int y_pantalla) {
 	int pos_texto[8];
-	int y_de_letra = 0, x_de_letra = 0, h, longitud;
-	longitud = strlen(said);
+	int y_de_letra = 0, x_de_letra = 0, h, length;
+	length = strlen(said);
 
-	for (h = 0; h < longitud; h++) {
-		y_de_letra = Y_ABC;
+	for (h = 0; h < length; h++) {
+		y_de_letra = (_lang == kSpanish) ? Y_ABC_ESP : Y_ABC;
 		int c = toupper(said[h]);
 		if (c == 'A')
 			x_de_letra = X_A;
@@ -1660,10 +1698,14 @@ void DrasculaEngine::print_abc(const char *said, int x_pantalla, int y_pantalla)
 			x_de_letra = X_Y;
 		else if (c == 'Z')
 			x_de_letra = X_Z;
+		else if (c == '\245')
+			x_de_letra = X_GN;
+		else if (c == '\244')
+			x_de_letra = X_GN;
 		else if (c == 0xa7 || c == ' ')
 			x_de_letra = SPACE;
 		else {
-			y_de_letra = Y_SIGNOS;
+			y_de_letra = (_lang == kSpanish) ? Y_SIGNOS_ESP : Y_SIGNOS;
 			if (c == '.')
 				x_de_letra = X_DOT;
 			else if (c == ',')
@@ -1672,7 +1714,7 @@ void DrasculaEngine::print_abc(const char *said, int x_pantalla, int y_pantalla)
 				x_de_letra = X_HYPHEN;
 			else if (c == '?')
 				x_de_letra = X_CIERRA_INTERROGACION;
-			else if (c == 0xa8)
+			else if (c == '\250')
 				x_de_letra = X_ABRE_INTERROGACION;
 //			else if (c == '\'') // FIXME
 //				x_de_letra = SPACE; // space for now
@@ -1680,7 +1722,7 @@ void DrasculaEngine::print_abc(const char *said, int x_pantalla, int y_pantalla)
 				x_de_letra = X_COMILLAS;
 			else if (c == '!')
 				x_de_letra = X_CIERRA_EXCLAMACION;
-			else if (c == 0xad)
+			else if (c == '\255')
 				x_de_letra = X_ABRE_EXCLAMACION;
 			else if (c == ';')
 				x_de_letra = X_PUNTO_Y_COMA;
@@ -1726,6 +1768,41 @@ void DrasculaEngine::print_abc(const char *said, int x_pantalla, int y_pantalla)
 				x_de_letra = X_N9;
 			else if (c == '0')
 				x_de_letra = X_N0;
+			else y_de_letra=Y_ACENTOS;
+
+			if (c == '\240') x_de_letra=X_A;
+			else if (c =='\202') x_de_letra = X_B;
+			else if (c =='\241') x_de_letra = X_C;
+			else if (c =='\242') x_de_letra = X_D;
+			else if (c =='\243') x_de_letra = X_E;
+			else if (c =='\205') x_de_letra = X_F;
+			else if (c =='\212') x_de_letra = X_G;
+			else if (c =='\215') x_de_letra = X_H;
+			else if (c =='\225') x_de_letra = X_I;
+			else if (c =='\227') x_de_letra = X_J;
+			else if (c =='\203') x_de_letra = X_K;
+			else if (c =='\210') x_de_letra = X_L;
+			else if (c =='\214') x_de_letra = X_M;
+			else if (c =='\223') x_de_letra = X_N;
+			else if (c =='\226') x_de_letra = X_GN;
+			else if (c =='\047') x_de_letra = X_O;
+			else if (c =='\200') x_de_letra = X_P;
+			else if (c =='\207') x_de_letra = X_P;
+			else if (c =='\265') x_de_letra = X_A;
+			else if (c =='\220') x_de_letra = X_B;
+			else if (c =='\326') x_de_letra = X_C;
+			else if (c =='\340') x_de_letra = X_D;
+			else if (c =='\351') x_de_letra = X_E;
+			else if (c =='\267') x_de_letra = X_F;
+			else if (c =='\324') x_de_letra = X_G;
+			else if (c =='\336') x_de_letra = X_H;
+			else if (c =='\343') x_de_letra = X_I;
+			else if (c =='\353') x_de_letra = X_J;
+			else if (c =='\266') x_de_letra = X_K;
+			else if (c =='\322') x_de_letra = X_L;
+			else if (c =='\327') x_de_letra = X_M;
+			else if (c =='\342') x_de_letra = X_N;
+			else if (c =='\352') x_de_letra = X_GN;
 		}
 
 		pos_texto[0] = x_de_letra;
@@ -1774,34 +1851,126 @@ bool DrasculaEngine::confirma_salir() {
 
 void DrasculaEngine::salva_pantallas() {
 	int xr, yr;
+	byte *copia, *ghost;
+	Common::File file;
+	float coeff = 0, coeff2 = 0;
+	int count = 0;
+	int count2 = 0;
+	int tempLine[320];
+	int tempRow[200];
 
 	// FIXME: that part (*.ghost) need RE from efecto.lib file for some gfx special effect
 	// for now ignore
-	return;
 
 	clearRoom();
 
 	loadPic("sv.alg");
 	decompressPic(dir_dibujo1, HALF_PAL);
-	//TODO inicio_ghost();
-	//TODO carga_ghost();
+
+	// inicio_ghost();
+	copia = (byte *)malloc(64000);
+	ghost = (byte *)malloc(65536);
+
+	// carga_ghost();
+	file.open("ghost.drv");
+	if (!file.isOpen())
+		error("Cannot open file ghost.drv");
+
+	file.read(ghost, 65536);
+	file.close();
 
 	MirarRaton();
-	xr = x_raton;
-	yr = y_raton;
+	xr = mouseX;
+	yr = mouseY;
 
 	for (;;) {
-		//TODO efecto(dir_dibujo1);
+		// efecto(dir_dibujo1);
+
+		memcpy(copia, dir_dibujo1, 64000);
+		coeff += 0.1f;
+		coeff2 = coeff;
+
+		if (++count > 319)
+			count = 0;
+
+		for (int i = 0; i < 320; i++) {
+			tempLine[i] = (int)(sin(coeff2) * 16);
+			coeff2 += 0.02f;
+			if (tempLine[i] < 0)
+				tempLine[i] += 200;
+			if (tempLine[i] > 199)
+				tempLine[i] -= 200;
+		}
+
+		coeff2 = coeff;
+		for (int i = 0; i < 200; i++) {
+			tempRow[i] = (int)(sin(coeff2) * 16);
+			coeff2 += 0.02f;
+			if (tempRow[i] < 0)
+				tempRow[i] += 320;
+			if (tempRow[i] > 319)
+				tempRow[i] -= 320;
+		}
+
+		if (++count2 > 199)
+			count2 = 0;
+
+		int x1_, y1_, off1, off2;
+
+		for (int i = 0; i < 200; i++) {
+			for (int j = 0; j < 320; j++) {
+				x1_ = j + tempRow[i];
+				if (x1_ < 0)
+					x1_ += 320;
+				if (x1_ > 319)
+					x1_ -= 319;
+
+				y1_ = i + count2;
+				if (y1_ < 0)
+					y1_ += 200;
+				if (y1_ > 199)
+					y1_ -= 200;
+
+				off1 = 320 * y1_ + x1_;
+
+				x1_ = j + count;
+				if (x1_ < 0)
+					x1_ += 320;
+				if (x1_ > 319)
+					x1_ -= 320;
+
+				y1_ = i + tempLine[j];
+				if (y1_ < 0)
+					y1_ += 200;
+				if (y1_ > 199)
+					y1_ -= 200;
+				off2 = 320 * y1_ + x1_;
+
+				VGA[320 * i + j] = ghost[dir_dibujo1[off2] + (copia[off1] << 8)];
+			}
+		}
+		_system->copyRectToScreen((const byte *)VGA, 320, 0, 0, 320, 200);
+		_system->updateScreen();
+
+		_system->delayMillis(20);
+
+		// end of efecto()
+
 		MirarRaton();
-		if (boton_dch == 1 || boton_izq == 1)
+		if (button_dch == 1 || button_izq == 1)
 			break;
-		if (x_raton != xr)
+		if (mouseX != xr)
 			break;
-		if (y_raton != yr)
+		if (mouseY != yr)
 			break;
 	}
-	//TODO fin_ghost();
-	loadPic(num_room);
+	// fin_ghost();
+	free(copia);
+	free(ghost);
+
+	char rm[20];
+	sprintf(rm, "%i.alg", roomNumber);
+	loadPic(rm);
 	decompressPic(dir_dibujo1, HALF_PAL);
 }
 
@@ -1823,7 +1992,7 @@ void DrasculaEngine::FundeDelNegro(int VelocidadDeFundido) {
 	for (fundido = 0; fundido < 64; fundido++) {
 		for (color = 0; color < 256; color++) {
 			for (componente = 0; componente < 3; componente++) {
-				palFundido[color][componente] = LimitaVGA(palJuego[color][componente] - 63 + fundido);
+				palFundido[color][componente] = LimitaVGA(gamePalette[color][componente] - 63 + fundido);
 			}
 		}
 		pause(VelocidadDeFundido);
@@ -1836,48 +2005,48 @@ void DrasculaEngine::color_abc(int cl) {
 	_color = cl;
 
 	if (cl == 0) {
-		palJuego[254][0] = 0;
-		palJuego[254][1] = 0;
-		palJuego[254][2] = 0;
+		gamePalette[254][0] = 0;
+		gamePalette[254][1] = 0;
+		gamePalette[254][2] = 0;
 	} else if (cl == 1) {
-		palJuego[254][0] = 0x10;
-		palJuego[254][1] = 0x3E;
-		palJuego[254][2] = 0x28;
+		gamePalette[254][0] = 0x10;
+		gamePalette[254][1] = 0x3E;
+		gamePalette[254][2] = 0x28;
 	} else if (cl == 3) {
-		palJuego[254][0] = 0x16;
-		palJuego[254][1] = 0x3F;
-		palJuego[254][2] = 0x16;
+		gamePalette[254][0] = 0x16;
+		gamePalette[254][1] = 0x3F;
+		gamePalette[254][2] = 0x16;
 	} else if (cl == 4) {
-		palJuego[254][0] = 0x9;
-		palJuego[254][1] = 0x3F;
-		palJuego[254][2] = 0x12;
+		gamePalette[254][0] = 0x9;
+		gamePalette[254][1] = 0x3F;
+		gamePalette[254][2] = 0x12;
 	} else if (cl == 5) {
-		palJuego[254][0] = 0x3F;
-		palJuego[254][1] = 0x3F;
-		palJuego[254][2] = 0x15;
+		gamePalette[254][0] = 0x3F;
+		gamePalette[254][1] = 0x3F;
+		gamePalette[254][2] = 0x15;
 	} else if (cl == 7) {
-		palJuego[254][0] = 0x38;
-		palJuego[254][1] = 0;
-		palJuego[254][2] = 0;
+		gamePalette[254][0] = 0x38;
+		gamePalette[254][1] = 0;
+		gamePalette[254][2] = 0;
 	} else if (cl == 8) {
-		palJuego[254][0] = 0x3F;
-		palJuego[254][1] = 0x27;
-		palJuego[254][2] = 0x0B;
+		gamePalette[254][0] = 0x3F;
+		gamePalette[254][1] = 0x27;
+		gamePalette[254][2] = 0x0B;
 	} else if (cl == 9) {
-		palJuego[254][0] = 0x2A;
-		palJuego[254][1] = 0;
-		palJuego[254][2] = 0x2A;
+		gamePalette[254][0] = 0x2A;
+		gamePalette[254][1] = 0;
+		gamePalette[254][2] = 0x2A;
 	} else if (cl == 10) {
-		palJuego[254][0] = 0x30;
-		palJuego[254][1] = 0x30;
-		palJuego[254][2] = 0x30;
+		gamePalette[254][0] = 0x30;
+		gamePalette[254][1] = 0x30;
+		gamePalette[254][2] = 0x30;
 	} else if (cl == 11) {
-		palJuego[254][0] = 98;
-		palJuego[254][1] = 91;
-		palJuego[254][2] = 100;
+		gamePalette[254][0] = 98;
+		gamePalette[254][1] = 91;
+		gamePalette[254][2] = 100;
 	};
 
-	setPalette((byte *)&palJuego);
+	setPalette((byte *)&gamePalette);
 }
 
 char DrasculaEngine::LimitaVGA(char valor) {
@@ -1901,10 +2070,7 @@ void DrasculaEngine::centra_texto(const char *mensaje, int x_texto, int y_texto)
 		ya = 1;
 
 	strcpy(m1, mensaje);
-	if (x_texto < 60)
-		x_texto = 60;
-	if (x_texto > 255)
-		x_texto = 255;
+	x_texto = CLIP<int>(x_texto, 60, 255);
 
 	x_texto1 = x_texto;
 
@@ -1953,7 +2119,7 @@ imprimir:
 	}
 }
 
-void DrasculaEngine::comienza_sound(const char *fichero) {
+void DrasculaEngine::playSound(const char *fichero) {
 	if (hay_sb == 1) {
 		sku = new Common::File;
 		sku->open(fichero);
@@ -1966,7 +2132,7 @@ void DrasculaEngine::comienza_sound(const char *fichero) {
 	ctvd_output(sku);
 }
 
-void DrasculaEngine::anima(const char *animation, int FPS) {
+bool DrasculaEngine::anima(const char *animation, int FPS) {
 	Common::File FileIn;
 	unsigned j;
 	int NFrames = 1;
@@ -2017,9 +2183,11 @@ void DrasculaEngine::anima(const char *animation, int FPS) {
 	free(AuxBuffLast);
 	free(AuxBuffDes);
 	FileIn.close();
+
+	return ((term_int == 1) || (getscan() == Common::KEYCODE_ESCAPE));
 }
 
-void DrasculaEngine::animafin_sound_corte() {
+void DrasculaEngine::animastopSound_corte() {
 	if (hay_sb == 1) {
 		ctvd_stop();
 		delete sku;
@@ -2037,7 +2205,7 @@ void DrasculaEngine::FundeAlNegro(int VelocidadDeFundido) {
 	for (fundido = 63; fundido >= 0; fundido--) {
 		for (color = 0; color < 256; color++) {
 			for (componente = 0; componente < 3; componente++) {
-				palFundido[color][componente] = LimitaVGA(palJuego[color][componente] - 63 + fundido);
+				palFundido[color][componente] = LimitaVGA(gamePalette[color][componente] - 63 + fundido);
 			}
 		}
 		pause(VelocidadDeFundido);
@@ -2144,7 +2312,7 @@ comienza:
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 }
 
-void DrasculaEngine::fin_sound() {
+void DrasculaEngine::stopSound() {
 	delay(1);
 
 	if (hay_sb == 1) {
@@ -2202,7 +2370,7 @@ bool DrasculaEngine::carga_partida(const char *nom_game) {
 	sentido_hare = sav->readSint32LE();
 
 	for (l = 1; l < 43; l++) {
-		objetos_que_tengo[l] = sav->readSint32LE();
+		inventoryObjects[l] = sav->readSint32LE();
 	}
 
 	for (l = 0; l < NUM_FLAGS; l++) {
@@ -2210,7 +2378,7 @@ bool DrasculaEngine::carga_partida(const char *nom_game) {
 	}
 
 	lleva_objeto = sav->readSint32LE();
-	objeto_que_lleva = sav->readSint32LE();
+	pickedObject = sav->readSint32LE();
 	hay_que_load = 0;
 
 	return true;
@@ -2220,87 +2388,51 @@ void DrasculaEngine::puertas_cerradas(int l) {
 	if (num_ejec == 1 || num_ejec == 3 || num_ejec == 5 || num_ejec == 6)
 		return;
 	else if (num_ejec == 2) {
-		if (num_obj[l] == 138 && flags[0] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 138 && flags[0] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 136 && flags[8] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 136 && flags[8] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 156 && flags[16] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 156 && flags[16] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 163 && flags[17] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 163 && flags[17] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 177 && flags[15] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 177 && flags[15] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 175 && flags[40] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 175 && flags[40] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 173 && flags[36] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 173 && flags[36] == 1)
-			isDoor[l] = 1;
+		if (num_obj[l] == 138)
+			isDoor[l] = flags[0];
+		else if (num_obj[l] == 136)
+			isDoor[l] = flags[8];
+		else if (num_obj[l] == 156)
+			isDoor[l] = flags[16];
+		else if (num_obj[l] == 163)
+			isDoor[l] = flags[17];
+		else if (num_obj[l] == 177)
+			isDoor[l] = flags[15];
+		else if (num_obj[l] == 175)
+			isDoor[l] = flags[40];
+		else if (num_obj[l] == 173)
+			isDoor[l] = flags[36];
 	} else if (num_ejec == 4) {
 		if (num_obj[l] == 101 && flags[0] == 0)
 			isDoor[l] = 0;
 		else if (num_obj[l] == 101 && flags[0] == 1 && flags[28] == 1)
 			isDoor[l] = 1;
-		else if (num_obj[l] == 103 && flags[0] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 103 && flags[0] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 104 && flags[1] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 104 && flags[1] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 105 && flags[1] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 105 && flags[1] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 106 && flags[2] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 106 && flags[2] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 107 && flags[2] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 107 && flags[2] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 110 && flags[6] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 110 && flags[6] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 114 && flags[4] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 114 && flags[4] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 115 && flags[4] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 115 && flags[4] == 1)
-			isDoor[l] = 1;
+		else if (num_obj[l] == 103)
+			isDoor[l] = flags[0];
+		else if (num_obj[l] == 104)
+			isDoor[l] = flags[1];
+		else if (num_obj[l] == 105)
+			isDoor[l] = flags[1];
+		else if (num_obj[l] == 106)
+			isDoor[l] = flags[2];
+		else if (num_obj[l] == 107)
+			isDoor[l] = flags[2];
+		else if (num_obj[l] == 110)
+			isDoor[l] = flags[6];
+		else if (num_obj[l] == 114)
+			isDoor[l] = flags[4];
+		else if (num_obj[l] == 115)
+			isDoor[l] = flags[4];
 		else if (num_obj[l] == 116 && flags[5] == 0)
 			isDoor[l] = 0;
 		else if (num_obj[l] == 116 && flags[5] == 1 && flags[23] == 1)
 			isDoor[l] = 1;
-		else if (num_obj[l] == 117 && flags[5] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 117 && flags[5] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 120 && flags[8] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 120 && flags[8] == 1)
-			isDoor[l] = 1;
-		else if (num_obj[l] == 122 && flags[7] == 0)
-			isDoor[l] = 0;
-		else if (num_obj[l] == 122 && flags[7] == 1)
-			isDoor[l] = 1;
+		else if (num_obj[l] == 117)
+			isDoor[l] = flags[5];
+		else if (num_obj[l] == 120)
+			isDoor[l] = flags[8];
+		else if (num_obj[l] == 122)
+			isDoor[l] = flags[7];
 	}
 }
 
@@ -2309,7 +2441,7 @@ void DrasculaEngine::color_hare() {
 
 	for (color = 235; color < 253; color++) {
 		for (componente = 0; componente < 3; componente++) {
-			palJuego[color][componente] = palHare[color][componente];
+			gamePalette[color][componente] = palHare[color][componente];
 		}
 	}
 	updatePalette();
@@ -2322,7 +2454,7 @@ void DrasculaEngine::funde_hare(int oscuridad) {
 	for (fundido = oscuridad; fundido >= 0; fundido--) {
 		for (color = 235; color < 253; color++) {
 			for (componente = 0; componente < 3; componente++)
-				palJuego[color][componente] = LimitaVGA(palJuego[color][componente] - 8 + fundido);
+				gamePalette[color][componente] = LimitaVGA(gamePalette[color][componente] - 8 + fundido);
 		}
 	}
 
@@ -2334,7 +2466,7 @@ void DrasculaEngine::paleta_hare_claro() {
 
 	for (color = 235; color < 253; color++) {
 		for (componente = 0; componente < 3; componente++)
-			palHareClaro[color][componente] = palJuego[color][componente];
+			palHareClaro[color][componente] = gamePalette[color][componente];
 	}
 }
 
@@ -2343,7 +2475,7 @@ void DrasculaEngine::paleta_hare_oscuro() {
 
 	for (color = 235; color < 253; color++) {
 		for (componente = 0; componente < 3; componente++)
-			palHareOscuro[color][componente] = palJuego[color][componente];
+			palHareOscuro[color][componente] = gamePalette[color][componente];
 	}
 }
 
@@ -2352,7 +2484,7 @@ void DrasculaEngine::hare_claro() {
 
 	for (color = 235; color < 253; color++) {
 		for (componente = 0; componente < 3; componente++)
-			palJuego[color][componente] = palHareClaro[color][componente];
+			gamePalette[color][componente] = palHareClaro[color][componente];
 	}
 
 	updatePalette();
@@ -2366,26 +2498,26 @@ void DrasculaEngine::empieza_andar() {
 
 	if (num_ejec == 2) {
 		if ((sitio_x < hare_x) && (sitio_y <= (hare_y + alto_hare)))
-			cuadrante_1();
+			quadrant_1();
 		else if ((sitio_x < hare_x) && (sitio_y > (hare_y + alto_hare)))
-			cuadrante_3();
+			quadrant_3();
 		else if ((sitio_x > hare_x + ancho_hare) && (sitio_y <= (hare_y + alto_hare)))
-			cuadrante_2();
+			quadrant_2();
 		else if ((sitio_x > hare_x + ancho_hare) && (sitio_y > (hare_y + alto_hare)))
-			cuadrante_4();
+			quadrant_4();
 		else if (sitio_y < hare_y + alto_hare)
 			anda_parriba();
 		else if (sitio_y > hare_y + alto_hare)
 			anda_pabajo();
 	} else {
 		if ((sitio_x < hare_x + ancho_hare / 2 ) && (sitio_y <= (hare_y + alto_hare)))
-			cuadrante_1();
+			quadrant_1();
 		else if ((sitio_x < hare_x + ancho_hare / 2) && (sitio_y > (hare_y + alto_hare)))
-			cuadrante_3();
+			quadrant_3();
 		else if ((sitio_x > hare_x + ancho_hare / 2) && (sitio_y <= (hare_y + alto_hare)))
-			cuadrante_2();
+			quadrant_2();
 		else if ((sitio_x > hare_x + ancho_hare / 2) && (sitio_y > (hare_y + alto_hare)))
-			cuadrante_4();
+			quadrant_4();
 		else
 			hare_se_mueve = 0;
 	}
@@ -2538,29 +2670,29 @@ void DrasculaEngine::menu_sin_volcar() {
 	strcpy(texto_icono, iconName[x]);
 
 	for (n = 1; n < 43; n++) {
-		h = objetos_que_tengo[n];
+		h = inventoryObjects[n];
 
 		if (h != 0) {
 			if (num_ejec == 6)
-				copyBackground(x_pol[n], y_pol[n], x_obj[n], y_obj[n],
+				copyBackground(x_pol[n], y_pol[n], itemLocations[n].x, itemLocations[n].y,
 						OBJWIDTH, OBJHEIGHT, dir_mesa, dir_zona_pantalla);
 			else
-				copyBackground(x_pol[n], y_pol[n], x_obj[n], y_obj[n],
+				copyBackground(x_pol[n], y_pol[n], itemLocations[n].x, itemLocations[n].y,
 						OBJWIDTH, OBJHEIGHT, dir_hare_frente, dir_zona_pantalla);
 		}
-		copyRect(x1d_menu[h], y1d_menu[h], x_obj[n], y_obj[n],
+		copyRect(x1d_menu[h], y1d_menu[h], itemLocations[n].x, itemLocations[n].y,
 				OBJWIDTH, OBJHEIGHT, dir_hare_fondo, dir_zona_pantalla);
 	}
 
 	if (x < 7)
-		print_abc(texto_icono, x_obj[x] - 2, y_obj[x] - 7);
+		print_abc(texto_icono, itemLocations[x].x - 2, itemLocations[x].y - 7);
 }
 
 void DrasculaEngine::barra_menu() {
 	int n, sobre_verbo = 1;
 
 	for (n = 0; n < 7; n++) {
-		if (x_raton > x_barra[n] && x_raton < x_barra[n + 1])
+		if (mouseX > x_barra[n] && mouseX < x_barra[n + 1])
 			sobre_verbo = 0;
 		copyRect(OBJWIDTH * n, OBJHEIGHT * sobre_verbo, x_barra[n], 2,
 						OBJWIDTH, OBJHEIGHT, dir_hare_fondo, dir_zona_pantalla);
@@ -2575,8 +2707,8 @@ void DrasculaEngine::saca_objeto() {
 
 	for (n = 1; n < 43; n++){
 		if (sobre_que_objeto() == n) {
-			h = objetos_que_tengo[n];
-			objetos_que_tengo[n] = 0;
+			h = inventoryObjects[n];
+			inventoryObjects[n] = 0;
 			if (h != 0)
 				lleva_objeto = 1;
 		}
@@ -2737,19 +2869,19 @@ bool DrasculaEngine::sal_de_la_habitacion(int l) {
 
 bool DrasculaEngine::coge_objeto() {
 	int h, n;
-	h = objeto_que_lleva;
+	h = pickedObject;
 	comprueba_flags = 1;
 
 	updateRoom();
 	menu_sin_volcar();
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 
-	if (objeto_que_lleva < 7)
+	if (pickedObject < 7)
 		goto usando_verbos;
 
 	for (n = 1; n < 43; n++) {
-		if (sobre_que_objeto() == n && objetos_que_tengo[n] == 0) {
-			objetos_que_tengo[n] = h;
+		if (sobre_que_objeto() == n && inventoryObjects[n] == 0) {
+			inventoryObjects[n] = h;
 			lleva_objeto = 0;
 			comprueba_flags = 0;
 		}
@@ -2773,400 +2905,401 @@ bool DrasculaEngine::banderas(int fl) {
 	updateRoom();
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 
-	hay_respuesta = 1;
+	hay_answer = 1;
 
 	if (menu_scr == 1) {
 		if (num_ejec == 1) {
-			if (objeto_que_lleva == LOOK && fl == 28)
+			if (pickedObject == kVerbLook && fl == 28)
 				talk(_text[_lang][328], "328.als");
 		} else if (num_ejec == 2) {
-			if ((objeto_que_lleva == LOOK && fl == 22 && flags[23] == 0)
-					|| (objeto_que_lleva == OPEN && fl == 22 && flags[23] == 0)) {
+			if ((pickedObject == kVerbLook && fl == 22 && flags[23] == 0)
+					|| (pickedObject == kVerbOpen && fl == 22 && flags[23] == 0)) {
 				talk(_text[_lang][164], "164.als");
 				flags[23] = 1;
 				withoutVerb();
 				suma_objeto(7);
 				suma_objeto(18);
-			} else if (objeto_que_lleva == LOOK && fl == 22 && flags[23] == 1)
+			} else if (pickedObject == kVerbLook && fl == 22 && flags[23] == 1)
 				talk(_text[_lang][307], "307.als");
-			else if (objeto_que_lleva == LOOK && fl == 28)
+			else if (pickedObject == kVerbLook && fl == 28)
 				talk(_text[_lang][328], "328.als");
-			else if (objeto_que_lleva == LOOK && fl == 7)
+			else if (pickedObject == kVerbLook && fl == 7)
 				talk(_text[_lang][143], "143.als");
-			else if (objeto_que_lleva == TALK && fl == 7)
+			else if (pickedObject == kVerbTalk && fl == 7)
 				talk(_text[_lang][144], "144.als");
-			else if (objeto_que_lleva == LOOK && fl == 8)
+			else if (pickedObject == kVerbLook && fl == 8)
 				talk(_text[_lang][145], "145.als");
-			else if (objeto_que_lleva == TALK && fl == 8)
+			else if (pickedObject == kVerbTalk && fl == 8)
 				talk(_text[_lang][146], "146.als");
-			else if (objeto_que_lleva == LOOK && fl == 9)
+			else if (pickedObject == kVerbLook && fl == 9)
 				talk(_text[_lang][147], "147.als");
-			else if (objeto_que_lleva == TALK && fl == 9)
+			else if (pickedObject == kVerbTalk && fl == 9)
 				talk(_text[_lang][148], "148.als");
-			else if (objeto_que_lleva == LOOK && fl == 10)
+			else if (pickedObject == kVerbLook && fl == 10)
 				talk(_text[_lang][151], "151.als");
-			else if (objeto_que_lleva == LOOK && fl == 11)
+			else if (pickedObject == kVerbLook && fl == 11)
 				talk(_text[_lang][152], "152.als");
-			else if (objeto_que_lleva == TALK && fl == 11)
+			else if (pickedObject == kVerbTalk && fl == 11)
 				talk(_text[_lang][153], "153.als");
-			else if (objeto_que_lleva == LOOK && fl == 12)
+			else if (pickedObject == kVerbLook && fl == 12)
 				talk(_text[_lang][154], "154.als");
-			else if (objeto_que_lleva == LOOK && fl == 13)
+			else if (pickedObject == kVerbLook && fl == 13)
 				talk(_text[_lang][155], "155.als");
-			else if (objeto_que_lleva == LOOK && fl == 14)
+			else if (pickedObject == kVerbLook && fl == 14)
 				talk(_text[_lang][157], "157.als");
-			else if (objeto_que_lleva == LOOK && fl == 15)
+			else if (pickedObject == kVerbLook && fl == 15)
 				talk(_text[_lang][58], "58.als");
-			else if (objeto_que_lleva == LOOK && fl == 16)
+			else if (pickedObject == kVerbLook && fl == 16)
 				talk(_text[_lang][158], "158.als");
-			else if (objeto_que_lleva == LOOK && fl == 17)
+			else if (pickedObject == kVerbLook && fl == 17)
 				talk(_text[_lang][159], "159.als");
-			else if (objeto_que_lleva == LOOK && fl == 18)
+			else if (pickedObject == kVerbLook && fl == 18)
 				talk(_text[_lang][160], "160.als");
-			else if (objeto_que_lleva == LOOK && fl == 19)
+			else if (pickedObject == kVerbLook && fl == 19)
 				talk(_text[_lang][161], "161.als");
-			else if (objeto_que_lleva == LOOK && fl == 20)
+			else if (pickedObject == kVerbLook && fl == 20)
 				talk(_text[_lang][162], "162.als");
-			else if (objeto_que_lleva == LOOK && fl == 23)
+			else if (pickedObject == kVerbLook && fl == 23)
 				talk(_text[_lang][152], "152.als");
 			else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		} else if (num_ejec == 3) {
-			if (objeto_que_lleva == LOOK && fl == 22)
+			if (pickedObject == kVerbLook && fl == 22)
 				talk(_text[_lang][307], "307.als");
-			else if (objeto_que_lleva == LOOK && fl == 28)
+			else if (pickedObject == kVerbLook && fl == 28)
 				talk(_text[_lang][328], "328.als");
-			else if (objeto_que_lleva == LOOK && fl == 7)
+			else if (pickedObject == kVerbLook && fl == 7)
 				talk(_text[_lang][143], "143.als");
-			else if (objeto_que_lleva == TALK && fl == 7)
+			else if (pickedObject == kVerbTalk && fl == 7)
 				talk(_text[_lang][144], "144.als");
-			else if (objeto_que_lleva == LOOK && fl == 8)
+			else if (pickedObject == kVerbLook && fl == 8)
 				talk(_text[_lang][145], "145.als");
-			else if (objeto_que_lleva == TALK && fl == 8)
+			else if (pickedObject == kVerbTalk && fl == 8)
 				talk(_text[_lang][146], "146.als");
-			else if (objeto_que_lleva == LOOK && fl == 9)
+			else if (pickedObject == kVerbLook && fl == 9)
 				talk(_text[_lang][147], "147.als");
-			else if (objeto_que_lleva == TALK && fl == 9)
+			else if (pickedObject == kVerbTalk && fl == 9)
 				talk(_text[_lang][148], "148.als");
-			else if (objeto_que_lleva == LOOK && fl == 10)
+			else if (pickedObject == kVerbLook && fl == 10)
 				talk(_text[_lang][151], "151.als");
-			else if (objeto_que_lleva == LOOK && fl == 11)
+			else if (pickedObject == kVerbLook && fl == 11)
 				talk(_text[_lang][152], "152.als");
-			else if (objeto_que_lleva == TALK && fl == 11)
+			else if (pickedObject == kVerbTalk && fl == 11)
 				talk(_text[_lang][153], "153.als");
-			else if (objeto_que_lleva == LOOK && fl == 12)
+			else if (pickedObject == kVerbLook && fl == 12)
 				talk(_text[_lang][154], "154.als");
-			else if (objeto_que_lleva == LOOK && fl == 13)
+			else if (pickedObject == kVerbLook && fl == 13)
 				talk(_text[_lang][155], "155.als");
-			else if (objeto_que_lleva == LOOK && fl == 14)
+			else if (pickedObject == kVerbLook && fl == 14)
 				talk(_text[_lang][157], "157.als");
-			else if (objeto_que_lleva == LOOK && fl == 15)
+			else if (pickedObject == kVerbLook && fl == 15)
 				talk(_text[_lang][58], "58.als");
-			else if (objeto_que_lleva == LOOK && fl == 16)
+			else if (pickedObject == kVerbLook && fl == 16)
 				talk(_text[_lang][158], "158.als");
-			else if (objeto_que_lleva == LOOK && fl == 17)
+			else if (pickedObject == kVerbLook && fl == 17)
 				talk(_text[_lang][159], "159.als");
-			else if (objeto_que_lleva == LOOK && fl == 18)
+			else if (pickedObject == kVerbLook && fl == 18)
 				talk(_text[_lang][160], "160.als");
-			else if (objeto_que_lleva == LOOK && fl == 19)
+			else if (pickedObject == kVerbLook && fl == 19)
 				talk(_text[_lang][161], "161.als");
-			else if (objeto_que_lleva == LOOK && fl == 20)
+			else if (pickedObject == kVerbLook && fl == 20)
 				talk(_text[_lang][162], "162.als");
-			else if (objeto_que_lleva == LOOK && fl == 23)
+			else if (pickedObject == kVerbLook && fl == 23)
 				talk(_text[_lang][152], "152.als");
 			else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		} else if (num_ejec == 4) {
-			if ((objeto_que_lleva == 18 && fl == 19) || (objeto_que_lleva == 19 && fl == 18)) {
+			if ((pickedObject == 18 && fl == 19) || (pickedObject == 19 && fl == 18)) {
 				withoutVerb();
 				chooseObject(21);
 				resta_objeto(18);
 				resta_objeto(19);
-			} else if ((objeto_que_lleva == 14 && fl == 19) || (objeto_que_lleva == 19 && fl == 14))
+			} else if ((pickedObject == 14 && fl == 19) || (pickedObject == 19 && fl == 14))
 				talk(_text[_lang][484], "484.als");
-			else if (objeto_que_lleva == LOOK && fl == 28)
+			else if (pickedObject == kVerbLook && fl == 28)
 				talk(_text[_lang][328], "328.als");
-			else if (objeto_que_lleva == LOOK && fl == 7)
+			else if (pickedObject == kVerbLook && fl == 7)
 				talk(_text[_lang][478], "478.als");
-			else if (objeto_que_lleva == LOOK && fl == 8)
+			else if (pickedObject == kVerbLook && fl == 8)
 				talk(_text[_lang][480], "480.als");
-			else if (objeto_que_lleva == LOOK && fl == 9) {
+			else if (pickedObject == kVerbLook && fl == 9) {
 				talk(_text[_lang][482], "482.als");
 				talk(_text[_lang][483], "483.als");
-			} else if (objeto_que_lleva == LOOK && fl == 10)
+			} else if (pickedObject == kVerbLook && fl == 10)
 				talk(_text[_lang][485], "485.als");
-			else if (objeto_que_lleva == LOOK && fl == 11)
+			else if (pickedObject == kVerbLook && fl == 11)
 				talk(_text[_lang][488], "488.als");
-			else if (objeto_que_lleva == LOOK && fl == 12)
+			else if (pickedObject == kVerbLook && fl == 12)
 				talk(_text[_lang][486], "486.als");
-			else if (objeto_que_lleva == LOOK && fl == 13)
+			else if (pickedObject == kVerbLook && fl == 13)
 				talk(_text[_lang][490], "490.als");
-			else if (objeto_que_lleva == LOOK && fl == 14)
+			else if (pickedObject == kVerbLook && fl == 14)
 				talk(_text[_lang][122], "122.als");
-			else if (objeto_que_lleva == LOOK && fl == 15)
+			else if (pickedObject == kVerbLook && fl == 15)
 				talk(_text[_lang][117], "117.als");
-			else if (objeto_que_lleva == TALK && fl == 15)
+			else if (pickedObject == kVerbTalk && fl == 15)
 				talk(_text[_lang][118], "118.als");
-			else if (objeto_que_lleva == OPEN && fl == 15)
+			else if (pickedObject == kVerbOpen && fl == 15)
 				talk(_text[_lang][119], "119.als");
-			else if (objeto_que_lleva == LOOK && fl == 16)
+			else if (pickedObject == kVerbLook && fl == 16)
 				talk(_text[_lang][491], "491.als");
-			else if (objeto_que_lleva == LOOK && fl == 17)
+			else if (pickedObject == kVerbLook && fl == 17)
 				talk(_text[_lang][478], "478.als");
-			else if (objeto_que_lleva == LOOK && fl == 18)
+			else if (pickedObject == kVerbLook && fl == 18)
 				talk(_text[_lang][493], "493.als");
-			else if (objeto_que_lleva == LOOK && fl == 19) {
+			else if (pickedObject == kVerbLook && fl == 19) {
 				talk(_text[_lang][494], "494.als");
 				talk(_text[_lang][495], "495.als");
-			} else if (objeto_que_lleva == LOOK && fl == 20)
+			} else if (pickedObject == kVerbLook && fl == 20)
 				talk(_text[_lang][162], "162.als");
-			else if (objeto_que_lleva == LOOK && fl == 21)
+			else if (pickedObject == kVerbLook && fl == 21)
 				talk(_text[_lang][496], "496.als");
-			else if (objeto_que_lleva == LOOK && fl == 22)
+			else if (pickedObject == kVerbLook && fl == 22)
 				talk(_text[_lang][161], "161.als");
 			else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		} else if (num_ejec == 5) {
-			if (objeto_que_lleva == LOOK && fl == 28)
+			if (pickedObject == kVerbLook && fl == 28)
 				talk(_text[_lang][328], "328.als");
-			else if (objeto_que_lleva == LOOK && fl == 7)
+			else if (pickedObject == kVerbLook && fl == 7)
 				talk(_text[_lang][478],"478.als");
-			else if (objeto_que_lleva == LOOK && fl == 8)
+			else if (pickedObject == kVerbLook && fl == 8)
 				talk(_text[_lang][120], "120.als");
-			else if (objeto_que_lleva == LOOK && fl == 9) {
+			else if (pickedObject == kVerbLook && fl == 9) {
 				talk(_text[_lang][482], "482.als");
 				talk(_text[_lang][483], "483.als");
-			} else if (objeto_que_lleva == LOOK && fl == 11)
+			} else if (pickedObject == kVerbLook && fl == 11)
 				talk(_text[_lang][488], "488.als");
-			else if (objeto_que_lleva == LOOK && fl == 13)
+			else if (pickedObject == kVerbLook && fl == 13)
 				talk(_text[_lang][490], "490.als");
-			else if (objeto_que_lleva == LOOK && fl == 14)
+			else if (pickedObject == kVerbLook && fl == 14)
 				talk(_text[_lang][121], "121.als");
-			else if (objeto_que_lleva == LOOK && fl == 15)
+			else if (pickedObject == kVerbLook && fl == 15)
 				talk(_text[_lang][117], "117.als");
-			else if (objeto_que_lleva == TALK && fl == 15)
+			else if (pickedObject == kVerbTalk && fl == 15)
 				talk(_text[_lang][118], "118.als");
-			else if (objeto_que_lleva == OPEN && fl == 15)
+			else if (pickedObject == kVerbOpen && fl == 15)
 				talk(_text[_lang][119], "119.als");
-			else if (objeto_que_lleva == LOOK && fl == 17)
+			else if (pickedObject == kVerbLook && fl == 17)
 				talk(_text[_lang][478], "478.als");
-			else if (objeto_que_lleva == LOOK && fl == 20)
+			else if (pickedObject == kVerbLook && fl == 20)
 				talk(_text[_lang][162], "162.als"); 
 			else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		} else if (num_ejec == 6) {
-			if (objeto_que_lleva == LOOK && fl == 28)
+			if (pickedObject == kVerbLook && fl == 28)
 				talk(_text[_lang][328], "328.als");
-			else if (objeto_que_lleva == LOOK && fl == 9) {
+			else if (pickedObject == kVerbLook && fl == 9) {
 				talk(_text[_lang][482], "482.als");
 				talk(_text[_lang][483], "483.als");
-			} else if (objeto_que_lleva == LOOK && fl == 20)
+			} else if (pickedObject == kVerbLook && fl == 20)
 				talk(_text[_lang][123], "123.als");
-			else if (objeto_que_lleva == LOOK && fl == 21)
+			else if (pickedObject == kVerbLook && fl == 21)
 				talk(_text[_lang][441], "441.als");
 			else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		}
 	} else {
 		if (num_ejec == 1) {
-			if (objeto_que_lleva == LOOK && fl == 50)
+			if (pickedObject == kVerbLook && fl == 50)
 				talk(_text[_lang][308], "308.als");
-			else if (objeto_que_lleva == OPEN && fl == 50)
+			else if (pickedObject == kVerbOpen && fl == 50)
 				talk(_text[_lang][310], "310.als");
-			else if (objeto_que_lleva == CLOSE && fl == 50)
+			else if (pickedObject == kVerbClose && fl == 50)
 				talk(_text[_lang][311], "311.als");
-			else if (objeto_que_lleva == MOVE && fl == 50)
+			else if (pickedObject == kVerbMove && fl == 50)
 				talk(_text[_lang][312], "312.als");
-			else if (objeto_que_lleva == PICK && fl == 50)
+			else if (pickedObject == kVerbPick && fl == 50)
 				talk(_text[_lang][313], "313.als");
-			else if (objeto_que_lleva == TALK && fl == 50)
+			else if (pickedObject == kVerbTalk && fl == 50)
 				talk(_text[_lang][314], "314.als");
-			else if (!strcmp(num_room, "62.alg"))
+			else if (roomNumber == 62)
 				room_62(fl);
-			else if (!strcmp(num_room, "63.alg"))
+			else if (roomNumber == 63)
 				room_63(fl);
 			else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		} else if (num_ejec == 2) {
-			if (objeto_que_lleva == LOOK && fl == 50)
+			if (pickedObject == kVerbLook && fl == 50)
 				talk(_text[_lang][308], "308.als");
-			else if (objeto_que_lleva == OPEN && fl == 50)
+			else if (pickedObject == kVerbOpen && fl == 50)
 				talk(_text[_lang][310], "310.als");
-			else if (objeto_que_lleva == CLOSE && fl == 50)
+			else if (pickedObject == kVerbClose && fl == 50)
 				talk(_text[_lang][311], "311.als");
-			else if (objeto_que_lleva == MOVE && fl == 50)
+			else if (pickedObject == kVerbMove && fl == 50)
 				talk(_text[_lang][312], "312.als");
-			else if (objeto_que_lleva == PICK && fl == 50)
+			else if (pickedObject == kVerbPick && fl == 50)
 				talk(_text[_lang][313], "313.als");
-			else if (objeto_que_lleva == TALK && fl == 50)
+			else if (pickedObject == kVerbTalk && fl == 50)
 				talk(_text[_lang][314], "314.als");
-			else if (objeto_que_lleva == 11 && fl == 50 && flags[22] == 0 && strcmp(num_room, "18.alg"))
+			// Note: the original check was strcmp(num_room, "18.alg")
+			else if (pickedObject == 11 && fl == 50 && flags[22] == 0 && roomNumber != 18)
 				talk(_text[_lang][315], "315.als");
-			else if (objeto_que_lleva == 13 && fl == 50)
+			else if (pickedObject == 13 && fl == 50)
 				talk(_text[_lang][156], "156.als");
-			else if (objeto_que_lleva == 20 && fl == 50)
+			else if (pickedObject == 20 && fl == 50)
 				talk(_text[_lang][163], "163.als");
-			else if (!strcmp(num_room, "1.alg"))
+			else if (roomNumber == 1)
 				room_1(fl);
-			else if (!strcmp(num_room, "3.alg"))
+			else if (roomNumber == 3)
 				room_3(fl);
-			else if (!strcmp(num_room, "4.alg"))
+			else if (roomNumber == 4)
 				room_4(fl);
-			else if (!strcmp(num_room, "5.alg"))
+			else if (roomNumber == 5)
 				room_5(fl);
-			else if (!strcmp(num_room, "6.alg"))
+			else if (roomNumber == 6)
 				room_6(fl);
-			else if (!strcmp(num_room, "7.alg"))
+			else if (roomNumber == 7)
 				room_7(fl);
-			else if (!strcmp(num_room, "8.alg"))
+			else if (roomNumber == 8)
 				room_8(fl);
-			else if (!strcmp(num_room, "9.alg"))
+			else if (roomNumber == 9)
 				room_9(fl);
-			else if (!strcmp(num_room, "12.alg"))
+			else if (roomNumber == 12)
 				room_12(fl);
-			else if (!strcmp(num_room, "14.alg"))
+			else if (roomNumber == 14)
 				room_14(fl);
-			else if (!strcmp(num_room, "15.alg"))
+			else if (roomNumber == 15)
 				room_15(fl);
-			else if (!strcmp(num_room, "16.alg"))
+			else if (roomNumber == 16)
 				room_16(fl);
-			else if (!strcmp(num_room, "17.alg"))
+			else if (roomNumber == 17)
 				room_17(fl);
-			else if (!strcmp(num_room, "18.alg"))
+			else if (roomNumber == 18)
 				room_18(fl);
-			else if (!strcmp(num_room, "19.alg"))
+			else if (roomNumber == 19)
 				room_19(fl);
 			else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		} else if (num_ejec == 3) {
-			if (objeto_que_lleva == LOOK && fl == 50)
+			if (pickedObject == kVerbLook && fl == 50)
 				talk(_text[_lang][309], "309.als");
-			else if (objeto_que_lleva == OPEN && fl == 50)
+			else if (pickedObject == kVerbOpen && fl == 50)
 				talk(_text[_lang][310], "310.als");
-			else if (objeto_que_lleva == CLOSE && fl == 50)
+			else if (pickedObject == kVerbClose && fl == 50)
 				talk(_text[_lang][311], "311.als");
-			else if (objeto_que_lleva == MOVE && fl == 50)
+			else if (pickedObject == kVerbMove && fl == 50)
 				talk(_text[_lang][312], "312.als");
-			else if (objeto_que_lleva == PICK && fl == 50)
+			else if (pickedObject == kVerbPick && fl == 50)
 				talk(_text[_lang][313], "313.als");
-			else if (objeto_que_lleva == TALK && fl == 50)
+			else if (pickedObject == kVerbTalk && fl == 50)
 				talk(_text[_lang][314], "314.als");
-			else if (!strcmp(num_room, "13.alg")) {
+			else if (roomNumber == 13) {
 				if (room_13(fl))
 					return true;
 			} else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		} else if (num_ejec == 4) {
-			if (!strcmp(num_room, "28.alg"))
+			if (roomNumber == 28)
 				talk(_text[_lang][178], "178.als");
-			else if (objeto_que_lleva == LOOK && fl == 50)
+			else if (pickedObject == kVerbLook && fl == 50)
 				talk(_text[_lang][309], "309.als");
-			else if (objeto_que_lleva == OPEN && fl == 50)
+			else if (pickedObject == kVerbOpen && fl == 50)
 				talk(_text[_lang][310], "310.als");
-			else if (objeto_que_lleva == CLOSE && fl == 50)
+			else if (pickedObject == kVerbClose && fl == 50)
 				talk(_text[_lang][311], "311.als");
-			else if (objeto_que_lleva == MOVE && fl == 50)
+			else if (pickedObject == kVerbMove && fl == 50)
 				talk(_text[_lang][312], "312.als");
-			else if (objeto_que_lleva == PICK && fl == 50)
+			else if (pickedObject == kVerbPick && fl == 50)
 				talk(_text[_lang][313], "313.als");
-			else if (objeto_que_lleva == TALK && fl == 50)
+			else if (pickedObject == kVerbTalk && fl == 50)
 				talk(_text[_lang][314], "314.als");
-			else if (objeto_que_lleva == 8 && fl == 50 && flags[18] == 0)
+			else if (pickedObject == 8 && fl == 50 && flags[18] == 0)
 				talk(_text[_lang][481], "481.als");
-			else if (objeto_que_lleva == 9 && fl == 50)
+			else if (pickedObject == 9 && fl == 50)
 				talk(_text[_lang][484], "484.als");
-			else if (objeto_que_lleva == 12 && fl == 50 && flags[18] == 0)
+			else if (pickedObject == 12 && fl == 50 && flags[18] == 0)
 				talk(_text[_lang][487], "487.als");
-			else if (objeto_que_lleva == 20 && fl == 50)
+			else if (pickedObject == 20 && fl == 50)
 				talk(_text[_lang][487], "487.als");
-			else if (!strcmp(num_room, "21.alg")) {
+			else if (roomNumber == 21) {
 				if (room_21(fl))
 					return true;
-			} else if (!strcmp(num_room, "22.alg"))
+			} else if (roomNumber == 22)
 				room_22(fl);
-			else if (!strcmp(num_room, "23.alg"))
+			else if (roomNumber == 23)
 				room_23(fl);
-			else if (!strcmp(num_room, "24.alg"))
+			else if (roomNumber == 24)
 				room_24(fl);
-			else if (!strcmp(num_room, "26.alg"))
+			else if (roomNumber == 26)
 				room_26(fl);
-			else if (!strcmp(num_room, "27.alg"))
+			else if (roomNumber == 27)
 				room_27(fl);
-			else if (!strcmp(num_room, "29.alg"))
+			else if (roomNumber == 29)
 				room_29(fl);
-			else if (!strcmp(num_room, "30.alg"))
+			else if (roomNumber == 30)
 				room_30(fl);
-			else if (!strcmp(num_room, "31.alg"))
+			else if (roomNumber == 31)
 				room_31(fl);
-			else if (!strcmp(num_room, "34.alg"))
+			else if (roomNumber == 34)
 				room_34(fl);
-			else if (!strcmp(num_room, "35.alg"))
+			else if (roomNumber == 35)
 				room_35(fl);
-			else if (!strcmp(num_room, "44.alg"))
+			else if (roomNumber == 44)
 				room_44(fl);
 			else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		} else if (num_ejec == 5) {
-			if (objeto_que_lleva == LOOK && fl == 50)
+			if (pickedObject == kVerbLook && fl == 50)
 				talk("Cuanto mas me miro, mas me gusto", "54.als");
-			else if (objeto_que_lleva == OPEN && fl == 50)
+			else if (pickedObject == kVerbOpen && fl == 50)
 				talk("y luego como me cierro", "19.als");
-			else if (objeto_que_lleva == CLOSE && fl == 50)
+			else if (pickedObject == kVerbClose && fl == 50)
 				talk("Tendre que abrirme primero no", "19.als");
-			else if (objeto_que_lleva == MOVE && fl == 50)
+			else if (pickedObject == kVerbMove && fl == 50)
 				talk("Estoy bien donde estoy", "19.als");
-			else if (objeto_que_lleva == PICK && fl == 50)
+			else if (pickedObject == kVerbPick && fl == 50)
 				talk("Ya me tengo", "11.als");
-			else if (objeto_que_lleva == TALK && fl == 50)
+			else if (pickedObject == kVerbTalk && fl == 50)
 				talk("hola yo", "16.als");
-			else if (objeto_que_lleva == 20 && fl == 50)
+			else if (pickedObject == 20 && fl == 50)
 				talk(_text[_lang][487], "487.als");
-			else if (!strcmp(num_room, "49.alg"))
+			else if (roomNumber == 49)
 				room_49(fl);
-			else if (!strcmp(num_room, "53.alg"))
+			else if (roomNumber == 53)
 				room_53(fl);
-			else if (!strcmp(num_room, "54.alg"))
+			else if (roomNumber == 54)
 				room_54(fl);
-			else if (!strcmp(num_room, "55.alg"))
+			else if (roomNumber == 55)
 				room_55(fl);
-			else if (!strcmp(num_room, "56.alg")) {
+			else if (roomNumber == 56) {
 				if (room_56(fl))
 					return true;
 			} else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		} else if (num_ejec == 6) {
-			if (objeto_que_lleva == LOOK && fl == 50 && flags[0] == 1)
+			if (pickedObject == kVerbLook && fl == 50 && flags[0] == 1)
 				talk(_text[_lang][308], "308.als");
-			else if (objeto_que_lleva == LOOK && fl == 50 && flags[0] == 0)
+			else if (pickedObject == kVerbLook && fl == 50 && flags[0] == 0)
 				talk(_text[_lang][310], "250.als" );
-			else if (objeto_que_lleva == OPEN && fl == 50)
+			else if (pickedObject == kVerbOpen && fl == 50)
 				talk(_text[_lang][310], "310.als" );
-			else if (objeto_que_lleva == CLOSE && fl == 50)
+			else if (pickedObject == kVerbClose && fl == 50)
 				talk(_text[_lang][311], "311.als" );
-			else if (objeto_que_lleva == MOVE && fl == 50)
+			else if (pickedObject == kVerbMove && fl == 50)
 				talk(_text[_lang][312], "312.als" );
-			else if (objeto_que_lleva == PICK && fl == 50)
+			else if (pickedObject == kVerbPick && fl == 50)
 				talk(_text[_lang][313], "313.als" );
-			else if (objeto_que_lleva == TALK && fl == 50)
+			else if (pickedObject == kVerbTalk && fl == 50)
 				talk(_text[_lang][314], "314.als" );
-			else if (!strcmp(num_room, "102.alg"))
+			else if (roomNumber == 102)
 				room_pendulo(fl);
-			else if (!strcmp(num_room, "58.alg"))
+			else if (roomNumber == 58)
 				room_58(fl);
-			else if (!strcmp(num_room, "59.alg"))
+			else if (roomNumber == 59)
 				room_59(fl);
-			else if (!strcmp(num_room, "60.alg")) {
+			else if (roomNumber == 60) {
 				if (room_60(fl))
 					return true;
-			} else if (!strcmp(num_room, "61.alg"))
+			} else if (roomNumber == 61)
 				room_61(fl);
 			else
-				hay_respuesta = 0;
+				hay_answer = 0;
 		}
 	}
-	if (hay_respuesta == 0 && hay_nombre == 1)
+	if (hay_answer == 0 && hay_nombre == 1)
 		room_0();
-	else if (hay_respuesta == 0 && menu_scr == 1)
+	else if (hay_answer == 0 && menu_scr == 1)
 		room_0();
 
 	return false;
@@ -3177,8 +3310,8 @@ void DrasculaEngine::cursor_mesa() {
 
 	pos_cursor[0] = 225;
 	pos_cursor[1] = 56;
-	pos_cursor[2] = x_raton - 20;
-	pos_cursor[3] = y_raton - 12;
+	pos_cursor[2] = mouseX - 20;
+	pos_cursor[3] = mouseY - 12;
 	pos_cursor[4] = 40;
 	pos_cursor[5] = 25;
 
@@ -3198,80 +3331,12 @@ void DrasculaEngine::introduce_nombre() {
 		key = getscan();
 		delay(70);
 		if (key != 0) {
-			if (key == Common::KEYCODE_q)
-				select2[v] = 'q';
-			else if (key == Common::KEYCODE_w)
-				select2[v] = 'w';
-			else if (key == Common::KEYCODE_e)
-				select2[v] = 'e';
-			else if (key == Common::KEYCODE_r)
-				select2[v] = 'r';
-			else if (key == Common::KEYCODE_t)
-				select2[v] = 't';
-			else if (key == Common::KEYCODE_y)
-				select2[v] = 'y';
-			else if (key == Common::KEYCODE_u)
-				select2[v] = 'u';
-			else if (key == Common::KEYCODE_i)
-				select2[v] = 'i';
-			else if (key == Common::KEYCODE_o)
-				select2[v] = 'o';
-			else if (key == Common::KEYCODE_p)
-				select2[v] = 'p';
-			else if (key == Common::KEYCODE_a)
-				select2[v] = 'a';
-			else if (key == Common::KEYCODE_s)
-				select2[v] = 's';
-			else if (key == Common::KEYCODE_d)
-				select2[v] = 'd';
-			else if (key == Common::KEYCODE_f)
-				select2[v] = 'f';
-			else if (key == Common::KEYCODE_g)
-				select2[v] = 'g';
-			else if (key == Common::KEYCODE_h)
-				select2[v] = 'h';
-			else if (key == Common::KEYCODE_j)
-				select2[v] = 'j';
-			else if (key == Common::KEYCODE_k)
-				select2[v] = 'k';
-			else if (key == Common::KEYCODE_l)
-				select2[v] = 'l';
+			if (key >= 0 && key <= 0xFF && isalpha(key))
+				select2[v] = tolower(key);
 			else if ((key == Common::KEYCODE_LCTRL) || (key == Common::KEYCODE_RCTRL))
 				select2[v] = '\164';
-			else if (key == Common::KEYCODE_z)
-				select2[v] = 'z';
-			else if (key == Common::KEYCODE_x)
-				select2[v] = 'x';
-			else if (key == Common::KEYCODE_c)
-				select2[v] = 'c';
-			else if (key == Common::KEYCODE_v)
-				select2[v] = 'v';
-			else if (key == Common::KEYCODE_b)
-				select2[v] = 'b';
-			else if (key == Common::KEYCODE_n)
-				select2[v] = 'n';
-			else if (key == Common::KEYCODE_m)
-				select2[v] = 'm';
-			else if (key == Common::KEYCODE_1)
-				select2[v] = '1';
-			else if (key == Common::KEYCODE_2)
-				select2[v] = '2';
-			else if (key == Common::KEYCODE_3)
-				select2[v] = '3';
-			else if (key == Common::KEYCODE_4)
-				select2[v] = '4';
-			else if (key == Common::KEYCODE_5)
-				select2[v] = '5';
-			else if (key == Common::KEYCODE_6)
-				select2[v] = '6';
-			else if (key == Common::KEYCODE_7)
-				select2[v] = '7';
-			else if (key == Common::KEYCODE_8)
-				select2[v] = '8';
-			else if (key == Common::KEYCODE_9)
-				select2[v] = '9';
-			else if (key == Common::KEYCODE_0)
-				select2[v] = '0';
+			else if (key >= Common::KEYCODE_0 && key <= Common::KEYCODE_9)
+				select2[v] = key;
 			else if (key == Common::KEYCODE_SPACE)
 				select2[v] = '\167';
 			else if (key == ESC)
@@ -3303,8 +3368,8 @@ void DrasculaEngine::introduce_nombre() {
 
 void DrasculaEngine::para_grabar(char nom_game[]) {
 	saveGame(nom_game);
-	comienza_sound("99.als");
-	fin_sound();
+	playSound("99.als");
+	stopSound();
 }
 
 void DrasculaEngine::OpenSSN(const char *Name, int Pause) {
@@ -3566,87 +3631,87 @@ char DrasculaEngine::codifica(char car) {
 	return ~car;
 }
 
-void DrasculaEngine::cuadrante_1() {
-	float distancia_x, distancia_y;
+void DrasculaEngine::quadrant_1() {
+	float distance_x, distance_y;
 
 	if (num_ejec == 2)
-		distancia_x = hare_x - sitio_x;
+		distance_x = hare_x - sitio_x;
 	else
-		distancia_x = hare_x + ancho_hare / 2 - sitio_x;
+		distance_x = hare_x + ancho_hare / 2 - sitio_x;
 
-	distancia_y = (hare_y + alto_hare) - sitio_y;
+	distance_y = (hare_y + alto_hare) - sitio_y;
 
-	if (distancia_x < distancia_y) {
+	if (distance_x < distance_y) {
 		direccion_hare = 0;
 		sentido_hare = 2;
-		step_x = (int)(distancia_x / (distancia_y / PASO_HARE_Y));
+		step_x = (int)(distance_x / (distance_y / PASO_HARE_Y));
 	} else {
 		direccion_hare = 7;
 		sentido_hare = 0;
-		step_y = (int)(distancia_y / (distancia_x / PASO_HARE_X));
+		step_y = (int)(distance_y / (distance_x / PASO_HARE_X));
 	}
 }
 
-void DrasculaEngine::cuadrante_2() {
-	float distancia_x, distancia_y;
+void DrasculaEngine::quadrant_2() {
+	float distance_x, distance_y;
 
 	if (num_ejec == 2)
-		distancia_x = abs(hare_x + ancho_hare - sitio_x);
+		distance_x = abs(hare_x + ancho_hare - sitio_x);
 	else
-		distancia_x = abs(hare_x + ancho_hare / 2 - sitio_x);
+		distance_x = abs(hare_x + ancho_hare / 2 - sitio_x);
 
-	distancia_y = (hare_y + alto_hare) - sitio_y;
+	distance_y = (hare_y + alto_hare) - sitio_y;
 
-	if (distancia_x < distancia_y) {
+	if (distance_x < distance_y) {
 		direccion_hare = 1;
 		sentido_hare = 2;
-		step_x = (int)(distancia_x / (distancia_y / PASO_HARE_Y));
+		step_x = (int)(distance_x / (distance_y / PASO_HARE_Y));
 	} else {
 		direccion_hare = 2;
 		sentido_hare = 1;
-		step_y = (int)(distancia_y / (distancia_x / PASO_HARE_X));
+		step_y = (int)(distance_y / (distance_x / PASO_HARE_X));
 	}
 }
 
-void DrasculaEngine::cuadrante_3() {
-	float distancia_x, distancia_y;
+void DrasculaEngine::quadrant_3() {
+	float distance_x, distance_y;
 
 	if (num_ejec == 2)
-		distancia_x = hare_x - sitio_x;
+		distance_x = hare_x - sitio_x;
 	else
-		distancia_x = hare_x + ancho_hare / 2 - sitio_x;
+		distance_x = hare_x + ancho_hare / 2 - sitio_x;
 
-	distancia_y = sitio_y - (hare_y + alto_hare);
+	distance_y = sitio_y - (hare_y + alto_hare);
 
-	if (distancia_x < distancia_y) {
+	if (distance_x < distance_y) {
 		direccion_hare = 5;
 		sentido_hare = 3;
-		step_x = (int)(distancia_x / (distancia_y / PASO_HARE_Y));
+		step_x = (int)(distance_x / (distance_y / PASO_HARE_Y));
 	} else {
 		direccion_hare = 6;
 		sentido_hare = 0;
-		step_y = (int)(distancia_y / (distancia_x / PASO_HARE_X));
+		step_y = (int)(distance_y / (distance_x / PASO_HARE_X));
 	}
 }
 
-void DrasculaEngine::cuadrante_4() {
-	float distancia_x, distancia_y;
+void DrasculaEngine::quadrant_4() {
+	float distance_x, distance_y;
 
 	if (num_ejec == 2)
-		distancia_x = abs(hare_x + ancho_hare - sitio_x);
+		distance_x = abs(hare_x + ancho_hare - sitio_x);
 	else
-		distancia_x = abs(hare_x + ancho_hare / 2 - sitio_x);
+		distance_x = abs(hare_x + ancho_hare / 2 - sitio_x);
 
-	distancia_y = sitio_y - (hare_y + alto_hare);
+	distance_y = sitio_y - (hare_y + alto_hare);
 
-	if (distancia_x < distancia_y) {
+	if (distance_x < distance_y) {
 		direccion_hare = 4;
 		sentido_hare = 3;
-		step_x = (int)(distancia_x / (distancia_y / PASO_HARE_Y));
+		step_x = (int)(distance_x / (distance_y / PASO_HARE_Y));
 	} else {
 		direccion_hare = 3;
 		sentido_hare = 1;
-		step_y = (int)(distancia_y / (distancia_x / PASO_HARE_X));
+		step_y = (int)(distance_y / (distance_x / PASO_HARE_X));
 	}
 }
 
@@ -3664,7 +3729,7 @@ void DrasculaEngine::saveGame(char nom_game[]) {
 	out->writeSint32LE(sentido_hare);
 
 	for (l = 1; l < 43; l++) {
-		out->writeSint32LE(objetos_que_tengo[l]);
+		out->writeSint32LE(inventoryObjects[l]);
 	}
 
 	for (l = 0; l < NUM_FLAGS; l++) {
@@ -3672,7 +3737,7 @@ void DrasculaEngine::saveGame(char nom_game[]) {
 	}
 
 	out->writeSint32LE(lleva_objeto);
-	out->writeSint32LE(objeto_que_lleva);
+	out->writeSint32LE(pickedObject);
 
 	out->finalize();
 	if (out->ioFailed())
@@ -3690,28 +3755,16 @@ void DrasculaEngine::aumenta_num_frame() {
 		if (num_frame == 6)
 			num_frame = 0;
 
-		if (direccion_hare == 0) {
+		if (direccion_hare == 0 || direccion_hare == 7) {
 			hare_x = hare_x - step_x;
 			hare_y = hare_y - step_y;
-		} else if (direccion_hare == 7) {
-			hare_x = hare_x - step_x;
-			hare_y = hare_y - step_y;
-		} else if (direccion_hare == 1) {
-			hare_x = hare_x + step_x;
-			hare_y = hare_y - step_y;
-		} else if (direccion_hare == 2) {
+		} else if (direccion_hare == 1 || direccion_hare == 2) {
 			hare_x = hare_x + step_x;
 			hare_y = hare_y - step_y;
-		} else if (direccion_hare == 3) {
-			hare_x = hare_x + step_x;
-			hare_y = hare_y + step_y;
-		} else if (direccion_hare == 4) {
+		} else if (direccion_hare == 3 || direccion_hare == 4) {
 			hare_x = hare_x + step_x;
 			hare_y = hare_y + step_y;
-		} else if (direccion_hare == 5) {
-			hare_x = hare_x - step_x;
-			hare_y = hare_y + step_y;
-		} else if (direccion_hare == 6) {
+		} else if (direccion_hare == 5 || direccion_hare == 6) {
 			hare_x = hare_x - step_x;
 			hare_y = hare_y + step_y;
 		}
@@ -3731,8 +3784,8 @@ int DrasculaEngine::sobre_que_objeto() {
 	int n = 0;
 
 	for (n = 1; n < 43; n++) {
-		if (x_raton > x_obj[n] && y_raton > y_obj[n]
-				&& x_raton < x_obj[n] + OBJWIDTH && y_raton < y_obj[n] + OBJHEIGHT)
+		if (mouseX > itemLocations[n].x && mouseY > itemLocations[n].y
+				&& mouseX < itemLocations[n].x + OBJWIDTH && mouseY < itemLocations[n].y + OBJHEIGHT)
 			break;
 	}
 
@@ -3744,7 +3797,7 @@ bool DrasculaEngine::comprueba_banderas_menu() {
 
 	for (n = 0; n < 43; n++) {
 		if (sobre_que_objeto() == n) {
-			h = objetos_que_tengo[n];
+			h = inventoryObjects[n];
 			if (h != 0)
 				if (banderas(h))
 					return true;
@@ -3756,23 +3809,23 @@ bool DrasculaEngine::comprueba_banderas_menu() {
 
 void DrasculaEngine::conversa(const char *nom_fich) {
 	int h;
-	int juego1 = 1, juego2 = 1, juego3 = 1, juego4 = 1;
-	char frase1[78];
-	char frase2[78];
-	char frase3[87];
-	char frase4[78];
+	int game1 = 1, game2 = 1, game3 = 1, game4 = 1;
+	char phrase1[78];
+	char phrase2[78];
+	char phrase3[87];
+	char phrase4[78];
 	char para_codificar[13];
-	char suena1[13];
-	char suena2[13];
-	char suena3[13];
-	char suena4[13];
-	int longitud;
-	int respuesta1;
-	int respuesta2;
-	int respuesta3;
-	int usado1 = 0;
-	int usado2 = 0;
-	int usado3 = 0;
+	char sound1[13];
+	char sound2[13];
+	char sound3[13];
+	char sound4[13];
+	int length;
+	int answer1;
+	int answer2;
+	int answer3;
+	int used1 = 0;
+	int used2 = 0;
+	int used3 = 0;
 	char buffer[256];
 
 	rompo_y_salgo = 0;
@@ -3790,67 +3843,67 @@ void DrasculaEngine::conversa(const char *nom_fich) {
 	int size = ald->size();
 
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%s", frase1);
+	sscanf(buffer, "%s", phrase1);
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%s", frase2);
+	sscanf(buffer, "%s", phrase2);
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%s", frase3);
+	sscanf(buffer, "%s", phrase3);
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%s", frase4);
+	sscanf(buffer, "%s", phrase4);
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%s", suena1);
+	sscanf(buffer, "%s", sound1);
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%s", suena2);
+	sscanf(buffer, "%s", sound2);
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%s", suena3);
+	sscanf(buffer, "%s", sound3);
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%s", suena4);
+	sscanf(buffer, "%s", sound4);
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%d", &respuesta1);
+	sscanf(buffer, "%d", &answer1);
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%d", &respuesta2);
+	sscanf(buffer, "%d", &answer2);
 	getLine(ald, buffer, size);
-	sscanf(buffer, "%d", &respuesta3);
+	sscanf(buffer, "%d", &answer3);
 	delete ald;
 	ald = NULL;
 
 	if (num_ejec == 2 && !strcmp(nom_fich, "op_5.cal") && flags[38] == 1 && flags[33] == 1) {
-		strcpy(frase3, _text[_lang][405]);
-		strcpy(suena3, "405.als");
-		respuesta3 = 31;
+		strcpy(phrase3, _text[_lang][405]);
+		strcpy(sound3, "405.als");
+		answer3 = 31;
 	}
 
 	if (num_ejec == 6 && !strcmp(nom_fich, "op_12.cal") && flags[7] == 1) {
-		strcpy(frase3, _text[_lang][273]);
-		strcpy(suena3, "273.als");
-		respuesta3 = 14;
+		strcpy(phrase3, _text[_lang][273]);
+		strcpy(sound3, "273.als");
+		answer3 = 14;
 	}
 
 	if (num_ejec == 6 && !strcmp(nom_fich, "op_12.cal") && flags[10] == 1) {
-		strcpy(frase3, " cuanto queda para que acabe el partido?");
-		strcpy(suena3, "274.als");
-		respuesta3 = 15;
+		strcpy(phrase3, " cuanto queda para que acabe el partido?");
+		strcpy(sound3, "274.als");
+		answer3 = 15;
 	}
 
-	longitud = strlen(frase1);
-	for (h = 0; h < longitud; h++)
-		if (frase1[h] == (char)0xa7)
-			frase1[h] = ' ';
+	length = strlen(phrase1);
+	for (h = 0; h < length; h++)
+		if (phrase1[h] == (char)0xa7)
+			phrase1[h] = ' ';
 
-	longitud = strlen(frase2);
-	for (h = 0; h < longitud; h++)
-		if (frase2[h] == (char)0xa7)
-			frase2[h] = ' ';
+	length = strlen(phrase2);
+	for (h = 0; h < length; h++)
+		if (phrase2[h] == (char)0xa7)
+			phrase2[h] = ' ';
 
-	longitud = strlen(frase3);
-	for (h = 0; h < longitud; h++)
-		if (frase3[h] == (char)0xa7)
-			frase3[h] = ' ';
+	length = strlen(phrase3);
+	for (h = 0; h < length; h++)
+		if (phrase3[h] == (char)0xa7)
+			phrase3[h] = ' ';
 
-	longitud = strlen(frase4);
-	for (h = 0; h < longitud; h++)
-		if (frase4[h] == (char)0xa7)
-			frase4[h] = ' ';
+	length = strlen(phrase4);
+	for (h = 0; h < length; h++)
+		if (phrase4[h] == (char)0xa7)
+			phrase4[h] = ' ';
 
 	loadPic("car.alg");
 	decompressPic(dir_hare_fondo, 1);
@@ -3876,89 +3929,89 @@ bucle_opc:
 
 	MirarRaton();
 
-	if (y_raton > 0 && y_raton < 9) {
-		if (usado1 == 1 && _color != WHITE)
+	if (mouseY > 0 && mouseY < 9) {
+		if (used1 == 1 && _color != WHITE)
 			color_abc(WHITE);
-		else if (usado1 == 0 && _color != LIGHT_GREEN)
+		else if (used1 == 0 && _color != LIGHT_GREEN)
 			color_abc(LIGHT_GREEN);
-	} else if (y_raton > 8 && y_raton < 17) {
-		if (usado2 == 1 && _color != WHITE)
+	} else if (mouseY > 8 && mouseY < 17) {
+		if (used2 == 1 && _color != WHITE)
 			color_abc(WHITE);
-		else if (usado2 == 0 && _color != LIGHT_GREEN)
+		else if (used2 == 0 && _color != LIGHT_GREEN)
 			color_abc(LIGHT_GREEN);
-	} else if (y_raton > 16 && y_raton < 25) {
-		if (usado3 == 1 && _color != WHITE)
+	} else if (mouseY > 16 && mouseY < 25) {
+		if (used3 == 1 && _color != WHITE)
 			color_abc(WHITE);
-		else if (usado3 == 0 && _color != LIGHT_GREEN)
+		else if (used3 == 0 && _color != LIGHT_GREEN)
 			color_abc(LIGHT_GREEN);
 	} else if (_color != LIGHT_GREEN)
 		color_abc(LIGHT_GREEN);
 
-	if (y_raton > 0 && y_raton < 9)
-		juego1 = 2;
-	else if (y_raton > 8 && y_raton < 17)
-		juego2 = 2;
-	else if (y_raton > 16 && y_raton < 25)
-		juego3 = 2;
-	else if (y_raton > 24 && y_raton < 33)
-		juego4 = 2;
+	if (mouseY > 0 && mouseY < 9)
+		game1 = 2;
+	else if (mouseY > 8 && mouseY < 17)
+		game2 = 2;
+	else if (mouseY > 16 && mouseY < 25)
+		game3 = 2;
+	else if (mouseY > 24 && mouseY < 33)
+		game4 = 2;
 
-	print_abc_opc(frase1, 1, 2, juego1);
-	print_abc_opc(frase2, 1, 10, juego2);
-	print_abc_opc(frase3, 1, 18, juego3);
-	print_abc_opc(frase4, 1, 26, juego4);
+	print_abc_opc(phrase1, 1, 2, game1);
+	print_abc_opc(phrase2, 1, 10, game2);
+	print_abc_opc(phrase3, 1, 18, game3);
+	print_abc_opc(phrase4, 1, 26, game4);
 
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 
-	if ((boton_izq == 1) && (juego1 == 2)) {
+	if ((button_izq == 1) && (game1 == 2)) {
 		delay(100);
-		usado1 = 1;
-		talk(frase1, suena1);
+		used1 = 1;
+		talk(phrase1, sound1);
 		if (num_ejec == 3)
 			grr();
 		else
-			responde(respuesta1);
-	} else if ((boton_izq == 1) && (juego2 == 2)) {
+			response(answer1);
+	} else if ((button_izq == 1) && (game2 == 2)) {
 		delay(100);
-		usado2 = 1;
-		talk(frase2, suena2);
+		used2 = 1;
+		talk(phrase2, sound2);
 		if (num_ejec == 3)
 			grr();
 		else
-			responde(respuesta2);
-	} else if ((boton_izq == 1) && (juego3 == 2)) {
+			response(answer2);
+	} else if ((button_izq == 1) && (game3 == 2)) {
 		delay(100);
-		usado3 = 1;
-		talk(frase3, suena3);
+		used3 = 1;
+		talk(phrase3, sound3);
 		if (num_ejec == 3)
 			grr();
 		else
-			responde(respuesta3);
-	} else if ((boton_izq == 1) && (juego4 == 2)) {
+			response(answer3);
+	} else if ((button_izq == 1) && (game4 == 2)) {
 		delay(100);
-		talk(frase4, suena4);
+		talk(phrase4, sound4);
 		rompo_y_salgo = 1;
 	}
 
-	if (boton_izq == 1) {
+	if (button_izq == 1) {
 		delay(100);
 		color_abc(LIGHT_GREEN);
 	}
 
-	if (usado1 == 0)
-		juego1 = 1;
+	if (used1 == 0)
+		game1 = 1;
 	else
-		juego1 = 3;
-	if (usado2 == 0)
-		juego2 = 1;
+		game1 = 3;
+	if (used2 == 0)
+		game2 = 1;
 	else
-		juego2 = 3;
-	if (usado3 == 0)
-		juego3 = 1;
+		game2 = 3;
+	if (used3 == 0)
+		game3 = 1;
 	else
-		juego3 = 3;
+		game3 = 3;
 
-	juego4 = 1;
+	game4 = 1;
 
 	if (rompo_y_salgo == 0)
 		goto bucle_opc;
@@ -3972,16 +4025,16 @@ bucle_opc:
 		withoutVerb();
 }
 
-void DrasculaEngine::print_abc_opc(const char *said, int x_pantalla, int y_pantalla, int juego) {
+void DrasculaEngine::print_abc_opc(const char *said, int x_pantalla, int y_pantalla, int game) {
 	int pos_texto[6];
-	int y_de_signos, y_de_letra, x_de_letra = 0, h, longitud;
-	longitud = strlen(said);
+	int y_de_signos, y_de_letra, x_de_letra = 0, h, length;
+	length = strlen(said);
 
-	for (h = 0; h < longitud; h++) {
-		if (juego == 1) {
+	for (h = 0; h < length; h++) {
+		if (game == 1) {
 			y_de_letra = Y_ABC_OPC_1;
 			y_de_signos = Y_SIGNOS_OPC_1;
-		} else if (juego == 3) {
+		} else if (game == 3) {
 			y_de_letra = Y_ABC_OPC_3;
 			y_de_signos = Y_SIGNOS_OPC_3;
 		} else {
@@ -3992,14 +4045,22 @@ void DrasculaEngine::print_abc_opc(const char *said, int x_pantalla, int y_panta
 		int c = toupper(said[h]);
 		if (c == 'A')
 			x_de_letra = X_A_OPC;
+		else if (c == '\265') x_de_letra = X_A_OPC;
+		else if (c == '\267') x_de_letra = X_A_OPC;
+		else if (c == '\266') x_de_letra = X_A_OPC;
 		else if (c == 'B')
 			x_de_letra = X_B_OPC;
 		else if (c == 'C')
 			x_de_letra = X_C_OPC;
+		else if (c == '\200') x_de_letra = X_C_OPC;
+		else if (c == '\207') x_de_letra = X_C_OPC;
 		else if (c == 'D')
 			x_de_letra = X_D_OPC;
 		else if (c == 'E')
 			x_de_letra = X_E_OPC;
+		else if (c == '\220') x_de_letra = X_E_OPC;
+		else if (c == '\324') x_de_letra = X_E_OPC;
+		else if (c == '\322') x_de_letra = X_E_OPC;
 		else if (c == 'F')
 			x_de_letra = X_F_OPC;
 		else if (c == 'G')
@@ -4008,6 +4069,9 @@ void DrasculaEngine::print_abc_opc(const char *said, int x_pantalla, int y_panta
 			x_de_letra = X_H_OPC;
 		else if (c == 'I')
 			x_de_letra = X_I_OPC;
+		else if (c == '\326') x_de_letra = X_I_OPC;
+		else if (c == '\336') x_de_letra = X_I_OPC;
+		else if (c == '\327') x_de_letra = X_I_OPC;
 		else if (c == 'J')
 			x_de_letra = X_J_OPC;
 		else if (c == 'K')
@@ -4018,10 +4082,14 @@ void DrasculaEngine::print_abc_opc(const char *said, int x_pantalla, int y_panta
 			x_de_letra = X_M_OPC;
 		else if (c == 'N')
 			x_de_letra = X_N_OPC;
+		else if (c == '\047') x_de_letra = X_GN_OPC;
 		else if (c == 'O')
 			x_de_letra = X_O_OPC;
 		else if (c == 'P')
 			x_de_letra = X_P_OPC;
+		else if (c == '\340') x_de_letra = X_O_OPC;
+		else if (c == '\342') x_de_letra = X_O_OPC;
+		else if (c == '\343') x_de_letra = X_O_OPC;
 		else if (c == 'Q')
 			x_de_letra = X_Q_OPC;
 		else if (c == 'R')
@@ -4032,6 +4100,9 @@ void DrasculaEngine::print_abc_opc(const char *said, int x_pantalla, int y_panta
 			x_de_letra = X_T_OPC;
 		else if (c == 'U')
 			x_de_letra = X_U_OPC;
+		else if (c == '\353') x_de_letra = X_U_OPC;
+		else if (c == '\352') x_de_letra = X_U_OPC;
+		else if (c == '\351') x_de_letra = X_U_OPC;
 		else if (c == 'V')
 			x_de_letra = X_V_OPC;
 		else if (c == 'W')
@@ -4123,7 +4194,7 @@ void DrasculaEngine::print_abc_opc(const char *said, int x_pantalla, int y_panta
 	}
 }
 
-void DrasculaEngine::responde(int funcion) {
+void DrasculaEngine::response(int funcion) {
 	if (num_ejec == 1) {
 		if (funcion == 10)
 			talk_borracho(_textb[_lang][1], "B1.als");
@@ -4205,25 +4276,25 @@ void DrasculaEngine::responde(int funcion) {
 }
 
 void DrasculaEngine::suma_objeto(int osj) {
-	int h, puesto = 0;
+	int h, position = 0;
 
 	for (h = 1; h < 43; h++) {
-		if (objetos_que_tengo[h] == osj)
-			puesto = 1;
+		if (inventoryObjects[h] == osj)
+			position = 1;
 	}
 
-	if (puesto == 0) {
+	if (position == 0) {
 		for (h = 1; h < 43; h++) {
-			if (objetos_que_tengo[h] == 0) {
-				objetos_que_tengo[h] = osj;
-				puesto = 1;
+			if (inventoryObjects[h] == 0) {
+				inventoryObjects[h] = osj;
+				position = 1;
 				break;
 			}
 		}
 	}
 }
 
-void DrasculaEngine::fin_sound_corte() {
+void DrasculaEngine::stopSound_corte() {
 	if (hay_sb == 1) {
 		ctvd_stop();
 		delete sku;
@@ -4284,69 +4355,69 @@ void DrasculaEngine::updateData() {
 	if (num_ejec == 1) {
 		// nothing
 	} else if (num_ejec == 2) {
-		if (!strcmp(num_room,"2.alg") && flags[40] == 0)
+		if (roomNumber == 2 && flags[40] == 0)
 			visible[3] = 0;
-		else if (!strcmp(num_room, "3.alg") && flags[3] == 1)
+		else if (roomNumber == 3 && flags[3] == 1)
 			visible[8] = 0;
-		else if (!strcmp(num_room, "6.alg") && flags[1] == 1 && flags[10] == 0) {
+		else if (roomNumber == 6 && flags[1] == 1 && flags[10] == 0) {
 			visible[2] = 0;
 			visible[4] = 1;
-		} else if (!strcmp(num_room, "7.alg") && flags[35] == 1)
+		} else if (roomNumber == 7 && flags[35] == 1)
 			visible[3] = 0;
-		else if (!strcmp(num_room, "14.alg") && flags[5] == 1)
+		else if (roomNumber == 14 && flags[5] == 1)
 			visible[4] = 0;
-		else if (!strcmp(num_room, "18.alg") && flags[28] == 1)
+		else if (roomNumber == 18 && flags[28] == 1)
 			visible[2] = 0;
 	} else if (num_ejec == 3) {
 		// nothing
 	} else if (num_ejec == 4) {
-		if (!strcmp(num_room, "23.alg") && flags[0] == 0 && flags[11] == 0)
+		if (roomNumber == 23 && flags[0] == 0 && flags[11] == 0)
 			visible[2] = 1;
-		if (!strcmp(num_room, "23.alg") && flags[0] == 1 && flags[11] == 0)
+		if (roomNumber == 23 && flags[0] == 1 && flags[11] == 0)
 			visible[2] = 0;
-		if (!strcmp(num_room, "21.alg") && flags[10] == 1)
+		if (roomNumber == 21 && flags[10] == 1)
 			visible[2] = 0;
-		if (!strcmp(num_room, "22.alg") && flags[26] == 1) {
+		if (roomNumber == 22 && flags[26] == 1) {
 			visible[2] = 0;
 			visible[1] = 1;
 		}
-		if (!strcmp(num_room, "22.alg") && flags[27] == 1)
+		if (roomNumber == 22 && flags[27] == 1)
 			visible[3] = 0;
-		if (!strcmp(num_room, "26.alg") && flags[21] == 0)
+		if (roomNumber == 26 && flags[21] == 0)
 			strcpy(objName[2], _textmisc[_lang][0]);
-		if (!strcmp(num_room, "26.alg") && flags[18] == 1)
+		if (roomNumber == 26 && flags[18] == 1)
 			visible[2] = 0;
-		if (!strcmp(num_room, "26.alg") && flags[12] == 1)
+		if (roomNumber == 26 && flags[12] == 1)
 			visible[1] = 0;
-		if (!strcmp(num_room, "35.alg") && flags[14] == 1)
+		if (roomNumber == 35 && flags[14] == 1)
 			visible[2] = 0;
-		if (!strcmp(num_room, "35.alg") && flags[17] == 1)
+		if (roomNumber == 35 && flags[17] == 1)
 			visible[3] = 1;
-		if (!strcmp(num_room, "35.alg") && flags[15] == 1)
+		if (roomNumber == 35 && flags[15] == 1)
 			visible[1] = 0;
 	} else if (num_ejec == 5) {
-		if (!strcmp(num_room,"49.alg") && flags[6] == 1)
+		if (roomNumber == 49 && flags[6] == 1)
 			visible[2] = 0;
-		if (!strcmp(num_room,"49.alg") && flags[6] == 0)
+		if (roomNumber == 49 && flags[6] == 0)
 			visible[1] = 0;
-		if (!strcmp(num_room,"49.alg") && flags[6] == 1)
+		if (roomNumber == 49 && flags[6] == 1)
 			visible[1] = 1;
-		if (!strcmp(num_room,"45.alg") && flags[6] == 1)
+		if (roomNumber == 45 && flags[6] == 1)
 			visible[3] = 1;
-		if (!strcmp(num_room,"53.alg") && flags[2] == 1)
+		if (roomNumber == 53 && flags[2] == 1)
 			visible[3] = 0;
-		if (!strcmp(num_room,"54.alg") && flags[13] == 1)
+		if (roomNumber == 54 && flags[13] == 1)
 			visible[3] = 0;
-		if (!strcmp(num_room,"55.alg") && flags[8] == 1)
+		if (roomNumber == 55 && flags[8] == 1)
 			visible[1] = 0;
 	} else if (num_ejec == 6) {
-		if ((!strcmp(num_room, "58.alg")) && flags[8] == 0)
+		if (roomNumber == 58 && flags[8] == 0)
 			isDoor[1] = 0;
-		if ((!strcmp(num_room, "58.alg")) && flags[8] == 1)
+		if (roomNumber == 58 && flags[8] == 1)
 			isDoor[1] = 1;
-		if (!strcmp(num_room, "59.alg"))
+		if (roomNumber == 59)
 			isDoor[1] = 0;
-		if (!strcmp(num_room, "60.alg")) {
+		if (roomNumber == 60) {
 			sentido_dr = 0;
 			x_dr = 155;
 			y_dr = 69;
@@ -4465,23 +4536,23 @@ comienza:
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 }
 
-void DrasculaEngine::openDoor(int nflag, int n_puerta) {
+void DrasculaEngine::openDoor(int nflag, int doorNum) {
 	if (flags[nflag] == 0) {
 		if (num_ejec == 1 /*|| num_ejec == 4*/) {
 			if (nflag != 7) {
-				comienza_sound("s3.als");
+				playSound("s3.als");
 				flags[nflag] = 1;
 			}
 		} else {
-			comienza_sound("s3.als");
+			playSound("s3.als");
 			flags[nflag] = 1;
 		}
 
-		if (n_puerta != NO_DOOR)
-			puertas_cerradas(n_puerta);
+		if (doorNum != NO_DOOR)
+			puertas_cerradas(doorNum);
 		updateRoom();
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-		fin_sound();
+		stopSound();
 		withoutVerb();
 	}
 }
@@ -4490,8 +4561,8 @@ void DrasculaEngine::mapa() {
 	int l, veo = 0;
 
 	for (l = 0; l < numRoomObjs; l++) {
-		if (x_raton > x1[l] && y_raton > y1[l]
-				&& x_raton < x2[l] && y_raton < y2[l]
+		if (mouseX > x1[l] && mouseY > y1[l]
+				&& mouseX < x2[l] && mouseY < y2[l]
 				&& visible[l] == 1) {
 			strcpy(texto_nombre, objName[l]);
 			hay_nombre = 1;
@@ -4504,8 +4575,7 @@ void DrasculaEngine::mapa() {
 }
 
 void DrasculaEngine::grr() {
-	int longitud;
-	longitud = 30;
+	int length = 30;
 
 	color_abc(DARK_GREEN);
 
@@ -4539,8 +4609,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -4551,7 +4621,7 @@ bucless:
 void DrasculaEngine::activa_pendulo() {
 	flags[1] = 2;
 	hare_se_ve = 0;
-	strcpy(num_room, "102.alg");
+	roomNumber = 102;
 	loadPic("102.alg");
 	decompressPic(dir_dibujo1, HALF_PAL);
 	loadPic("an_p1.alg");
@@ -4566,15 +4636,15 @@ void DrasculaEngine::activa_pendulo() {
 	conta_ciego_vez = vez();
 }
 
-void DrasculaEngine::cierra_puerta(int nflag, int n_puerta) {
+void DrasculaEngine::closeDoor(int nflag, int doorNum) {
 	if (flags[nflag] == 1) {
-		comienza_sound("s4.als");
+		playSound("s4.als");
 		flags[nflag] = 0;
-		if (n_puerta != NO_DOOR)
-			puertas_cerradas(n_puerta);
+		if (doorNum != NO_DOOR)
+			puertas_cerradas(doorNum);
 		updateRoom();
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-		fin_sound();
+		stopSound();
 		withoutVerb();
 	}
 }
diff --git a/engines/drascula/drascula.h b/engines/drascula/drascula.h
index 5cbc1fd403..512ebb9950 100644
--- a/engines/drascula/drascula.h
+++ b/engines/drascula/drascula.h
@@ -56,9 +56,20 @@ enum Languages {
 	kItalian = 4
 };
 
+enum Verbs {
+	kVerbDefault = -1,
+	kVerbLook = 1,
+	kVerbPick = 2,
+	kVerbOpen = 3,
+	kVerbClose = 4,
+	kVerbTalk = 5,
+	kVerbMove = 6
+};
+
 #define TEXTD_START 68
 
 struct DrasculaGameDescription;
+struct RoomTalkAction;
 
 #define NUM_SAVES     10
 #define NUM_FLAGS     50
@@ -72,110 +83,19 @@ struct DrasculaGameDescription;
 #define F8           0x42
 #define F9           0x43
 #define F10          0x44
-#define LOOK            1
-#define PICK            2
-#define OPEN            3
-#define CLOSE           4
-#define TALK            5
-#define MOVE            6
 #define DIF_MASK       55
 #define OBJWIDTH        40
 #define OBJHEIGHT         25
 
-#define X_OBJ1         5
-#define Y_OBJ1         10
-#define X_OBJ2         50
-#define Y_OBJ2         10
-#define X_OBJ3         95
-#define Y_OBJ3         10
-#define X_OBJ4         140
-#define Y_OBJ4         10
-#define X_OBJ5         185
-#define Y_OBJ5         10
-#define X_OBJ6         230
-#define Y_OBJ6         10
-#define X_OBJ7         275
-#define Y_OBJ7         10
-#define X_OBJ8         5
-#define Y_OBJ8         40
-#define X_OBJ9         50
-#define Y_OBJ9         40
-#define X_OBJ10        95
-#define Y_OBJ10        40
-#define X_OBJ11        140
-#define Y_OBJ11        40
-#define X_OBJ12        185
-#define Y_OBJ12        40
-#define X_OBJ13        230
-#define Y_OBJ13        40
-#define X_OBJ14        275
-#define Y_OBJ14        40
-#define X_OBJ15        5
-#define Y_OBJ15        70
-#define X_OBJ16        50
-#define Y_OBJ16        70
-#define X_OBJ17        95
-#define Y_OBJ17        70
-#define X_OBJ18        140
-#define Y_OBJ18        70
-#define X_OBJ19        185
-#define Y_OBJ19        70
-#define X_OBJ20        230
-#define Y_OBJ20        70
-#define X_OBJ21        275
-#define Y_OBJ21        70
-#define X_OBJ22        5
-#define Y_OBJ22        100
-#define X_OBJ23        50
-#define Y_OBJ23        100
-#define X_OBJ24        95
-#define Y_OBJ24        100
-#define X_OBJ25        140
-#define Y_OBJ25        100
-#define X_OBJ26        185
-#define Y_OBJ26        100
-#define X_OBJ27        230
-#define Y_OBJ27        100
-#define X_OBJ28        275
-#define Y_OBJ28        100
-#define X_OBJ29        5
-#define Y_OBJ29        130
-#define X_OBJ30        50
-#define Y_OBJ30        130
-#define X_OBJ31        95
-#define Y_OBJ31        130
-#define X_OBJ32        140
-#define Y_OBJ32        130
-#define X_OBJ33        185
-#define Y_OBJ33        130
-#define X_OBJ34        230
-#define Y_OBJ34        130
-#define X_OBJ35        275
-#define Y_OBJ35        130
-#define X_OBJ36        5
-#define Y_OBJ36        160
-#define X_OBJ37        50
-#define Y_OBJ37        160
-#define X_OBJ38        95
-#define Y_OBJ38        160
-#define X_OBJ39        140
-#define Y_OBJ39        160
-#define X_OBJ40        185
-#define Y_OBJ40        160
-#define X_OBJ41        230
-#define Y_OBJ41        160
-#define X_OBJ42        275
-#define Y_OBJ42        160
-#define X_OBJ43        275
-#define Y_OBJ43        160
-
 #define DIF_MASK_HARE   72
 #define DIF_MASK_ABC    22
 #define CHAR_WIDTH     8
 #define CHAR_HEIGHT      6
 
 #define Y_ABC            158
+#define Y_ABC_ESP        149
 #define Y_SIGNOS         169
+#define Y_SIGNOS_ESP     160
 #define Y_ACENTOS        180
 
 #define X_A              6
@@ -356,6 +276,7 @@ public:
 	uint32 getFeatures() const;
 	uint16 getVersion() const;
 	Common::Platform getPlatform() const;
+	Common::Language getLanguage() const;
 	void updateEvents();
 
 	Audio::SoundHandle _soundHandle;
@@ -380,7 +301,7 @@ public:
 	void copyRectClip(int *Array, byte *src, byte *dest);
 	void updateScreen(int xorg, int yorg, int xdes, int ydes, int width, int height, byte *buffer);
 
-	DacPalette256 palJuego;
+	DacPalette256 gamePalette;
 	DacPalette256 palHare;
 	DacPalette256 palHareClaro;
 	DacPalette256 palHareOscuro;
@@ -406,7 +327,8 @@ public:
 
 	int hay_sb;
 	int nivel_osc, previousMusic, roomMusic;
-	char num_room[20], roomDisk[20];
+	int roomNumber;
+	char roomDisk[20];
 	char currentData[20];
 	int numRoomObjs;
 	char fondo_y_menu[20];
@@ -416,11 +338,11 @@ public:
 
 	int num_obj[40], visible[40], isDoor[40];
 	int sitiobj_x[40], sitiobj_y[40], sentidobj[40];
-	int objetos_que_tengo[43];
+	int inventoryObjects[43];
 	char alapantallakeva[40][20];
 	int x_alakeva[40], y_alakeva[40], sentido_alkeva[40], alapuertakeva[40];
 	int x1[40], y1[40], x2[40], y2[40];
-	int lleva_objeto, objeto_que_lleva;
+	int lleva_objeto, pickedObject;
 	int withVoices;
 	int menu_bar, menu_scr, hay_nombre;
 	char texto_nombre[20];
@@ -444,7 +366,7 @@ public:
 	int sentido_final, anda_a_objeto;
 	int obj_saliendo;
 	int diff_vez, conta_vez;
-	int hay_respuesta;
+	int hay_answer;
 	int conta_ciego_vez;
 	int cambio_de_color;
 	int rompo_y_salgo;
@@ -469,15 +391,17 @@ public:
 	int corta_musica;
 	char select[23];
 	int hay_seleccion;
-	int x_raton;
-	int y_raton;
-	int y_raton_ant;
-	int boton_izq;
-	int boton_dch;
+	int mouseX;
+	int mouseY;
+	int mouseY_ant;
+	int button_izq;
+	int button_dch;
 
 	bool escoba();
 	void black();
+	void talk_vb(int);
 	void talk_vb(const char *, const char *);
+	void talk_vbpuerta(int);
 	void talk_vbpuerta(const char *said, const char *filename);
 	void talk_ciego(const char *, const char *, const char *);
 	void talk_hacker(const char *, const char *);
@@ -487,7 +411,7 @@ public:
 	void pon_vb();
 	void lleva_vb(int punto_x);
 	void hipo_sin_nadie(int counter);
-	void openDoor(int nflag, int n_puerta);
+	void openDoor(int nflag, int doorNum);
 	void mapa();
 	void animation_1_1();
 	void animation_2_1();
@@ -598,15 +522,16 @@ public:
 	char LimitaVGA(char valor);
 	void color_abc(int cl);
 	void centra_texto(const char *,int,int);
-	void comienza_sound(const char *);
-	void anima(const char *animation, int FPS);
-	void fin_sound_corte();
+	void playSound(const char *);
+	bool anima(const char *animation, int FPS);
+	void stopSound_corte();
 	void FundeAlNegro(int VelocidadDeFundido);
 	void pause(int);
 	void talk_dr_grande(const char *said, const char *filename);
 	void pon_igor();
 	void pon_bj();
 	void pon_dr();
+	void talkInit(const char *filename);
 	void talk_igor_dch(const char *said, const char *filename);
 	void talk_dr_dch(const char *said, const char *filename);
 	void talk_dr_izq(const char *said, const char *filename);
@@ -616,19 +541,21 @@ public:
 	void talk_igorpuerta(const char *said, const char *filename);
 	void talk_igor_peluca(const char *said, const char *filename);
 	void hipo(int);
-	void fin_sound();
+	void stopSound();
+	void talk_bj(int);
 	void talk_bj(const char *, const char *);
 	void talk_baul(const char *said, const char *filename);
+	void talk(int);
 	void talk(const char *, const char *);
 	void talk_sinc(const char *, const char *, const char *);
-	void cierra_puerta(int nflag, int n_puerta);
+	void closeDoor(int nflag, int doorNum);
 	void playMusic(int p);
 	void stopMusic();
 	int musicStatus();
 	void updateRoom();
 	bool carga_partida(const char *);
 	void puertas_cerradas(int);
-	void animafin_sound_corte();
+	void animastopSound_corte();
 	void color_hare();
 	void funde_hare(int oscuridad);
 	void paleta_hare_claro();
@@ -684,10 +611,10 @@ public:
 	int vez();
 	void reduce_hare_chico(int, int, int, int, int, int, int, byte *, byte *);
 	char codifica(char);
-	void cuadrante_1();
-	void cuadrante_2();
-	void cuadrante_3();
-	void cuadrante_4();
+	void quadrant_1();
+	void quadrant_2();
+	void quadrant_3();
+	void quadrant_4();
 	void update_62();
 	void update_62_pre();
 	void update_63();
@@ -695,6 +622,7 @@ public:
 	void aumenta_num_frame();
 	int sobre_que_objeto();
 	bool comprueba_banderas_menu();
+	bool roomParse(RoomTalkAction*, int);
 	void room_0();
 	void room_1(int);
 	void room_2(int);
@@ -728,7 +656,7 @@ public:
 	void room_63(int);
 	void conversa(const char *);
 	void print_abc_opc(const char *, int, int, int);
-	void responde(int);
+	void response(int);
 	void talk_borracho(const char *said, const char *filename);
 	void talk_pianista(const char *said, const char *filename);
 
@@ -822,6 +750,7 @@ public:
 	void talk_pen(const char *, const char *);
 	void talk_pen2(const char *, const char *);
 	void talk_taber2(const char *, const char *);
+	void talk_bj_cama(int);
 	void talk_bj_cama(const char *said, const char * filename);
 	void talk_htel(const char *said, const char *filename);
 
@@ -842,7 +771,7 @@ extern const char *_textvb[][63];
 extern const char *_textsys[][4];
 extern const char *_texthis[][5];
 extern const char *_textverbs[][6];
-extern const char *_textmisc[][1];
+extern const char *_textmisc[][2];
 extern const char *_textd1[][11];
 
 } // End of namespace Drascula
diff --git a/engines/drascula/rooms.cpp b/engines/drascula/rooms.cpp
index 7f6fa8f8b3..50f1110c23 100644
--- a/engines/drascula/rooms.cpp
+++ b/engines/drascula/rooms.cpp
@@ -32,132 +32,252 @@ static const char mirar_v[3][14] = {"100.als", "101.als", "54.als"};
 static const int poder_t[6] = {11, 109, 111, 110, 115, 116};
 static const char poder_v[6][14] = {"11.als", "109.als", "111.als", "110.als", "115.als", "116.als"};
 
+struct RoomTalkAction {
+	int num;
+	int action;
+	int objectID;
+	int speechID;
+};
+
+// TODO: move these elsewhere, or in a .dat file?
+// Note: default action needs to be LAST for each group
+// of actions with the same number
+RoomTalkAction room0Actions[] = {
+	// num	action		object	speech
+	{ 1,	kVerbLook,		-1,		 54 },
+	{ 1,	kVerbMove,		-1,		 19 },
+	{ 1,	kVerbPick,		-1,		 11 },
+	{ 1,	kVerbOpen,		-1,		  9 },
+	{ 1,	kVerbClose,		-1,		  9 },
+	{ 1,	kVerbTalk,		-1,		 16 },
+	{ 1,	kVerbDefault,	-1,		 11 },
+	// -------------------------------
+	{ 2,	kVerbMove,		-1,		 19 },
+	{ 2,	kVerbOpen,		-1,		  9 },
+	{ 2,	kVerbClose,		-1,		  9 },
+	{ 2,	kVerbTalk,		-1,		 16 },
+	// -------------------------------
+	{ 3,	kVerbLook,		-1,		316 },
+	{ 3,	kVerbMove,		-1,		317 },
+	{ 3,	kVerbPick,		-1,		318 },
+	{ 3,	kVerbOpen,		-1,		319 },
+	{ 3,	kVerbClose,		-1,		319 },
+	{ 3,	kVerbTalk,		-1,		320 },
+	{ 3,	kVerbDefault,	-1,		318 },
+	// -------------------------------
+	{ 4,	kVerbMove,		-1,		 19 },
+	{ 4,	kVerbOpen,		-1,		  9 },
+	{ 4,	kVerbClose,		-1,		  9 },
+	{ 4,	kVerbTalk,		-1,		 16 },
+	// -------------------------------
+	{ 5,	kVerbOpen,		-1,		  9 },
+	{ 5,	kVerbClose,		-1,		  9 },
+	{ 5,	kVerbTalk,		-1,		 16 },
+	// -------------------------------
+	{ 6,	kVerbMove,		-1,		 19 },
+	{ 6,	kVerbOpen,		-1,		  9 },
+	{ 6,	kVerbClose,		-1,		  9 },
+	{ 6,	kVerbTalk,		-1,		 16 }
+};
+
+RoomTalkAction room1Actions[] = {
+	// num	action		object	speech
+	{ -1,	kVerbPick,		118,	  5 },
+	{ -1,	kVerbOpen,		118,	  3 },
+	{ -1,	kVerbClose,		118,	  4 },
+	{ -1,	kVerbTalk,		118,	  6 },
+	// -------------------------------
+	{ -1,	kVerbLook,		119,	  8 },
+	{ -1,	kVerbMove,		119,	 13 },
+	{ -1,	kVerbClose,		119,	 10 },
+	{ -1,	kVerbTalk,		119,	 12 },
+	// -------------------------------
+	{ -1,	kVerbMove,		120,	 13 },
+	{ -1,	kVerbOpen,		120,	 18 },
+	{ -1,	kVerbTalk,		120,	 15 }
+};
+
+RoomTalkAction room3Actions[] = {
+	// num	action		object	speech
+	{ -1,	kVerbLook,		129,	 21 },
+	{ -1,	kVerbPick,		129,	  5 },
+	{ -1,	kVerbMove,		129,	 24 },
+	{ -1,	kVerbOpen,		129,	 22 },
+	{ -1,	kVerbClose,		129,	 10 },
+	// -------------------------------
+	{ -1,	kVerbLook,		131,	 27 },
+	{ -1,	kVerbPick,		131,	  5 },
+	{ -1,	kVerbMove,		131,	 24 },
+	{ -1,	kVerbOpen,		131,	 22 },
+	{ -1,	kVerbClose,		131,	 10 },
+	{ -1,	kVerbTalk,		131,	 23 },
+	// -------------------------------
+	{ -1,	kVerbLook,		132,	 28 },
+	{ -1,	kVerbPick,		132,	  5 },
+	{ -1,	kVerbMove,		132,	 24 },
+	{ -1,	kVerbOpen,		132,	 22 },
+	{ -1,	kVerbClose,		132,	 10 },
+	{ -1,	kVerbTalk,		132,	 23 },
+	// -------------------------------
+	{ -1,	kVerbLook,		133,	321 },
+	{ -1,	kVerbPick,		133,	 31 },
+	{ -1,	kVerbMove,		133,	 34 },
+	{ -1,	kVerbOpen,		133,	 30 },
+	{ -1,	kVerbClose,		133,	 10 },
+	// -------------------------------
+	{ -1,	kVerbLook,		166,	 55 },
+	{ -1,	kVerbPick,		166,	  7 },
+	// -------------------------------
+	{ -1,	kVerbLook,		211,	184 }
+};
+
+RoomTalkAction room4Actions[] = {
+	// num	action		object	speech
+	{ -1,	kVerbLook,		189,	182 },
+	// -------------------------------
+	{ -1,	kVerbLook,		207,	175 },
+	{ -1,	kVerbTalk,		207,	176 },
+	// -------------------------------
+	{ -1,	kVerbLook,		208,	177 },
+	// -------------------------------
+	{ -1,	kVerbLook,		209,	179 },
+	// -------------------------------
+	{ -1,	kVerbLook,		210,	180 },
+	{ -1,	kVerbOpen,		210,	181 }
+};
+
+RoomTalkAction room5Actions[] = {
+	// num	action		object	speech
+	{ -1,	kVerbMove,		136,	 13 },
+	{ -1,	kVerbOpen,		136,	 18 },
+	{ -1,	kVerbTalk,		136,	 15 },
+	// -------------------------------
+	{ -1,	kVerbLook,		212,	187 },
+	{ -1,	kVerbTalk,		212,	188 },
+	// -------------------------------
+	{ -1,	kVerbLook,		213,	189 },
+	{ -1,	kVerbOpen,		213,	190 }
+};
+
+RoomTalkAction room6Actions[] = {
+	// num	action		object	speech
+	{ -1,	kVerbPick,		144,	 43 },
+	// -------------------------------
+	{ -1,	kVerbLook,		138,	 35 },
+	{ -1,	kVerbTalk,		138,	  6 },
+	// -------------------------------
+	{ -1,	kVerbLook,		143,	 37 },
+	{ -1,	kVerbPick,		143,	  7 },
+	{ -1,	kVerbMove,		143,	  7 },
+	{ -1,	kVerbTalk,		143,	 38 },
+	// -------------------------------
+	{ -1,	kVerbLook,		139,	 36 },
+	// -------------------------------
+	{ -1,	kVerbLook,		140,	147 }
+};
+
+RoomTalkAction room12Actions[] = {
+	// num	action		object	speech
+	{ -1,	kVerbLook,		154,	329 },
+	{ -1,	kVerbTalk,		154,	330 },
+	// -------------------------------
+	{ -1,	kVerbMove,		155,	 48 },
+	{ -1,	kVerbTalk,		155,	331 },
+	// -------------------------------
+	{ -1,	kVerbLook,		156,	 35 },
+	{ -1,	kVerbMove,		156,	 48 },
+	{ -1,	kVerbTalk,		156,	 50 },
+};
+
+bool DrasculaEngine::roomParse(RoomTalkAction* roomActions, int fl) {
+	bool didAction = false;
+
+	for (int i = 0; i < ARRAYSIZE(roomActions); i++) {
+		if (roomActions[i].num == num_ejec || 
+			roomActions[i].num == -1) {
+			if (roomActions[i].action == pickedObject ||
+				roomActions[i].action == kVerbDefault) {
+				if (roomActions[i].objectID == fl ||
+					roomActions[i].objectID == -1) {
+					talk(roomActions[i].speechID);
+					didAction = true;
+					break;
+				}
+			}
+		}
+	}
+
+	return didAction;
+}
+
 void DrasculaEngine::room_0() {
-	if (num_ejec == 1) {
-		if (objeto_que_lleva == LOOK)
-			talk(_text[_lang][54], "54.als");
-		else if (objeto_que_lleva == MOVE)
-			talk(_text[_lang][19], "19.als");
-		else if (objeto_que_lleva == PICK)
-			talk(_text[_lang][11], "11.als");
-		else if (objeto_que_lleva == OPEN)
-			talk(_text[_lang][9], "9.als");
-		else if (objeto_que_lleva == CLOSE)
-			talk(_text[_lang][9], "9.als");
-		else if (objeto_que_lleva == TALK)
-			talk(_text[_lang][16], "16.als");
-		else
-			talk(_text[_lang][11],"11.als");
-	} else if (num_ejec == 2) {
-		if (objeto_que_lleva == LOOK) {
+	if (roomParse(room0Actions, -1))
+		return;
+
+	// non-default actions
+	if (num_ejec == 2) {
+		if (pickedObject == kVerbLook) {
 			talk(_text[_lang][mirar_t[c_mirar]], mirar_v[c_mirar]);
 			c_mirar++;
 			if (c_mirar == 3)
 				c_mirar = 0;
-		} else if (objeto_que_lleva == MOVE) {
-			talk(_text[_lang][19], "19.als");
-		} else if (objeto_que_lleva == PICK) {
+		} else if (pickedObject == kVerbPick) {
 			talk(_text[_lang][poder_t[c_poder]], poder_v[c_poder]);
 			c_poder++;
 			if (c_poder == 6)
 				c_poder = 0;
-		} else if (objeto_que_lleva == OPEN)
-			talk(_text[_lang][9], "9.als");
-		else if (objeto_que_lleva == CLOSE)
-			talk(_text[_lang][9], "9.als");
-		else if (objeto_que_lleva == TALK)
-			talk(_text[_lang][16], "16.als");
-		else {
+		} else {
 			talk(_text[_lang][poder_t[c_poder]], poder_v[c_poder]);
 			c_poder++;
 			if (c_poder == 6)
 				c_poder = 0;
 		}
-	} else if (num_ejec == 3) {
-		if (objeto_que_lleva == LOOK)
-			talk(_text[_lang][316], "316.als");
-		else if (objeto_que_lleva == MOVE)
-			talk(_text[_lang][317], "317.als");
-		else if (objeto_que_lleva == PICK)
-			talk(_text[_lang][318], "318.als");
-		else if (objeto_que_lleva == OPEN)
-			talk(_text[_lang][319], "319.als");
-		else if (objeto_que_lleva == CLOSE)
-			talk(_text[_lang][319], "319.als");
-		else if (objeto_que_lleva == TALK)
-			talk(_text[_lang][320], "320.als");
-		else
-			talk(_text[_lang][318], "318.als");
 	} else if (num_ejec == 4) {
-		if (objeto_que_lleva == LOOK) {
+		if (pickedObject == kVerbLook) {
 			talk(_text[_lang][mirar_t[c_mirar]], mirar_v[c_mirar]);
 			c_mirar++;
 			if (c_mirar == 3)
 				c_mirar = 0;
-		} else if (objeto_que_lleva == MOVE)
-			talk(_text[_lang][19], "19.als");
-		else if (objeto_que_lleva == PICK) {
+		} else if (pickedObject == kVerbPick) {
 			talk(_text[_lang][poder_t[c_poder]], poder_v[c_poder]);
 			c_poder++;
 			if (c_poder == 6)
 				c_poder = 0;
-		} else if (objeto_que_lleva == OPEN)
-			talk(_text[_lang][9], "9.als");
-		else if (objeto_que_lleva == CLOSE)
-			talk(_text[_lang][9], "9.als");
-		else if (objeto_que_lleva == TALK)
-			talk(_text[_lang][16], "16.als");
-		else {
+		} else {
 			talk(_text[_lang][poder_t[c_poder]], poder_v[c_poder]);
 			c_poder++;
 			if (c_poder == 6)
 				c_poder = 0;
 		}
 	} else if (num_ejec == 5) {
-		if (objeto_que_lleva == LOOK) {
+		if (pickedObject == kVerbLook) {
 			talk(_text[_lang][mirar_t[c_mirar]], mirar_v[c_mirar]);
 			c_mirar++;
 			if (c_mirar == 3)
 				c_mirar = 0;
-		} else if (objeto_que_lleva == MOVE)
-			talk(_text[_lang][19], "19.als");
-		else if (objeto_que_lleva == PICK) {
+		} else if (pickedObject == kVerbPick) {
 			talk(_text[_lang][poder_t[c_poder]], poder_v[c_poder]);
 			c_poder++;
 			if (c_poder == 6)
 				c_poder = 0;
-		} else if (objeto_que_lleva == OPEN)
-			talk(_text[_lang][9], "9.als");
-		else if (objeto_que_lleva == CLOSE)
-			talk(_text[_lang][9], "9.als");
-		else if (objeto_que_lleva == TALK)
-			talk(_text[_lang][16], "16.als");
-		else {
+		} else {
 			talk(_text[_lang][poder_t[c_poder]], poder_v[c_poder]);
 			c_poder++;
 			if (c_poder == 6)
 				c_poder = 0;
 		}
 	} else if (num_ejec == 6) {
-		if (objeto_que_lleva == LOOK) {
+		if (pickedObject == kVerbLook) {
 			talk(_text[_lang][mirar_t[c_mirar]], mirar_v[c_mirar]);
 			c_mirar++;
 			if (c_mirar == 3)
 				c_mirar = 0;
-		} else if (objeto_que_lleva == MOVE)
-			talk(_text[_lang][19], "19.als");
-		else if (objeto_que_lleva == PICK) {
+		} else if (pickedObject == kVerbPick) {
 			talk(_text[_lang][poder_t[c_poder]], poder_v[c_poder]);
 			c_poder++;
 			if (c_poder == 6)
 				c_poder = 0;
-		} else if (objeto_que_lleva == OPEN)
-			talk(_text[_lang][9], "9.als");
-		else if (objeto_que_lleva == CLOSE)
-			talk(_text[_lang][9], "9.als");
-		else if (objeto_que_lleva == TALK)
-			talk(_text[_lang][16], "16.als");
-		else {
+		} else {
 			talk(_text[_lang][poder_t[c_poder]], poder_v[c_poder]);
 			c_poder++;
 			if (c_poder == 6)
@@ -167,97 +287,37 @@ void DrasculaEngine::room_0() {
 }
 
 void DrasculaEngine::room_1(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 118) {
-		talk(_text[_lang][1], "1.als");
+	if (roomParse(room1Actions, fl))
+		return;
+
+	if (pickedObject == kVerbLook && fl == 118) {
+		talk(1);
 		pause(10);
-		talk(_text[_lang][2], "2.als");
-	} else if (objeto_que_lleva == PICK && fl == 118)
-		talk(_text[_lang][5], "5.als");
-	else if (objeto_que_lleva == OPEN && fl == 118)
-		talk(_text[_lang][3], "3.als");
-	else if (objeto_que_lleva == CLOSE && fl == 118)
-		talk(_text[_lang][4], "4.als");
-	else if (objeto_que_lleva == TALK && fl == 118)
-		talk(_text[_lang][6], "6.als");
-	else if (objeto_que_lleva == LOOK && fl == 119)
-		talk(_text[_lang][8], "8.als");
-	else if (objeto_que_lleva == MOVE && fl == 119)
-		talk(_text[_lang][13], "13.als");
-	else if (objeto_que_lleva == CLOSE && fl == 119)
-		talk(_text[_lang][10], "10.als");
-	else if (objeto_que_lleva == TALK && fl == 119)
-		talk(_text[_lang][12], "12.als");
-	else if (objeto_que_lleva == LOOK && fl == 120 && flags[8] == 0)
-		talk(_text[_lang][14], "14.als");
-	else if (objeto_que_lleva == MOVE && fl == 120)
-		talk(_text[_lang][13], "13.als");
-	else if (objeto_que_lleva == OPEN && fl == 120)
-		talk(_text[_lang][18], "18.als");
-	else if (objeto_que_lleva == TALK && fl == 120)
-		talk(_text[_lang][15], "15.als");
+		talk(2);
+	} else if (pickedObject == kVerbLook && fl == 120 && flags[8] == 0)
+		talk(14);
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_3(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 129)
-		talk(_text[_lang][21], "21.als");
-	else if (objeto_que_lleva == PICK && fl == 129)
-		talk(_text[_lang][5], "5.als");
-	else if (objeto_que_lleva == MOVE && fl == 129)
-		talk(_text[_lang][24], "24.als");
-	else if (objeto_que_lleva == OPEN && fl == 129)
-		talk(_text[_lang][22], "22.als");
-	else if (objeto_que_lleva == CLOSE && fl == 129)
-		talk(_text[_lang][10], "10.als");
-	else if (objeto_que_lleva == TALK && fl == 129) {
-		talk(_text[_lang][23], "23.als");
+	if (roomParse(room3Actions, fl))
+		return;
+
+	if (pickedObject == kVerbTalk && fl == 129) {
+		talk(23);
 		pause(6);
 		talk_sinc(_text[_lang][50], "50.als", "11111111111144432554433");
-	} else if (objeto_que_lleva == LOOK && fl == 131)
-		talk(_text[_lang][27], "27.als");
-	else if (objeto_que_lleva == PICK && fl == 131)
-		talk(_text[_lang][5], "5.als");
-	else if (objeto_que_lleva == MOVE && fl == 131)
-		talk(_text[_lang][24], "24.als");
-	else if (objeto_que_lleva == OPEN && fl == 131)
-		talk(_text[_lang][22], "22.als");
-	else if (objeto_que_lleva == CLOSE && fl == 131)
-		talk(_text[_lang][10], "10.als");
-	else if (objeto_que_lleva == TALK && fl == 131)
-		talk(_text[_lang][23], "23.als");
-	else if (objeto_que_lleva == LOOK && fl == 132)
-		talk(_text[_lang][28], "28.als");
-	else if (objeto_que_lleva == PICK && fl == 132)
-		talk(_text[_lang][5], "5.als");
-	else if (objeto_que_lleva == MOVE && fl == 132)
-		talk(_text[_lang][24], "24.als");
-	else if (objeto_que_lleva == OPEN && fl == 132)
-		talk(_text[_lang][22], "22.als");
-	else if (objeto_que_lleva == CLOSE && fl == 132)
-		talk(_text[_lang][10], "10.als");
-	else if (objeto_que_lleva == TALK && fl == 132)
-		talk(_text[_lang][23], "23.als");
-	else if (objeto_que_lleva == LOOK && fl == 133)
-		talk(_text[_lang][321], "321.als");
-	else if (objeto_que_lleva == PICK && fl == 133)
-		talk(_text[_lang][31], "31.als");
-	else if (objeto_que_lleva == MOVE && fl == 133)
-		talk(_text[_lang][34], "34.als");
-	else if (objeto_que_lleva == OPEN && fl == 133)
-		talk(_text[_lang][30], "30.als");
-	else if (objeto_que_lleva == CLOSE && fl == 133)
-		talk(_text[_lang][10], "10.als");
-	else if (objeto_que_lleva == TALK && fl == 133) {
+	} else if (pickedObject == kVerbTalk && fl == 133) {
 		talk_sinc(_text[_lang][322], "322.als", "13333334125433333333");
 		updateRoom();
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 		pause(25);
-		talk(_text[_lang][33], "33.als");
-	} else if (objeto_que_lleva == LOOK && fl == 165) {
-		talk(_text[_lang][149], "149.als");
-		talk(_text[_lang][150], "150.als");
-	} else if (objeto_que_lleva == PICK && fl == 165) {
+		talk(33);
+	} else if (pickedObject == kVerbLook && fl == 165) {
+		talk(149);
+		talk(150);
+	} else if (pickedObject == kVerbPick && fl == 165) {
 		copyBackground(0, 0, 0,0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 		updateRefresh_pre();
 		copyRect(44, 1, hare_x, hare_y, 41, 70, dir_dibujo2, dir_zona_pantalla);
@@ -267,134 +327,92 @@ void DrasculaEngine::room_3(int fl) {
 		pickObject(10);
 		flags[3] = 1;
 		visible[8] = 0;
-	} else if (objeto_que_lleva == LOOK && fl == 166)
-		talk(_text[_lang][55], "55.als");
-	else if (objeto_que_lleva == PICK && fl == 166)
-		talk(_text[_lang][7], "7.als");
-	else if (objeto_que_lleva == 14 && fl == 166 && flags[37] == 0) {
+	} else if (pickedObject == 14 && fl == 166 && flags[37] == 0) {
 		animation_7_2();
 		pickObject(8);
-	} else if (objeto_que_lleva == 14 && fl == 166 && flags[37] == 1)
-		talk(_text[_lang][323], "323.als");
-	else if (objeto_que_lleva == LOOK && fl == 211)
-		talk(_text[_lang][184], "184.als");
-	else if (objeto_que_lleva == TALK && fl == 211) {
-		talk(_text[_lang][185], "185.als");
-		talk(_text[_lang][186], "186.als");
+	} else if (pickedObject == 14 && fl == 166 && flags[37] == 1)
+		talk(323);
+	else if (pickedObject == kVerbTalk && fl == 211) {
+		talk(185);
+		talk(186);
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_4(int fl) {
-	if (objeto_que_lleva == MOVE && fl == 189 && flags[34] == 0) {
-		talk(_text[_lang][327], "327.als");
+	if (roomParse(room4Actions, fl))
+		return;
+
+	if (pickedObject == kVerbMove && fl == 189 && flags[34] == 0) {
+		talk(327);
 		pickObject(13);
 		flags[34] = 1;
 		if (flags[7] == 1 && flags[26] == 1 && flags[34] == 1 && flags[35] == 1 && flags[37] == 1)
 			flags[38] = 1;
-	} else if (objeto_que_lleva == LOOK && fl == 189)
-		talk(_text[_lang][182], "182.als");
-	else if (objeto_que_lleva == LOOK && fl == 207)
-		talk(_text[_lang][175], "175.als");
-	else if (objeto_que_lleva == TALK && fl == 207)
-		talk(_text[_lang][176], "176.als");
-	else if (objeto_que_lleva == LOOK && fl == 208)
-		talk(_text[_lang][177], "177.als");
-	else if (objeto_que_lleva == LOOK && fl == 209)
-		talk(_text[_lang][179], "179.als");
-	else if (objeto_que_lleva == LOOK && fl == 210)
-		talk(_text[_lang][180], "180.als");
-	else if (objeto_que_lleva == OPEN && fl == 210)
-		talk(_text[_lang][181], "181.als");
-	else
-		hay_respuesta = 0;
+	} else
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_5(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 136 && flags[8]==0) talk(_text[_lang][14], "14.als");
-	else if (objeto_que_lleva == MOVE && fl == 136)
-		talk(_text[_lang][13], "13.als");
-	else if (objeto_que_lleva == OPEN && fl == 136)
-		talk(_text[_lang][18], "18.als");
-	else if (objeto_que_lleva == TALK && fl == 136)
-		talk(_text[_lang][15], "15.als");
-	else if (objeto_que_lleva == 10 && fl == 136) {
+	if (roomParse(room5Actions, fl))
+		return;
+
+	if (pickedObject == kVerbLook && fl == 136 && flags[8] == 0) 
+		talk(14);
+	else if (pickedObject == 10 && fl == 136) {
 		animation_5_2();
 		resta_objeto(10);
-	} else if (objeto_que_lleva == LOOK && fl == 212)
-		talk(_text[_lang][187], "187.als");
-	else if (objeto_que_lleva == TALK && fl == 212)
-		talk(_text[_lang][188], "188.als");
-	else if (objeto_que_lleva == LOOK && fl == 213)
-		talk(_text[_lang][189], "189.als");
-	else if (objeto_que_lleva == OPEN && fl == 213)
-		talk(_text[_lang][190], "190.als");
-	else
-		hay_respuesta = 0;
+	} else
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_6(int fl){
-	if (objeto_que_lleva == LOOK && fl==144) {
-		talk(_text[_lang][41], "41.als");
-		talk(_text[_lang][42], "42.als");
-	} else if (objeto_que_lleva == PICK && fl == 144)
-		talk(_text[_lang][43], "43.als");
-	else if (objeto_que_lleva == LOOK && fl == 138)
-		talk(_text[_lang][35], "35.als");
-	else if (objeto_que_lleva == OPEN && fl == 138)
+	if (roomParse(room6Actions, fl))
+		return;
+
+	if (pickedObject == kVerbLook && fl==144) {
+		talk(41);
+		talk(42);
+	} else if (pickedObject == kVerbOpen && fl == 138)
 		openDoor(0, 1);
-	else if (objeto_que_lleva == CLOSE && fl == 138)
-		cierra_puerta(0, 1);
-	else if (objeto_que_lleva == TALK && fl == 138)
-		talk(_text[_lang][6], "6.als");
-	else if (objeto_que_lleva == LOOK && fl == 143)
-		talk(_text[_lang][37], "37.als");
-	else if (objeto_que_lleva == PICK && fl == 143)
-		talk(_text[_lang][7], "7.als");
-	else if (objeto_que_lleva == MOVE && fl == 143)
-		talk(_text[_lang][7], "7.als");
-	else if (objeto_que_lleva == OPEN && fl == 143 && flags[2] == 0) {
+	else if (pickedObject == kVerbClose && fl == 138)
+		closeDoor(0, 1);
+	else if (pickedObject == kVerbOpen && fl == 143 && flags[2] == 0) {
 		copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
-	updateRefresh_pre();
-	copyRect(228, 102, hare_x + 5, hare_y - 1, 47, 73, dir_dibujo3, dir_zona_pantalla);
-	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-	pause(10);
-	comienza_sound("s3.als");
-	flags[2] = 1;
-	updateRoom();
-	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-	fin_sound();
-	} else if (objeto_que_lleva == CLOSE && fl == 143 && flags[2] == 1) {
+		updateRefresh_pre();
+		copyRect(228, 102, hare_x + 5, hare_y - 1, 47, 73, dir_dibujo3, dir_zona_pantalla);
+		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
+		pause(10);
+		playSound("s3.als");
+		flags[2] = 1;
+		updateRoom();
+		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
+		stopSound();
+	} else if (pickedObject == kVerbClose && fl == 143 && flags[2] == 1) {
 		copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 		flags[2] = 0;
 		updateRefresh_pre();
 		copyRect(228, 102, hare_x + 5, hare_y - 1, 47, 73, dir_dibujo3, dir_zona_pantalla);
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 		pause(5);
-		comienza_sound("s4.als");
+		playSound("s4.als");
 		updateRoom();
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-		fin_sound();
-	} else if (objeto_que_lleva == TALK && fl == 143)
-		talk(_text[_lang][38], "38.als");
-	else if (objeto_que_lleva == LOOK && fl == 139)
-		talk(_text[_lang][36], "36.als");
-	else if (objeto_que_lleva == OPEN && fl == 139 && flags[1] == 0) {
+		stopSound();
+	} else if (pickedObject == kVerbOpen && fl == 139 && flags[1] == 0) {
 		copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 		updateRefresh_pre();
 		copyRect(267, 1, hare_x - 14, hare_y - 2, 52, 73, dir_dibujo3, dir_zona_pantalla);
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 		pause(19);
-		comienza_sound("s3.als");
+		playSound("s3.als");
 		flags[1] = 1;
 		visible[4] = 1;
 		visible[2] = 0;
 		updateRoom();
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-		fin_sound();
-	} else if (objeto_que_lleva == LOOK && fl == 140)
-		talk(_text[_lang][147], "147.als");
-	else if (objeto_que_lleva == PICK && fl == 140) {
+		stopSound();
+	} else if (pickedObject == kVerbPick && fl == 140) {
 		copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 		updateRefresh_pre();
 		copyRect(267, 1, hare_x - 14, hare_y - 2, 52, 73, dir_dibujo3, dir_zona_pantalla);
@@ -403,192 +421,181 @@ void DrasculaEngine::room_6(int fl){
 		pickObject(9);
 		visible[4] = 0;
 		flags[10] = 1;
-	} else if (objeto_que_lleva == OPEN && fl == 140)
-		hay_respuesta = 1;
+	} else if (pickedObject == kVerbOpen && fl == 140)
+		hay_answer = 1;
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_7(int fl){
-	if (objeto_que_lleva == LOOK && fl == 169)
-		talk(_text[_lang][44], "44.als");
-	else if (objeto_que_lleva == LOOK && fl == 164)
-		talk(_text[_lang][35], "35.als" );
-	else if (objeto_que_lleva == PICK && fl == 190) {
+	if (pickedObject == kVerbLook && fl == 169)
+		talk(44);
+	else if (pickedObject == kVerbLook && fl == 164)
+		talk(35);
+	else if (pickedObject == kVerbPick && fl == 190) {
 		pickObject(17);
 		flags[35] = 1;
 		visible[3] = 0;
 		if (flags[7] == 1 && flags[26] == 1 && flags[34] == 1 && flags[35] == 1 && flags[37] == 1)
 			flags[38] = 1;
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_8(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 147 && flags[7] == 0) {
-		talk(_text[_lang][58], "58.als");
+	if (pickedObject == kVerbLook && fl == 147 && flags[7] == 0) {
+		talk(58);
 		pickObject(15);
 		flags[7] = 1;
 		if (flags[7] == 1 && flags[26] == 1 && flags[34] == 1 && flags[35] == 1 && flags[37] == 1)
 			flags[38] = 1;
-	} else if (objeto_que_lleva == LOOK && fl == 147)
-		talk(_text[_lang][59], "59.als");
+	} else if (pickedObject == kVerbLook && fl == 147)
+		talk(59);
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_9(int fl){
-	if (objeto_que_lleva == LOOK && fl == 150)
-		talk(_text[_lang][35], "35.als");
-	else if (objeto_que_lleva == TALK && fl == 150)
-		talk(_text[_lang][6], "6.als");
-	else if (objeto_que_lleva == LOOK && fl == 51)
-		talk(_text[_lang][60], "60.als");
-	else if (objeto_que_lleva == TALK && fl == 51 && flags[4] == 0)
+	if (pickedObject == kVerbLook && fl == 150)
+		talk(35);
+	else if (pickedObject == kVerbTalk && fl == 150)
+		talk(6);
+	else if (pickedObject == kVerbLook && fl == 51)
+		talk(60);
+	else if (pickedObject == kVerbTalk && fl == 51 && flags[4] == 0)
 		animation_4_2();
-	else if (objeto_que_lleva == TALK && fl == 51 && flags[4] == 1)
+	else if (pickedObject == kVerbTalk && fl == 51 && flags[4] == 1)
 		animation_33_2();
-	else if (objeto_que_lleva == 7 && fl == 51) {
+	else if (pickedObject == 7 && fl == 51) {
 		animation_6_2();
 		resta_objeto(7);
 		pickObject(14);}
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_12(int fl){
-	if (objeto_que_lleva == LOOK && fl == 154)
-		talk(_text[_lang][329], "329.als");
-	else if (objeto_que_lleva == TALK && fl == 154)
-		talk(_text[_lang][330], "330.als");
-	else if (objeto_que_lleva == MOVE && fl == 155)
-		talk(_text[_lang][48], "48.als");
-	else if (objeto_que_lleva == TALK && fl == 155)
-		talk(_text[_lang][331], "331.als");
-	else if (objeto_que_lleva == LOOK && fl == 156)
-		talk(_text[_lang][35], "35.als");
-	else if (objeto_que_lleva == MOVE && fl == 156)
-		talk(_text[_lang][48], "48.als");
-	else if (objeto_que_lleva == TALK && fl == 156)
-		talk(_text[_lang][50], "50.als");
-	else if (objeto_que_lleva == OPEN && fl == 156)
+	if (roomParse(room12Actions, fl))
+		return;
+
+	if (pickedObject == kVerbOpen && fl == 156)
 		openDoor(16, 4);
-	else if (objeto_que_lleva == CLOSE && fl == 156)
-		cierra_puerta(16, 4);
+	else if (pickedObject == kVerbClose && fl == 156)
+		closeDoor(16, 4);
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 bool DrasculaEngine::room_13(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 51) {
-		talk(_text[_lang][411], "411.als");
+	if (pickedObject == kVerbLook && fl == 51) {
+		talk(411);
 		sentido_hare = 3;
-		talk(_text[_lang][412], "412.als");
+		talk(412);
 		strcpy(objName[1], "yoda");
-	} else if (objeto_que_lleva == TALK && fl == 51)
+	} else if (pickedObject == kVerbTalk && fl == 51)
 		conversa("op_7.cal");
-	else if (objeto_que_lleva == 19 && fl == 51)
+	else if (pickedObject == 19 && fl == 51)
 		animation_1_3();
-	else if (objeto_que_lleva == 9 && fl == 51) {
+	else if (pickedObject == 9 && fl == 51) {
 		animation_2_3();
 		return true;
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 	return false;
 }
 
 void DrasculaEngine::room_14(int fl) {
-	if (objeto_que_lleva == TALK && fl == 54 && flags[39] == 0)
+	if (pickedObject == kVerbTalk && fl == 54 && flags[39] == 0)
 		animation_12_2();
-	else if (objeto_que_lleva == TALK && fl == 54 && flags[39] == 1)
-		talk(_text[_lang][109], "109.als");
-	else if (objeto_que_lleva == 12 && fl == 54)
+	else if (pickedObject == kVerbTalk && fl == 54 && flags[39] == 1)
+		talk(109);
+	else if (pickedObject == 12 && fl == 54)
 		animation_26_2();
-	else if (objeto_que_lleva == TALK && fl == 52 && flags[5] == 0)
+	else if (pickedObject == kVerbTalk && fl == 52 && flags[5] == 0)
 		animation_11_2();
-	else if (objeto_que_lleva == TALK && fl == 52 && flags[5] == 1)
+	else if (pickedObject == kVerbTalk && fl == 52 && flags[5] == 1)
 		animation_36_2();
-	else if (objeto_que_lleva == TALK && fl == 53)
+	else if (pickedObject == kVerbTalk && fl == 53)
 		animation_13_2();
-	else if (objeto_que_lleva == LOOK && fl == 200)
-		talk(_text[_lang][165], "165.als");
-	else if (objeto_que_lleva == LOOK && fl == 201)
-		talk(_text[_lang][166], "166.als");
-	else if (objeto_que_lleva == LOOK && fl == 202)
-		talk(_text[_lang][167], "167.als");
-	else if (objeto_que_lleva == LOOK && fl == 203)
-		talk(_text[_lang][168], "168.als");
-	else if (objeto_que_lleva == PICK && fl == 203)
-		talk(_text[_lang][170], "170.als");
-	else if (objeto_que_lleva == MOVE && fl == 203)
-		talk(_text[_lang][170], "170.als");
-	else if (objeto_que_lleva == TALK && fl == 203)
-		talk(_text[_lang][169], "169.als");
-	else if (objeto_que_lleva == LOOK && fl == 204)
-		talk(_text[_lang][171], "171.als");
+	else if (pickedObject == kVerbLook && fl == 200)
+		talk(165);
+	else if (pickedObject == kVerbLook && fl == 201)
+		talk(166);
+	else if (pickedObject == kVerbLook && fl == 202)
+		talk(167);
+	else if (pickedObject == kVerbLook && fl == 203)
+		talk(168);
+	else if (pickedObject == kVerbPick && fl == 203)
+		talk(170);
+	else if (pickedObject == kVerbMove && fl == 203)
+		talk(170);
+	else if (pickedObject == kVerbTalk && fl == 203)
+		talk(169);
+	else if (pickedObject == kVerbLook && fl == 204)
+		talk(171);
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_15(int fl) {
-	if (objeto_que_lleva == TALK && fl == 188)
-		talk(_text[_lang][333], "333.als");
-	else if (objeto_que_lleva == LOOK && fl == 188)
-		talk(_text[_lang][334], "334.als");
-	else if (objeto_que_lleva == 19 && fl == 188 && flags[27] == 0)
-		talk(_text[_lang][335], "335.als");
-	else if (objeto_que_lleva == 19 && fl == 188 && flags[27] == 1) {
-		talk(_text[_lang][336], "336.als");
+	if (pickedObject == kVerbTalk && fl == 188)
+		talk(333);
+	else if (pickedObject == kVerbLook && fl == 188)
+		talk(334);
+	else if (pickedObject == 19 && fl == 188 && flags[27] == 0)
+		talk(335);
+	else if (pickedObject == 19 && fl == 188 && flags[27] == 1) {
+		talk(336);
 		sentido_hare = 3;
-		talk(_text[_lang][337], "337.als");
+		talk(337);
 		talk_sinc(_text[_lang][46], "46.als", "4442444244244");
 		sentido_hare = 1;
-	} else if (objeto_que_lleva == 18 && fl == 188 && flags[26] == 0) {
+	} else if (pickedObject == 18 && fl == 188 && flags[26] == 0) {
 		copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 		copyRect(133, 135, hare_x + 6, hare_y, 39, 63, dir_dibujo3, dir_zona_pantalla);
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
-		comienza_sound("s8.als");
-		fin_sound();
+		playSound("s8.als");
+		stopSound();
 		talk(_text[_lang][338], "338.als");
 		flags[27] = 0;
 		pickObject(19);
 		resta_objeto(18);
-	} else if (objeto_que_lleva == MOVE && fl == 188 && flags[27] == 0) {
+	} else if (pickedObject == kVerbMove && fl == 188 && flags[27] == 0) {
 		animation_34_2();
-		talk(_text[_lang][339], "339.als");
+		talk(339);
 		pickObject(16);
 		flags[26] = 1;
 		flags[27] = 1;
 		if (flags[7] == 1 && flags[26] == 1 && flags[34] == 1 && flags[35] == 1 && flags[37] == 1)
 			flags[38] = 1;
-	} else if (objeto_que_lleva == LOOK && fl == 205)
-		talk(_text[_lang][172], "172.als");
-	else if (objeto_que_lleva == LOOK && fl == 206)
-		talk(_text[_lang][173], "173.als");
-	else if (objeto_que_lleva == MOVE && fl == 206)
-		talk(_text[_lang][174], "174.als");
-	else if (objeto_que_lleva == OPEN && fl == 206)
-		talk(_text[_lang][174], "174.als");
+	} else if (pickedObject == kVerbLook && fl == 205)
+		talk(172);
+	else if (pickedObject == kVerbLook && fl == 206)
+		talk(173);
+	else if (pickedObject == kVerbMove && fl == 206)
+		talk(174);
+	else if (pickedObject == kVerbOpen && fl == 206)
+		talk(174);
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_16(int fl) {
-	if (objeto_que_lleva == TALK && fl == 163)
+	if (pickedObject == kVerbTalk && fl == 163)
 		talk(_text[_lang][6], "6.als");
-	else if (objeto_que_lleva == OPEN && fl == 163)
+	else if (pickedObject == kVerbOpen && fl == 163)
 		openDoor(17, 0);
-	else if (objeto_que_lleva == CLOSE && fl == 163)
-		cierra_puerta(17, 0);
-	else if (objeto_que_lleva == LOOK && fl == 183)
+	else if (pickedObject == kVerbClose && fl == 163)
+		closeDoor(17, 0);
+	else if (pickedObject == kVerbLook && fl == 183)
 		talk(_text[_lang][340], "340.als");
-	else if (objeto_que_lleva == TALK && fl == 183) {
+	else if (pickedObject == kVerbTalk && fl == 183) {
 		talk(_text[_lang][341], "341.als");
 		pause(10);
 		talk_sinc(_text[_lang][50], "50.als", "11111111111144432554433");
 		pause(3);
 		talk_baul(_text[_lang][83], "d83.als");
-	} else if (objeto_que_lleva == OPEN && fl == 183) {
+	} else if (pickedObject == kVerbOpen && fl == 183) {
 		openDoor(19, NO_DOOR);
 		if (flags[20] == 0) {
 			flags[20] = 1;
@@ -598,60 +605,60 @@ void DrasculaEngine::room_16(int fl) {
 			talk(_text[_lang][342], "342.als");
 			pickObject(22);
 		}
-	} else if (objeto_que_lleva == CLOSE && fl == 183)
-		cierra_puerta(19, NO_DOOR);
-	else if (objeto_que_lleva == LOOK && fl == 185)
+	} else if (pickedObject == kVerbClose && fl == 183)
+		closeDoor(19, NO_DOOR);
+	else if (pickedObject == kVerbLook && fl == 185)
 		talk(_text[_lang][37], "37.als");
-	else if (objeto_que_lleva == PICK && fl == 185)
+	else if (pickedObject == kVerbPick && fl == 185)
 		talk(_text[_lang][7], "7.als");
-	else if (objeto_que_lleva == MOVE && fl == 185)
+	else if (pickedObject == kVerbMove && fl == 185)
 		talk(_text[_lang][7], "7.als");
-	else if (objeto_que_lleva == TALK && fl == 185)
+	else if (pickedObject == kVerbTalk && fl == 185)
 		talk(_text[_lang][38], "38.als");
-	else if (objeto_que_lleva == LOOK && fl == 187) {
+	else if (pickedObject == kVerbLook && fl == 187) {
 		talk(_text[_lang][343], "343.als");
 		sentido_hare = 3;
 		updateRoom();
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 		talk(_text[_lang][344], "344.als");
-	} else if (objeto_que_lleva == TALK && fl == 187)
+	} else if (pickedObject == kVerbTalk && fl == 187)
 		talk(_text[_lang][345], "345.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_17(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 177)
+	if (pickedObject == kVerbLook && fl == 177)
 		talk(_text[_lang][35], "35.als");
-	else if (objeto_que_lleva == TALK && fl == 177 && flags[18] == 0)
+	else if (pickedObject == kVerbTalk && fl == 177 && flags[18] == 0)
 		talk(_text[_lang][6], "6.als");
-	else if (objeto_que_lleva == TALK && fl == 177 && flags[18] == 1)
+	else if (pickedObject == kVerbTalk && fl == 177 && flags[18] == 1)
 		animation_18_2();
-	else if (objeto_que_lleva == OPEN && fl == 177 && flags[18] == 1)
+	else if (pickedObject == kVerbOpen && fl == 177 && flags[18] == 1)
 		talk(_text[_lang][346], "346.als");
-	else if (objeto_que_lleva == OPEN && fl == 177 && flags[14] == 0 && flags[18] == 0)
+	else if (pickedObject == kVerbOpen && fl == 177 && flags[14] == 0 && flags[18] == 0)
 		animation_22_2();
-	else if (objeto_que_lleva == OPEN && fl == 177 && flags[14] == 1)
+	else if (pickedObject == kVerbOpen && fl == 177 && flags[14] == 1)
 		openDoor(15, 1);
-	else if (objeto_que_lleva == CLOSE && fl == 177 && flags[14] == 1)
-		cierra_puerta(15, 1);
-	else if (objeto_que_lleva == 11 && fl == 50 && flags[22] == 0) {
+	else if (pickedObject == kVerbClose && fl == 177 && flags[14] == 1)
+		closeDoor(15, 1);
+	else if (pickedObject == 11 && fl == 50 && flags[22] == 0) {
 		talk(_text[_lang][347], "347.als");
 		flags[29] = 1;
 		pickObject(23);
 		resta_objeto(11);
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_18(int fl) {
-	if (objeto_que_lleva == TALK && fl == 55 && flags[36] == 0)
+	if (pickedObject == kVerbTalk && fl == 55 && flags[36] == 0)
 		animation_24_2();
-	else if (objeto_que_lleva == TALK && fl == 55 && flags[36] == 1)
+	else if (pickedObject == kVerbTalk && fl == 55 && flags[36] == 1)
 		talk(_text[_lang][109], "109.als");
-	else if (objeto_que_lleva == LOOK && fl == 181)
+	else if (pickedObject == kVerbLook && fl == 181)
 		talk(_text[_lang][348], "348.als");
-	else if (objeto_que_lleva == PICK && fl == 182) {
+	else if (pickedObject == kVerbPick && fl == 182) {
 		copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 		updateRefresh_pre();
 		copyRect(44, 1, hare_x, hare_y, 41, 70, dir_dibujo2, dir_zona_pantalla);
@@ -661,29 +668,29 @@ void DrasculaEngine::room_18(int fl) {
 		pickObject(12);
 		visible[2] = 0;
 		flags[28] = 1;
-	} else if (objeto_que_lleva == LOOK && fl == 182)
+	} else if (pickedObject == kVerbLook && fl == 182)
 		talk(_text[_lang][154], "154.als");
-	else if (objeto_que_lleva == 8 && fl == 55 && flags[38] == 0 && flags[33] == 1)
+	else if (pickedObject == 8 && fl == 55 && flags[38] == 0 && flags[33] == 1)
 		talk(_text[_lang][349], "349.als");
-	else if (objeto_que_lleva == 13 && fl == 55 && flags[38] == 0 && flags[33] == 1)
+	else if (pickedObject == 13 && fl == 55 && flags[38] == 0 && flags[33] == 1)
 		talk(_text[_lang][349], "349.als");
-	else if (objeto_que_lleva == 15 && fl == 55 && flags[38] == 0 && flags[33] == 1)
+	else if (pickedObject == 15 && fl == 55 && flags[38] == 0 && flags[33] == 1)
 		talk(_text[_lang][349], "349.als");
-	else if (objeto_que_lleva == 16 && fl == 55 && flags[38] == 0 && flags[33] == 1)
+	else if (pickedObject == 16 && fl == 55 && flags[38] == 0 && flags[33] == 1)
 		talk(_text[_lang][349], "349.als");
-	else if (objeto_que_lleva == 17 && fl == 55 && flags[38] == 0 && flags[33] == 1)
+	else if (pickedObject == 17 && fl == 55 && flags[38] == 0 && flags[33] == 1)
 		talk(_text[_lang][349], "349.als");
-	else if (objeto_que_lleva == 8 && fl == 55 && flags[38] == 1 && flags[33] == 1)
+	else if (pickedObject == 8 && fl == 55 && flags[38] == 1 && flags[33] == 1)
 		animation_24_2();
-	else if (objeto_que_lleva == 13 && fl == 55 && flags[38] == 1 && flags[33] == 1)
+	else if (pickedObject == 13 && fl == 55 && flags[38] == 1 && flags[33] == 1)
 		animation_24_2();
-	else if (objeto_que_lleva == 15 && fl == 55 && flags[38] == 1 && flags[33] == 1)
+	else if (pickedObject == 15 && fl == 55 && flags[38] == 1 && flags[33] == 1)
 		animation_24_2();
-	else if (objeto_que_lleva == 16 && fl == 55 && flags[38] == 1 && flags[33] == 1)
+	else if (pickedObject == 16 && fl == 55 && flags[38] == 1 && flags[33] == 1)
 		animation_24_2();
-	else if (objeto_que_lleva == 17 && fl == 55 && flags[38] == 1 && flags[33] == 1)
+	else if (pickedObject == 17 && fl == 55 && flags[38] == 1 && flags[33] == 1)
 		animation_24_2();
-	else if (objeto_que_lleva == 11 && fl == 50 && flags[22] == 0) {
+	else if (pickedObject == 11 && fl == 50 && flags[22] == 0) {
 		sentido_hare = 3;
 		updateRoom();
 		updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
@@ -698,85 +705,85 @@ void DrasculaEngine::room_18(int fl) {
 		pickObject(23);
 		resta_objeto(11);
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_19(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 214)
+	if (pickedObject == kVerbLook && fl == 214)
 		talk(_text[_lang][191], "191.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 bool DrasculaEngine::room_21(int fl) {
-	if (objeto_que_lleva == OPEN && fl == 101 && flags[28] == 0)
+	if (pickedObject == kVerbOpen && fl == 101 && flags[28] == 0)
 		talk(_text[_lang][419], "419.als");
-	else if (objeto_que_lleva == OPEN && fl == 101 && flags[28] == 1)
+	else if (pickedObject == kVerbOpen && fl == 101 && flags[28] == 1)
 		openDoor(0, 1);
-	else if (objeto_que_lleva == CLOSE && fl == 101)
-		cierra_puerta(0, 1);
-	else if(objeto_que_lleva == PICK && fl == 141) {
+	else if (pickedObject == kVerbClose && fl == 101)
+		closeDoor(0, 1);
+	else if(pickedObject == kVerbPick && fl == 141) {
 		pickObject(19);
 		visible[2] = 0;
 		flags[10] = 1;
-	} else if(objeto_que_lleva == 7 && fl == 101) {
+	} else if(pickedObject == 7 && fl == 101) {
 		flags[28] = 1;
 		openDoor(0, 1);
 		withoutVerb();
-	} else if (objeto_que_lleva == 21 && fl == 179) {
+	} else if (pickedObject == 21 && fl == 179) {
 		animation_9_4();
 		return true;
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 
 	return false;
 }
 
 void DrasculaEngine::room_22(int fl) {
-	if (objeto_que_lleva == PICK && fl == 140)
+	if (pickedObject == kVerbPick && fl == 140)
 		talk(_text[_lang][7], "7.als");
-	else if (objeto_que_lleva == 11 && fl == 140) {
+	else if (pickedObject == 11 && fl == 140) {
 		pickObject(18);
 		visible[1] = 0;
 		flags[24] = 1;
-	} else if (objeto_que_lleva == 22 && fl == 52) {
+	} else if (pickedObject == 22 && fl == 52) {
 		anima("up.bin",14);
 		flags[26]=1;
-		comienza_sound("s1.als");
+		playSound("s1.als");
 		hipo(14);
-		fin_sound();
+		stopSound();
 		withoutVerb();
 		resta_objeto(22);
 		updateData();
 		sentido_hare = 3;
 		talk(_text[_lang][499], "499.als");
 		talk(_text[_lang][500], "500.als");
-	} else if (objeto_que_lleva == LOOK && fl == 52)
+	} else if (pickedObject == kVerbLook && fl == 52)
 		talk(_text[_lang][497], "497.als");
-	else if (objeto_que_lleva == TALK && fl == 52)
+	else if (pickedObject == kVerbTalk && fl == 52)
 		talk(_text[_lang][498], "498.als");
-	else if (objeto_que_lleva == PICK && fl == 180 && flags[26] == 0)
+	else if (pickedObject == kVerbPick && fl == 180 && flags[26] == 0)
 		talk(_text[_lang][420], "420.als");
-	else if (objeto_que_lleva == PICK && fl == 180 && flags[26] == 1) {
+	else if (pickedObject == kVerbPick && fl == 180 && flags[26] == 1) {
 		pickObject(7);
 		visible[3] = 0;
 		flags[27] = 1;
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_23(int fl) {
-	if (objeto_que_lleva == OPEN && fl == 103) {
+	if (pickedObject == kVerbOpen && fl == 103) {
 		openDoor(0, 0);
 		updateData();
-	} else if(objeto_que_lleva == CLOSE && fl == 103) {
-		cierra_puerta(0, 0);
+	} else if(pickedObject == kVerbClose && fl == 103) {
+		closeDoor(0, 0);
 		updateData();
-	} else if(objeto_que_lleva == OPEN && fl == 104)
+	} else if(pickedObject == kVerbOpen && fl == 104)
 		openDoor(1, 1);
-	else if(objeto_que_lleva == CLOSE && fl == 104)
-		cierra_puerta(1, 1);
-	else if(objeto_que_lleva == PICK && fl == 142) {
+	else if(pickedObject == kVerbClose && fl == 104)
+		closeDoor(1, 1);
+	else if(pickedObject == kVerbPick && fl == 142) {
 		pickObject(8);
 		visible[2] = 0;
 		flags[11] = 1;
@@ -785,129 +792,129 @@ void DrasculaEngine::room_23(int fl) {
 		if (flags[18] == 1)
 			animation_6_4();
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_24(int fl) {
-	if (objeto_que_lleva == OPEN && fl == 105)
+	if (pickedObject == kVerbOpen && fl == 105)
 		openDoor(1, 0);
-	else if (objeto_que_lleva == CLOSE && fl == 105)
-		cierra_puerta(1, 0);
-	else if (objeto_que_lleva == OPEN && fl == 106)
+	else if (pickedObject == kVerbClose && fl == 105)
+		closeDoor(1, 0);
+	else if (pickedObject == kVerbOpen && fl == 106)
 		openDoor(2, 1);
-	else if (objeto_que_lleva == CLOSE && fl == 106)
-		cierra_puerta(2, 1);
-	else if (objeto_que_lleva == LOOK && fl == 151)
+	else if (pickedObject == kVerbClose && fl == 106)
+		closeDoor(2, 1);
+	else if (pickedObject == kVerbLook && fl == 151)
 		talk(_text[_lang][461], "461.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_26(int fl) {
-	if (objeto_que_lleva == OPEN && fl == 107 && flags[30] == 0)
+	if (pickedObject == kVerbOpen && fl == 107 && flags[30] == 0)
 		openDoor(2, 0);
-	else if (objeto_que_lleva == OPEN && fl == 107 && flags[30] == 1)
+	else if (pickedObject == kVerbOpen && fl == 107 && flags[30] == 1)
 		talk(_text[_lang][421], "421.als");
-	else if (objeto_que_lleva == CLOSE && fl == 107)
-		cierra_puerta(2, 0);
-	else if (objeto_que_lleva == 10 && fl == 50 && flags[18] == 1 && flags[12] == 1)
+	else if (pickedObject == kVerbClose && fl == 107)
+		closeDoor(2, 0);
+	else if (pickedObject == 10 && fl == 50 && flags[18] == 1 && flags[12] == 1)
 		animation_5_4();
-	else if (objeto_que_lleva == 8 && fl == 50 && flags[18] == 1 && flags[12] == 1)
+	else if (pickedObject == 8 && fl == 50 && flags[18] == 1 && flags[12] == 1)
 		animation_5_4();
-	else if (objeto_que_lleva == 12 && fl == 50 && flags[18] == 1 && flags[12] == 1)
+	else if (pickedObject == 12 && fl == 50 && flags[18] == 1 && flags[12] == 1)
 		animation_5_4();
-	else if (objeto_que_lleva == 16 && fl == 50 && flags[18] == 1 && flags[12] == 1)
+	else if (pickedObject == 16 && fl == 50 && flags[18] == 1 && flags[12] == 1)
 		animation_5_4();
-	else if (objeto_que_lleva == PICK && fl == 143 && flags[18] == 1) {
+	else if (pickedObject == kVerbPick && fl == 143 && flags[18] == 1) {
 		lleva_al_hare(260, 180);
 		pickObject(10);
 		visible[1] = 0;
 		flags[12] = 1;
-		cierra_puerta(2, 0);
+		closeDoor(2, 0);
 		sentido_hare = 2;
 		talk_igorpuerta(_texti[_lang][27], "I27.als");
 		flags[30] = 1;
 		talk_igorpuerta(_texti[_lang][28], "I28.als");
 		lleva_al_hare(153, 180);
-	} else if (objeto_que_lleva == PICK && fl == 143 && flags[18] == 0) {
+	} else if (pickedObject == kVerbPick && fl == 143 && flags[18] == 0) {
 		lleva_al_hare(260, 180);
 		copyBackground(80, 78, 199, 94, 38, 27, dir_dibujo3, dir_zona_pantalla);
 		updateScreen(199, 94, 199, 94, 38, 27, dir_zona_pantalla);
 		pause(3);
 		talk_igor_peluca(_texti[_lang][25], "I25.als");
 		lleva_al_hare(153, 180);
-	} else if (objeto_que_lleva == TALK && fl == 51)
+	} else if (pickedObject == kVerbTalk && fl == 51)
 		animation_1_4();
-	else if (objeto_que_lleva == OPEN && fl == 167)
+	else if (pickedObject == kVerbOpen && fl == 167)
 		talk(_text[_lang][467], "467.als");
-	else if (objeto_que_lleva == LOOK && fl == 164)
+	else if (pickedObject == kVerbLook && fl == 164)
 		talk(_text[_lang][470], "470.als");
-	else if (objeto_que_lleva == OPEN && fl == 164)
+	else if (pickedObject == kVerbOpen && fl == 164)
 		talk(_text[_lang][471], "471.als");
-	else if (objeto_que_lleva == LOOK && fl == 163)
+	else if (pickedObject == kVerbLook && fl == 163)
 		talk(_text[_lang][472], "472.als");
-	else if (objeto_que_lleva == PICK && fl == 163)
+	else if (pickedObject == kVerbPick && fl == 163)
 		talk(_text[_lang][473], "473.als");
-	else if (objeto_que_lleva == LOOK && fl == 165)
+	else if (pickedObject == kVerbLook && fl == 165)
 		talk(_text[_lang][474], "474.als");
-	else if (objeto_que_lleva == LOOK && fl == 168)
+	else if (pickedObject == kVerbLook && fl == 168)
 		talk(_text[_lang][476], "476.als");
-	else if (objeto_que_lleva == PICK && fl == 168)
+	else if (pickedObject == kVerbPick && fl == 168)
 		talk(_text[_lang][477], "477.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_27(int fl) {
-	if (objeto_que_lleva == OPEN && fl == 110)
+	if (pickedObject == kVerbOpen && fl == 110)
 		openDoor(6, 1);
-	else if (objeto_que_lleva == CLOSE && fl == 110)
-		cierra_puerta(6, 1);
-	else if (objeto_que_lleva == OPEN && fl == 116 && flags[23] == 0)
+	else if (pickedObject == kVerbClose && fl == 110)
+		closeDoor(6, 1);
+	else if (pickedObject == kVerbOpen && fl == 116 && flags[23] == 0)
 		talk(_text[_lang][419], "419.als");
-	else if (objeto_que_lleva == OPEN && fl == 116 && flags[23] == 1)
+	else if (pickedObject == kVerbOpen && fl == 116 && flags[23] == 1)
 		openDoor(5, 3);
-	else if (objeto_que_lleva == 17 && fl == 116) {
+	else if (pickedObject == 17 && fl == 116) {
 		flags[23] = 1;
 		openDoor(5,3);
 		withoutVerb();
-	} else if (objeto_que_lleva == LOOK && fl == 175)
+	} else if (pickedObject == kVerbLook && fl == 175)
 		talk(_text[_lang][429], "429.als");
 	else if (fl == 150)
 		talk(_text[_lang][460], "460.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_29(int fl) {
-	if (objeto_que_lleva == OPEN && fl == 114)
+	if (pickedObject == kVerbOpen && fl == 114)
 		openDoor(4, 1);
-	else if (objeto_que_lleva == CLOSE && fl == 114)
-		cierra_puerta(4, 1);
-	else if (objeto_que_lleva == LOOK && fl == 152)
+	else if (pickedObject == kVerbClose && fl == 114)
+		closeDoor(4, 1);
+	else if (pickedObject == kVerbLook && fl == 152)
 		talk(_text[_lang][463], "463.als");
-	else if (objeto_que_lleva == OPEN && fl == 152)
+	else if (pickedObject == kVerbOpen && fl == 152)
 		talk(_text[_lang][464], "464.als");
-	else if (objeto_que_lleva == LOOK && fl == 153)
+	else if (pickedObject == kVerbLook && fl == 153)
 		talk(_text[_lang][465], "465.als");
-	else if (objeto_que_lleva == PICK && fl == 154)
+	else if (pickedObject == kVerbPick && fl == 154)
 		talk(_text[_lang][466], "466.als");
-	else if (objeto_que_lleva == OPEN && fl == 156)
+	else if (pickedObject == kVerbOpen && fl == 156)
 		talk(_text[_lang][467], "467.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_30(int fl) {
-	if (objeto_que_lleva == OPEN && fl == 115)
+	if (pickedObject == kVerbOpen && fl == 115)
 		openDoor(4, 0);
-	else if (objeto_que_lleva == CLOSE && fl == 115)
-		cierra_puerta(4, 0);
-	else if (objeto_que_lleva == OPEN && fl == 144 && flags[19] == 0)
+	else if (pickedObject == kVerbClose && fl == 115)
+		closeDoor(4, 0);
+	else if (pickedObject == kVerbOpen && fl == 144 && flags[19] == 0)
 		talk(_text[_lang][422], "422.als");
-	else if (objeto_que_lleva == OPEN && fl == 144 && flags[19] == 1 && flags[22] == 1)
+	else if (pickedObject == kVerbOpen && fl == 144 && flags[19] == 1 && flags[22] == 1)
 		openDoor(16, 1);
-	else if (objeto_que_lleva == OPEN && fl == 144 && flags[19] == 1 && flags[22] == 0) {
+	else if (pickedObject == kVerbOpen && fl == 144 && flags[19] == 1 && flags[22] == 0) {
 		openDoor(16, 1);
 		talk(_text[_lang][423], "423.als");
 		flags[22] = 1;
@@ -916,59 +923,59 @@ void DrasculaEngine::room_30(int fl) {
 			flags[18] = 1;
 		if (flags[18] == 1)
 			animation_6_4();
-	} else if (objeto_que_lleva == CLOSE && fl == 144)
-		cierra_puerta(16, 1);
-	else if (objeto_que_lleva == 13 && fl == 144) {
+	} else if (pickedObject == kVerbClose && fl == 144)
+		closeDoor(16, 1);
+	else if (pickedObject == 13 && fl == 144) {
 		talk(_text[_lang][424], "424.als");
 		flags[19] = 1;
-	} else if (objeto_que_lleva == OPEN && fl == 157)
+	} else if (pickedObject == kVerbOpen && fl == 157)
 		talk(_text[_lang][468], "468.als");
-	else if (objeto_que_lleva == LOOK && fl == 158)
+	else if (pickedObject == kVerbLook && fl == 158)
 		talk(_text[_lang][469], "469.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_31(int fl) {
-	if (objeto_que_lleva == PICK && fl == 145) {
+	if (pickedObject == kVerbPick && fl == 145) {
 		pickObject(11);
 		visible[1] = 0;
 		flags[13] = 1;
-	} else if (objeto_que_lleva == OPEN && fl == 117)
+	} else if (pickedObject == kVerbOpen && fl == 117)
 		openDoor(5, 0);
-	else if (objeto_que_lleva == CLOSE && fl == 117)
-		cierra_puerta(5, 0);
-	else if (objeto_que_lleva == LOOK && fl == 161)
+	else if (pickedObject == kVerbClose && fl == 117)
+		closeDoor(5, 0);
+	else if (pickedObject == kVerbLook && fl == 161)
 		talk(_text[_lang][470], "470.als");
-	else if (objeto_que_lleva == OPEN && fl == 161)
+	else if (pickedObject == kVerbOpen && fl == 161)
 		talk(_text[_lang][471], "471.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_34(int fl) {
-	if (objeto_que_lleva == MOVE && fl == 146)
+	if (pickedObject == kVerbMove && fl == 146)
 		animation_8_4();
-	else if (objeto_que_lleva == LOOK && fl == 146)
+	else if (pickedObject == kVerbLook && fl == 146)
 		talk(_text[_lang][458], "458.als");
-	else if (objeto_que_lleva == PICK && fl == 146)
+	else if (pickedObject == kVerbPick && fl == 146)
 		talk(_text[_lang][459], "459.als");
-	else if (objeto_que_lleva == OPEN && fl == 120 && flags[25] == 1)
+	else if (pickedObject == kVerbOpen && fl == 120 && flags[25] == 1)
 		openDoor(8, 2);
-	else if (objeto_que_lleva == OPEN && fl == 120 && flags[25] == 0) {
+	else if (pickedObject == kVerbOpen && fl == 120 && flags[25] == 0) {
 		openDoor(8, 2);
 		sentido_hare = 3;
 		talk(_text[_lang][425], "425.als");
 		pickObject(14);
 		flags[25] = 1;
-	} else if (objeto_que_lleva == CLOSE && fl == 120)
-		cierra_puerta(8, 2);
+	} else if (pickedObject == kVerbClose && fl == 120)
+		closeDoor(8, 2);
 	else
-		hay_respuesta=0;
+		hay_answer=0;
 }
 
 void DrasculaEngine::room_35(int fl) {
-	if (objeto_que_lleva == PICK && fl == 148) {
+	if (pickedObject == kVerbPick && fl == 148) {
 		pickObject(16);
 		visible[2] = 0;
 		flags[14] = 1;
@@ -976,85 +983,85 @@ void DrasculaEngine::room_35(int fl) {
 		flags[18] = 1;
 	if (flags[18] == 1)
 		animation_6_4();
-	} else if (objeto_que_lleva == PICK && fl == 147) {
+	} else if (pickedObject == kVerbPick && fl == 147) {
 		talk(_text[_lang][426], "426.als");
 		pickObject(15);
 		visible[1] = 0;
 		flags[15] = 1;
 		flags[17] = 1;
 		updateData();
-	} else if (objeto_que_lleva == PICK && fl == 149) {
+	} else if (pickedObject == kVerbPick && fl == 149) {
 		pickObject(13);
 		visible[3] = 0;
 		flags[17] = 0;
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_44(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 172)
+	if (pickedObject == kVerbLook && fl == 172)
 		talk(_text[_lang][428], "428.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_49(int fl){
-	if (objeto_que_lleva == TALK && fl ==51)
+	if (pickedObject == kVerbTalk && fl ==51)
 		conversa("op_9.cal");
-	else if (objeto_que_lleva == LOOK && fl == 51)
+	else if (pickedObject == kVerbLook && fl == 51)
 		talk(_text[_lang][132], "132.als");
-	else if ((objeto_que_lleva == 8 && fl == 51) || (objeto_que_lleva == 8 && fl == 203))
+	else if ((pickedObject == 8 && fl == 51) || (pickedObject == 8 && fl == 203))
 		animation_5_5();
-	else if (objeto_que_lleva == LOOK && fl == 200)
+	else if (pickedObject == kVerbLook && fl == 200)
 		talk(_text[_lang][133], "133.als");
-	else if (objeto_que_lleva == TALK && fl == 200)
+	else if (pickedObject == kVerbTalk && fl == 200)
 		talk(_text[_lang][134], "134.als");
-	else if (objeto_que_lleva == LOOK && fl == 201)
+	else if (pickedObject == kVerbLook && fl == 201)
 		talk(_text[_lang][135], "135.als");
-	else if (objeto_que_lleva == LOOK && fl == 203)
+	else if (pickedObject == kVerbLook && fl == 203)
 		talk(_text[_lang][137], "137.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_53(int fl) {
-	if (objeto_que_lleva == PICK && fl == 120) {
+	if (pickedObject == kVerbPick && fl == 120) {
 		pickObject(16);
 		visible[3] = 0;
-	} else if (objeto_que_lleva == LOOK && fl == 121)
+	} else if (pickedObject == kVerbLook && fl == 121)
 		talk(_text[_lang][128], "128.als");
-	else if (objeto_que_lleva == LOOK && fl == 209)
+	else if (pickedObject == kVerbLook && fl == 209)
 		talk(_text[_lang][129], "129.als");
-	else if (objeto_que_lleva == MOVE && fl == 123)
+	else if (pickedObject == kVerbMove && fl == 123)
 		animation_11_5();
-	else if (objeto_que_lleva == LOOK && fl == 52)
+	else if (pickedObject == kVerbLook && fl == 52)
 		talk(_text[_lang][447], "447.als");
-	else if (objeto_que_lleva == TALK && fl == 52)
+	else if (pickedObject == kVerbTalk && fl == 52)
 		talk(_text[_lang][131], "131.als");
-	else if (objeto_que_lleva == 12 && fl == 52)
+	else if (pickedObject == 12 && fl == 52)
 		animation_10_5();
-	else if (objeto_que_lleva == 15 && fl == 52)
+	else if (pickedObject == 15 && fl == 52)
 		animation_9_5();
-	else if (objeto_que_lleva == 16 && fl == 121) {
+	else if (pickedObject == 16 && fl == 121) {
 		flags[2] = 1;
 		withoutVerb();
 		updateData();
-	} else if (objeto_que_lleva == 16) {
+	} else if (pickedObject == 16) {
 		talk(_text[_lang][439], "439.als");
 		withoutVerb();
 		visible[3] = 1;
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_54(int fl) {
-	if ((objeto_que_lleva == TALK && fl == 118) || (objeto_que_lleva == LOOK && fl == 118 && flags[0] == 0))
+	if ((pickedObject == kVerbTalk && fl == 118) || (pickedObject == kVerbLook && fl == 118 && flags[0] == 0))
 		animation_1_5();
-	else if (objeto_que_lleva == LOOK && fl == 118 && flags[0]==1)
+	else if (pickedObject == kVerbLook && fl == 118 && flags[0]==1)
 		talk(_text[_lang][124], "124.als");
-	else if (objeto_que_lleva == LOOK && fl == 53)
+	else if (pickedObject == kVerbLook && fl == 53)
 		talk(_text[_lang][127], "127.als");
-	else if (objeto_que_lleva == TALK && fl == 53 && flags[14] == 0) {
+	else if (pickedObject == kVerbTalk && fl == 53 && flags[14] == 0) {
 		talk(_text[_lang][288], "288.als");
 		flags[12] = 1;
 		pause(10);
@@ -1065,96 +1072,96 @@ void DrasculaEngine::room_54(int fl) {
 		conversa("op_10.cal");
 		flags[12] = 0;
 		flags[14] = 1;
-	} else if (objeto_que_lleva == TALK && fl == 53 && flags[14] == 1)
+	} else if (pickedObject == kVerbTalk && fl == 53 && flags[14] == 1)
 		talk(_text[_lang][109], "109.als");
-	else if (objeto_que_lleva == PICK && fl == 9999 && flags[13] == 0) {
+	else if (pickedObject == kVerbPick && fl == 9999 && flags[13] == 0) {
 		pickObject(8);
 		flags[13] = 1;
 		talk_mus(_texte[_lang][10], "e10.als");
 		updateData();
-	} else if (objeto_que_lleva == OPEN && fl == 119)
+	} else if (pickedObject == kVerbOpen && fl == 119)
 		talk(_text[_lang][125], "125.als");
-	else if (objeto_que_lleva == LOOK && fl == 119)
+	else if (pickedObject == kVerbLook && fl == 119)
 		talk(_text[_lang][126], "126.als");
-	else if (objeto_que_lleva == 10 && fl == 119) {
+	else if (pickedObject == 10 && fl == 119) {
 		pause(4);
 		talk(_text[_lang][436], "436.als");
 		withoutVerb();
 		resta_objeto(10);
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_55(int fl) {
-	if (objeto_que_lleva == PICK && fl == 122) {
+	if (pickedObject == kVerbPick && fl == 122) {
 		pickObject(12);
 		flags[8] = 1;
 		updateData();
-	} else if (objeto_que_lleva == LOOK && fl == 122)
+	} else if (pickedObject == kVerbLook && fl == 122)
 		talk(_text[_lang][138], "138.als");
-	else if (objeto_que_lleva == LOOK && fl == 204)
+	else if (pickedObject == kVerbLook && fl == 204)
 		talk(_text[_lang][139], "139.als");
-	else if (objeto_que_lleva == LOOK && fl == 205)
+	else if (pickedObject == kVerbLook && fl == 205)
 		talk(_text[_lang][140], "140.als");
 	else if (fl == 206) {
-		comienza_sound("s11.als");
+		playSound("s11.als");
 		anima("det.bin", 17);
-		fin_sound();
+		stopSound();
 		lleva_al_hare(hare_x - 3, hare_y + alto_hare + 6);
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 bool DrasculaEngine::room_56(int fl) {
-	if (objeto_que_lleva == OPEN && fl == 124) {
+	if (pickedObject == kVerbOpen && fl == 124) {
 		animation_14_5();
 		return true;
-	} else if (objeto_que_lleva == LOOK && fl == 124)
+	} else if (pickedObject == kVerbLook && fl == 124)
 		talk(_text[_lang][450], "450.als");
-	else if (objeto_que_lleva == OPEN && fl == 207)
+	else if (pickedObject == kVerbOpen && fl == 207)
 		talk(_text[_lang][141], "141.als");
-	else if (objeto_que_lleva == LOOK && fl == 208)
+	else if (pickedObject == kVerbLook && fl == 208)
 		talk(_text[_lang][142], "142.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 
 	return false;
 }
 
 void DrasculaEngine::room_58(int fl) {
-	if (objeto_que_lleva == MOVE && fl == 103)
+	if (pickedObject == kVerbMove && fl == 103)
 		animation_7_6();
-	else if (objeto_que_lleva == LOOK && fl == 104)
+	else if (pickedObject == kVerbLook && fl == 104)
 		talk(_text[_lang][454], "454.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_59(int fl) {
-	if ((objeto_que_lleva == TALK && fl == 51) || (objeto_que_lleva == LOOK && fl == 51)) {
+	if ((pickedObject == kVerbTalk && fl == 51) || (pickedObject == kVerbLook && fl == 51)) {
 		flags[9] = 1;
-		talk(_text[_lang][259], "259.als");
-		talk_bj_cama(_textbj[_lang][13], "bj13.als");
-		talk(_text[_lang][263], "263.als");
-		talk_bj_cama(_textbj[_lang][14], "bj14.als");
+		talk(259);
+		talk_bj_cama(13);
+		talk(263);
+		talk_bj_cama(14);
 		pause(40);
-		talk(_text[_lang][264], "264.als");
-		talk_bj_cama(_textbj[_lang][15], "BJ15.als");
-		talk(_text[_lang][265], "265.als");
+		talk(264);
+		talk_bj_cama(15);
+		talk(265);
 		flags[9] = 0;
 		if (flags[11] == 0) {
-			comienza_sound("s12.als");
+			playSound("s12.als");
 			delay(40);
-			fin_sound();
+			stopSound();
 			delay(10);
 			lleva_al_hare(174, 168);
 			sentido_hare = 2;
 			updateRoom();
 			updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 			pause(40);
-			comienza_sound("s12.als");
+			playSound("s12.als");
 			pause(19);
-			fin_sound_corte();
+			stopSound_corte();
 			hare_se_ve = 0;
 			updateRoom();
 			copyRect(101, 34, hare_x - 4, hare_y - 1, 37, 70, dir_dibujo3, dir_zona_pantalla);
@@ -1201,244 +1208,244 @@ void DrasculaEngine::room_59(int fl) {
 			flags[11] = 1;
 		}
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 bool DrasculaEngine::room_60(int fl) {
-	if (objeto_que_lleva == MOVE && fl == 112)
+	if (pickedObject == kVerbMove && fl == 112)
 		animation_10_6();
-	else if (objeto_que_lleva == LOOK && fl == 112)
+	else if (pickedObject == kVerbLook && fl == 112)
 		talk(_text[_lang][440], "440.als");
-	else if (objeto_que_lleva == TALK && fl == 52) {
+	else if (pickedObject == kVerbTalk && fl == 52) {
 		talk(_text[_lang][266], "266.als");
 		talk_taber2(_textt[_lang][1], "t1.als");
 		conversa("op_12.cal");
 		withoutVerb();
-		objeto_que_lleva = 0;
-	} else if (objeto_que_lleva == TALK && fl == 115)
+		pickedObject = 0;
+	} else if (pickedObject == kVerbTalk && fl == 115)
 		talk(_text[_lang][455], "455.als");
-	else if (objeto_que_lleva == TALK && fl == 56)
+	else if (pickedObject == kVerbTalk && fl == 56)
 		talk(_text[_lang][455], "455.als");
-	else if (objeto_que_lleva == LOOK && fl == 114)
+	else if (pickedObject == kVerbLook && fl == 114)
 		talk(_text[_lang][167], "167.als");
-	else if (objeto_que_lleva == LOOK && fl == 113)
+	else if (pickedObject == kVerbLook && fl == 113)
 		talk(_text[_lang][168], "168.als");
-	else if (objeto_que_lleva == PICK && fl == 113)
+	else if (pickedObject == kVerbPick && fl == 113)
 		talk(_text[_lang][170], "170.als");
-	else if (objeto_que_lleva == MOVE && fl == 113)
+	else if (pickedObject == kVerbMove && fl == 113)
 		talk(_text[_lang][170], "170.als");
-	else if (objeto_que_lleva == TALK && fl == 113)
+	else if (pickedObject == kVerbTalk && fl == 113)
 		talk(_text[_lang][169], "169.als");
-	else if (objeto_que_lleva == 21 && fl == 56)
+	else if (pickedObject == 21 && fl == 56)
 		animation_18_6();
-	else if (objeto_que_lleva == 9 && fl == 56 && flags[6] == 1) {
+	else if (pickedObject == 9 && fl == 56 && flags[6] == 1) {
 		animation_9_6();
 		return true;
-	} else if (objeto_que_lleva == 9 && fl == 56 && flags[6] == 0) {
+	} else if (pickedObject == 9 && fl == 56 && flags[6] == 0) {
 		anima("cnf.bin", 14);
 		talk(_text[_lang][455], "455.als");
 	} else
-		hay_respuesta = 0;
+		hay_answer = 0;
 
 	return false;
 }
 
 void DrasculaEngine::room_61(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 116)
+	if (pickedObject == kVerbLook && fl == 116)
 		talk(_text[_lang][172], "172.als");
-	else if (objeto_que_lleva == LOOK && fl == 117)
+	else if (pickedObject == kVerbLook && fl == 117)
 		talk(_text[_lang][173], "173.als");
-	else if (objeto_que_lleva == MOVE && fl == 117)
+	else if (pickedObject == kVerbMove && fl == 117)
 		talk(_text[_lang][174], "174.als");
-	else if (objeto_que_lleva == OPEN && fl == 117)
+	else if (pickedObject == kVerbOpen && fl == 117)
 		talk(_text[_lang][174], "174.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_62(int fl) {
-	if (objeto_que_lleva == TALK && fl == 53)
+	if (pickedObject == kVerbTalk && fl == 53)
 		conversa("op_13.cal");
-	else if (objeto_que_lleva == TALK && fl == 52 && flags[0] == 0)
+	else if (pickedObject == kVerbTalk && fl == 52 && flags[0] == 0)
 		animation_3_1();
-	else if (objeto_que_lleva == TALK && fl == 52 && flags[0] == 1)
+	else if (pickedObject == kVerbTalk && fl == 52 && flags[0] == 1)
 		talk(_text[_lang][109], "109.als");
-	else if (objeto_que_lleva == TALK && fl == 54)
+	else if (pickedObject == kVerbTalk && fl == 54)
 		animation_4_1();
-	else if (objeto_que_lleva == LOOK && fl == 100)
+	else if (pickedObject == kVerbLook && fl == 100)
 		talk(_text[_lang][168], "168.als");
-	else if (objeto_que_lleva == TALK && fl == 100)
+	else if (pickedObject == kVerbTalk && fl == 100)
 		talk(_text[_lang][169], "169.als");
-	else if (objeto_que_lleva == PICK && fl == 100)
+	else if (pickedObject == kVerbPick && fl == 100)
 		talk(_text[_lang][170], "170.als");
-	else if (objeto_que_lleva == LOOK && fl == 101)
+	else if (pickedObject == kVerbLook && fl == 101)
 		talk(_text[_lang][171], "171.als");
-	else if (objeto_que_lleva == LOOK && fl == 102)
+	else if (pickedObject == kVerbLook && fl == 102)
 		talk(_text[_lang][167], "167.als");
-	else if (objeto_que_lleva == LOOK && fl == 103)
+	else if (pickedObject == kVerbLook && fl == 103)
 		talk(_text[_lang][166], "166.als");
-	else hay_respuesta = 0;
+	else hay_answer = 0;
 }
 
 void DrasculaEngine::room_63(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 110)
+	if (pickedObject == kVerbLook && fl == 110)
 		talk(_text[_lang][172], "172.als");
-	else if (objeto_que_lleva == LOOK && fl == 109)
+	else if (pickedObject == kVerbLook && fl == 109)
 		talk(_text[_lang][173], "173.als");
-	else if (objeto_que_lleva == MOVE && fl == 109)
+	else if (pickedObject == kVerbMove && fl == 109)
 		talk(_text[_lang][174], "174.als");
-	else if (objeto_que_lleva == LOOK && fl == 108)
+	else if (pickedObject == kVerbLook && fl == 108)
 		talk(_text[_lang][334], "334.als");
-	else if (objeto_que_lleva == TALK && fl == 108)
+	else if (pickedObject == kVerbTalk && fl == 108)
 		talk(_text[_lang][333], "333.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::room_pendulo(int fl) {
-	if (objeto_que_lleva == LOOK && fl == 100)
+	if (pickedObject == kVerbLook && fl == 100)
 		talk(_text[_lang][452], "452.als");
-	else if (objeto_que_lleva == LOOK && fl == 101)
+	else if (pickedObject == kVerbLook && fl == 101)
 		talk (_text[_lang][123], "123.als");
-	else if (objeto_que_lleva == PICK && fl == 101)
+	else if (pickedObject == kVerbPick && fl == 101)
 		pickObject(20);
-	else if (objeto_que_lleva == 20 && fl == 100)
+	else if (pickedObject == 20 && fl == 100)
 		animation_6_6();
-	else if (objeto_que_lleva == PICK || objeto_que_lleva == OPEN)
+	else if (pickedObject == kVerbPick || pickedObject == kVerbOpen)
 		talk(_text[_lang][453], "453.als");
 	else
-		hay_respuesta = 0;
+		hay_answer = 0;
 }
 
 void DrasculaEngine::updateRefresh() {
 	if (num_ejec == 1) {
-		if (!strcmp(num_room, "63.alg"))
+		if (roomNumber == 63)
 			update_63();
-		else if (!strcmp(num_room, "62.alg"))
+		else if (roomNumber == 62)
 			update_62();
 	} else if (num_ejec == 2) {
-		if (!strcmp(num_room, "3.alg"))
+		if (roomNumber == 3)
 			update_3();
-		else if (!strcmp(num_room, "2.alg"))
+		else if (roomNumber == 2)
 			update_2();
-		else if (!strcmp(num_room, "4.alg"))
+		else if (roomNumber == 4)
 			update_4();
-		else if (!strcmp(num_room, "5.alg"))
+		else if (roomNumber == 5)
 			update_5();
-		else if (!strcmp(num_room, "15.alg"))
+		else if (roomNumber == 15)
 			update_15();
-		else if (!strcmp(num_room, "17.alg"))
+		else if (roomNumber == 17)
 			update_17();
-		else if (!strcmp(num_room, "18.alg"))
+		else if (roomNumber == 18)
 			update_18();
-		else if (!strcmp(num_room, "10.alg"))
+		else if (roomNumber == 10)
 			mapa();
 	} else if (num_ejec == 3) {
-		if (!strcmp(num_room, "20.alg"))
+		if (roomNumber == 20)
 			update_20();
-		else if (!strcmp(num_room, "13.alg"))
+		else if (roomNumber == 13)
 			update_13();
 	} else if (num_ejec == 4) {
-		if (!strcmp(num_room, "29.alg"))
+		if (roomNumber == 29)
 			update_29();
-		else if (!strcmp(num_room, "26.alg"))
+		else if (roomNumber == 26)
 			update_26();
-		else if (!strcmp(num_room, "27.alg"))
+		else if (roomNumber == 27)
 			update_27();
-		else if (!strcmp(num_room, "31.alg"))
+		else if (roomNumber == 31)
 			update_31();
-		else if (!strcmp(num_room, "34.alg"))
+		else if (roomNumber == 34)
 			update_34();
-		else if (!strcmp(num_room, "35.alg"))
+		else if (roomNumber == 35)
 			update_35();
 	} else if (num_ejec == 5) {
-		if (!strcmp(num_room, "45.alg"))
+		if (roomNumber == 45)
 			mapa();
-		else if (!strcmp(num_room, "50.alg"))
+		else if (roomNumber == 50)
 			update_50();
-		else if (!strcmp(num_room, "57.alg"))
+		else if (roomNumber == 57)
 			update_57();
 	} else if (num_ejec == 6) {
-		if (!strcmp(num_room, "60.alg"))
+		if (roomNumber == 60)
 			update_60();
-		else if (!strcmp(num_room, "61.alg"))
+		else if (roomNumber == 61)
 			update_61();
-		else if (!strcmp(num_room, "58.alg"))
+		else if (roomNumber == 58)
 			update_58();
 	}
 }
 
 void DrasculaEngine::updateRefresh_pre() {
 	if (num_ejec == 1) {
-		if (!strcmp(num_room, "62.alg"))
+		if (roomNumber == 62)
 			update_62_pre();
-		else if (!strcmp(num_room, "16.alg"))
+		else if (roomNumber == 16)
 			pon_bj();
 	} else if (num_ejec == 2) {
-		if (!strcmp(num_room, "1.alg"))
+		if (roomNumber == 1)
 			update_1_pre();
-		else if (!strcmp(num_room, "3.alg"))
+		else if (roomNumber == 3)
 			update_3_pre();
-		else if (!strcmp(num_room, "5.alg"))
+		else if (roomNumber == 5)
 			update_5_pre();
-		else if (!strcmp(num_room, "6.alg"))
+		else if (roomNumber == 6)
 			update_6_pre();
-		else if (!strcmp(num_room, "7.alg"))
+		else if (roomNumber == 7)
 			update_7_pre();
-		else if (!strcmp(num_room, "9.alg"))
+		else if (roomNumber == 9)
 			update_9_pre();
-		else if (!strcmp(num_room, "12.alg"))
+		else if (roomNumber == 12)
 			update_12_pre();
-		else if (!strcmp(num_room, "14.alg"))
+		else if (roomNumber == 14)
 			update_14_pre();
-		else if (!strcmp(num_room, "16.alg"))
+		else if (roomNumber == 16)
 			update_16_pre();
-		else if (!strcmp(num_room, "17.alg"))
+		else if (roomNumber == 17)
 			update_17_pre();
-		else if (!strcmp(num_room, "18.alg"))
+		else if (roomNumber == 18)
 			update_18_pre();
 	} else if (num_ejec == 3) {
 		// nothing
 	} else if (num_ejec == 4) {
-		if (!strcmp(num_room, "21.alg"))
+		if (roomNumber == 21)
 			update_21_pre();
-		else if (!strcmp(num_room, "22.alg"))
+		else if (roomNumber == 22)
 			update_22_pre();
-		else if (!strcmp(num_room, "23.alg"))
+		else if (roomNumber == 23)
 			update_23_pre();
-		else if (!strcmp(num_room, "24.alg"))
+		else if (roomNumber == 24)
 			update_24_pre();
-		else if (!strcmp(num_room, "26.alg"))
+		else if (roomNumber == 26)
 			update_26_pre();
-		else if (!strcmp(num_room, "27.alg"))
+		else if (roomNumber == 27)
 			update_27_pre();
-		else if (!strcmp(num_room, "29.alg"))
+		else if (roomNumber == 29)
 			update_29_pre();
-		else if (!strcmp(num_room, "30.alg"))
+		else if (roomNumber == 30)
 			update_30_pre();
-		else if (!strcmp(num_room, "31.alg"))
+		else if (roomNumber == 31)
 			update_31_pre();
-		else if (!strcmp(num_room, "34.alg"))
+		else if (roomNumber == 34)
 			update_34_pre();
-		else if (!strcmp(num_room, "35.alg"))
+		else if (roomNumber == 35)
 			update_35_pre();
 	} else if (num_ejec == 5) {
-		if (!strcmp(num_room,"49.alg"))
+		if (roomNumber == 49)
 			update_49_pre();
-		else if (!strcmp(num_room,"53.alg"))
+		else if (roomNumber == 53)
 			update_53_pre();
-		else if (!strcmp(num_room,"54.alg"))
+		else if (roomNumber == 54)
 			update_54_pre();
-		else if (!strcmp(num_room,"56.alg"))
+		else if (roomNumber == 56)
 			update_56_pre();
 	} else if (num_ejec == 6) {
-		if (!strcmp(num_room, "102.alg"))
+		if (roomNumber == 102)
 			update_pendulo();
-		else if (!strcmp(num_room, "58.alg"))
+		else if (roomNumber == 58)
 			update_58_pre();
-		else if (!strcmp(num_room, "59.alg"))
+		else if (roomNumber == 59)
 			update_59_pre();
-		else if (!strcmp(num_room, "60.alg"))
+		else if (roomNumber == 60)
 			update_60_pre();
 	}
 }
diff --git a/engines/drascula/talk.cpp b/engines/drascula/talk.cpp
index 62f44c31d3..d6f393aa2a 100644
--- a/engines/drascula/talk.cpp
+++ b/engines/drascula/talk.cpp
@@ -27,22 +27,7 @@
 
 namespace Drascula {
 
-void DrasculaEngine::talk_igor_dch(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
-	int x_talk[8] = { 56, 82, 108, 134, 160, 186, 212, 238 };
-	int cara;
-
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
-
-	color_abc(WHITE);
-
+void DrasculaEngine::talkInit(const char *filename) {
 	if (hay_sb == 1) {
 		sku = new Common::File;
 		sku->open(filename);
@@ -53,6 +38,18 @@ void DrasculaEngine::talk_igor_dch(const char *said, const char *filename) {
 		ctvd_speaker(1);
 		ctvd_output(sku);
 	}
+}
+
+void DrasculaEngine::talk_igor_dch(const char *said, const char *filename) {
+	int x_talk[8] = { 56, 82, 108, 134, 160, 186, 212, 238 };
+	int cara;
+	int length = strlen(said);
+
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
+
+	color_abc(WHITE);
+
+	talkInit(filename);
 
 bucless:
 
@@ -89,8 +86,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 	copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
@@ -100,31 +97,15 @@ bucless:
 }
 
 void DrasculaEngine::talk_dr_izq(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[8] = { 1, 40, 79, 118, 157, 196, 235, 274 };
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(RED);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -166,8 +147,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -178,31 +159,15 @@ bucless:
 }
 
 void DrasculaEngine::talk_dr_dch(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[8] = { 1, 40, 79, 118, 157, 196, 235, 274 };
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(RED);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -243,8 +208,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -259,31 +224,16 @@ bucless:
 }
 
 void DrasculaEngine::talk_solo(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	if (num_ejec == 1)
 		color_abc(color_solo);
 	else if (num_ejec == 4)
 		color_abc(RED);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 	if (num_ejec == 6)
 		copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
@@ -312,8 +262,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 	if (num_ejec == 6) {
@@ -323,31 +273,15 @@ bucless:
 }
 
 void DrasculaEngine::talk_igor_frente(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[8] = { 56, 86, 116, 146, 176, 206, 236, 266 };
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(WHITE);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -386,8 +320,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -404,31 +338,15 @@ bucless:
 }
 
 void DrasculaEngine::talk_tabernero(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[9] = { 1, 23, 45, 67, 89, 111, 133, 155, 177 };
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(MAROON);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -466,8 +384,8 @@ bucless:
 		delete(sku);
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -475,32 +393,22 @@ bucless:
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 }
 
-void DrasculaEngine::talk_bj(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
+void DrasculaEngine::talk_bj(int index) {
+	char name[20];
+	sprintf(name, "BJ%i.als", index);
+	talk_bj(_textbj[_lang][index], name);
+}
 
+void DrasculaEngine::talk_bj(const char *said, const char *filename) {
 	int x_talk[5] = { 64, 92, 120, 148, 176 };
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(WHITE);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 	if (num_ejec != 5) {
@@ -545,8 +453,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -554,10 +462,13 @@ bucless:
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 }
 
-void DrasculaEngine::talk(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
+void DrasculaEngine::talk(int index) {
+	char name[20];
+	sprintf(name, "%i.als", index);
+	talk(_text[_lang][index], name);
+}
 
+void DrasculaEngine::talk(const char *said, const char *filename) {
 	int suma_1_pixel = 0;
 	if (num_ejec != 2)
 		suma_1_pixel = 1;
@@ -566,24 +477,20 @@ void DrasculaEngine::talk(const char *said, const char *filename) {
 	int x_talk_dch[6] = { 1, 25, 49, 73, 97, 121 };
 	int x_talk_izq[6] = { 145, 169, 193, 217, 241, 265 };
 	int cara;
-
-	int longitud;
-	longitud = strlen(said);
+	int length = strlen(said);
 
 	if (num_ejec == 6) {
-		if (flags[0] == 0 && (!strcmp(num_room, "102.alg"))) {
+		if (flags[0] == 0 && roomNumber == 102) {
 			talk_pen(said, filename);
 			return;
 		}
-		if (flags[0] == 0 && (!strcmp(num_room, "58.alg"))) {
+		if (flags[0] == 0 && roomNumber == 58) {
 			talk_pen2(said, filename);
 			return;
 		}
 	}
 
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	if (num_ejec != 2) {
 		if (factor_red[hare_y + alto_hare] == 100)
@@ -591,22 +498,14 @@ void DrasculaEngine::talk(const char *said, const char *filename) {
 	}
 
 	if (num_ejec == 4) {
-		if (strcmp(num_room, "24.alg") || flags[29] == 0) {
+		if (roomNumber == 24 || flags[29] == 0) {
 			color_abc(YELLOW);
 		}
 	} else {
 		color_abc(YELLOW);
 	}
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+
+	talkInit(filename);
 
 bucless:
 
@@ -692,8 +591,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -707,29 +606,15 @@ bucless:
 }
 
 void DrasculaEngine::talk_pianista(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
 	int x_talk[4] = { 97, 145, 193, 241 };
 	int cara;
-	int longitud;
-	longitud = strlen(said);
+	int length = strlen(said);
 
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(WHITE);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -761,8 +646,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -771,17 +656,11 @@ bucless:
 }
 
 void DrasculaEngine::talk_borracho(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[8] = { 1, 21, 41, 61, 81, 101, 121, 141 };
 	int cara;
-	int longitud;
-	longitud = strlen(said);
+	int length = strlen(said);
 
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	if (num_ejec == 1) {
 		loadPic("an11y13.alg");
@@ -800,16 +679,7 @@ bebiendo:
 
 	color_abc(DARK_GREEN);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz\n");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -840,8 +710,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -863,32 +733,22 @@ bucless:
 	}
 }
 
-void DrasculaEngine::talk_vb(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
+void DrasculaEngine::talk_vb(int index) {
+	char name[20];
+	sprintf(name, "VB%i.als", index);
+	talk_vb(_textvb[_lang][index], name);
+}
 
+void DrasculaEngine::talk_vb(const char *said, const char *filename) {
 	int x_talk[6] = {1, 27, 53, 79, 105, 131};
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(VON_BRAUN);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 	copyBackground(vb_x + 5, 64, OBJWIDTH + 1, 0, 25, 27, dir_dibujo1, dir_dibujo3);
 
@@ -923,8 +783,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -934,29 +794,20 @@ bucless:
 		playMusic(roomMusic);
 }
 
-void DrasculaEngine::talk_vbpuerta(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
+void DrasculaEngine::talk_vbpuerta(int index) {
+	char name[20];
+	sprintf(name, "VB%i.als", index);
+	talk_vb(_textvb[_lang][index], name);
+}
 
-	int longitud;
-	longitud = strlen(said);
+void DrasculaEngine::talk_vbpuerta(const char *said, const char *filename) {
+	int length = strlen(said);
 
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(VON_BRAUN);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -975,8 +826,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -990,26 +841,14 @@ void DrasculaEngine::talk_ciego(const char *said, const char *filename, const ch
 	byte *num_cara;
 	int p = 0;
 	int pos_ciego[6];
-	int cara = 0;
-
-	int longitud;
-	longitud = strlen(said);
+	int length = strlen(said);
 
 	color_abc(VON_BRAUN);
 
 	copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 	pos_ciego[1] = 2;
 	pos_ciego[2] = 73;
@@ -1021,39 +860,23 @@ bucless:
 	copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 	pos_ciego[5] = 149;
 	char c = toupper(sincronia[p]);
-	if (c == '0')
-		cara = 0;
-	if (c == '1')
-		cara = 1;
-	if (c == '2')
-		cara = 2;
-	if (c == '3')
-		cara = 3;
-	if (c == '4')
-		cara = 4;
-	if (c == '5')
-		cara = 5;
-	if (c == '6')
-		cara = 6;
-	if (c == '7')
-		cara = 7;
 
-	if (cara == 0 || cara == 2 || cara == 4 || cara == 6)
+	if (c == '0' || c == '2' || c == '4' || c == '6')
 		pos_ciego[0] = 1;
 	else
 		pos_ciego[0] = 132;
 
-	if (cara == 0)
+	if (c == '0')
 		num_cara = dir_dibujo3;
-	else if (cara == 1)
+	else if (c == '1')
 		num_cara = dir_dibujo3;
-	else if (cara == 2)
+	else if (c == '2')
 		num_cara = dir_hare_dch;
-	else if (cara == 3)
+	else if (c == '3')
 		num_cara = dir_hare_dch;
-	else if (cara == 4)
+	else if (c == '4')
 		num_cara = dir_hare_fondo;
-	else if (cara == 5)
+	else if (c == '5')
 		num_cara = dir_hare_fondo;
 	else {
 		num_cara = dir_hare_frente;
@@ -1079,38 +902,23 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 }
 
 void DrasculaEngine::talk_hacker(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
-	int longitud;
-	longitud = strlen(said);
+	int length = strlen(said);
 
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	copyBackground(0, 0, 0, 0, 320, 200, dir_dibujo1, dir_zona_pantalla);
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 
 	color_abc(YELLOW);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 	if (withVoices == 0)
@@ -1127,8 +935,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -1136,31 +944,15 @@ bucless:
 }
 
 void DrasculaEngine::talk_lobo(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[9] = {52, 79, 106, 133, 160, 187, 214, 241, 268};
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(RED);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1191,8 +983,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -1201,31 +993,15 @@ bucless:
 }
 
 void DrasculaEngine::talk_mus(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[8] = { 16, 35, 54, 73, 92, 111, 130, 149};
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(WHITE);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1256,8 +1032,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-	if (longitud > 0)
+		length -= 2;
+	if (length > 0)
 		goto bucless;
 	}
 
@@ -1266,14 +1042,9 @@ bucless:
 }
 
 void DrasculaEngine::talk_pen(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[8] = {112, 138, 164, 190, 216, 242, 268, 294};
 	int cara;
-
-	int longitud;
-	longitud = strlen(said);
+	int length = strlen(said);
 
 	flags[1] = 1;
 
@@ -1281,22 +1052,11 @@ void DrasculaEngine::talk_pen(const char *said, const char *filename) {
 	copyRect(44, 145, 145, 105, 25, 29, dir_dibujo3, dir_zona_pantalla);
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(YELLOW);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1327,8 +1087,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -1339,33 +1099,17 @@ bucless:
 }
 
 void DrasculaEngine::talk_pen2(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[5]={122, 148, 174, 200, 226};
 	int cara;
-
-	int longitud;
-	longitud = strlen(said);
+	int length = strlen(said);
 
 	flags[1] = 1;
 
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(YELLOW);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1396,8 +1140,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -1408,31 +1152,15 @@ bucless:
 }
 
 void DrasculaEngine::talk_taber2(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[6] = {1, 23, 45, 67, 89, 111};
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(MAROON);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1463,8 +1191,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -1472,32 +1200,22 @@ bucless:
 	updateScreen(0, 0, 0, 0, 320, 200, dir_zona_pantalla);
 }
 
-void DrasculaEngine::talk_bj_cama(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
+void DrasculaEngine::talk_bj_cama(int index) {
+	char name[20];
+	sprintf(name, "BJ%i.als", index);
+	talk_bj_cama(_textbj[_lang][index], name);
+}
 
+void DrasculaEngine::talk_bj_cama(const char *said, const char *filename) {
 	int x_talk[5] = {51, 101, 151, 201, 251};
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(WHITE);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1529,8 +1247,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 	updateRoom();
@@ -1538,32 +1256,16 @@ bucless:
 }
 
 void DrasculaEngine::talk_htel(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
 	char *num_cara;
-
 	int x_talk[3] = {1, 94, 187};
 	int cara, pantalla;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(YELLOW);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1597,8 +1299,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -1612,9 +1314,7 @@ void DrasculaEngine::talk_sinc(const char *said, const char *filename, const cha
 	int x_talk_dch[6] = {1, 25, 49, 73, 97, 121};
 	int x_talk_izq[6] = {145, 169, 193, 217, 241, 265};
 	int p, cara = 0;
-
-	int longitud;
-	longitud = strlen(said);
+	int length = strlen(said);
 
 	color_abc(YELLOW);
 
@@ -1625,16 +1325,7 @@ void DrasculaEngine::talk_sinc(const char *said, const char *filename, const cha
 
 	p = 0;
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1721,8 +1412,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -1733,31 +1424,16 @@ bucless:
 }
 
 void DrasculaEngine::talk_baul(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
 	int cara = 0, cara_antes;
-	int longitud;
+	int length = strlen(said);
 
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	cara_antes = flags[19];
 
 	color_abc(MAROON);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1786,8 +1462,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -1797,28 +1473,13 @@ bucless:
 }
 
 void DrasculaEngine::talk_igorpuerta(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(WHITE);
 
-	if (hay_sb == 1){
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1837,8 +1498,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -1847,31 +1508,15 @@ bucless:
 }
 
 void DrasculaEngine::talk_igor_sentado(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[4] = { 80, 102, 124, 146 };
 	int cara;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(WHITE);
 
-	if (hay_sb == 1) {
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1902,8 +1547,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
@@ -1912,31 +1557,15 @@ bucless:
 }
 
 void DrasculaEngine::talk_igor_peluca(const char *said, const char *filename) {
-	int tiempou;
-	long tiempol;
-
 	int x_talk[4] = {119, 158, 197, 236};
 	int cara = 0;
+	int length = strlen(said);
 
-	int longitud;
-	longitud = strlen(said);
-
-	tiempol = _system->getMillis();
-	tiempou = (unsigned int)tiempol / 2;
-	_rnd->setSeed(tiempou);
+	_rnd->setSeed((unsigned int)_system->getMillis() / 2);
 
 	color_abc(WHITE);
 
-	if (hay_sb == 1){
-		sku = new Common::File;
-		sku->open(filename);
-		if (!sku->isOpen()) {
-			error("no puedo abrir archivo de voz");
-		}
-		ctvd_init(2);
-		ctvd_speaker(1);
-		ctvd_output(sku);
-	}
+	talkInit(filename);
 
 bucless:
 
@@ -1967,8 +1596,8 @@ bucless:
 		sku = NULL;
 		ctvd_terminate();
 	} else {
-		longitud = longitud - 2;
-		if (longitud > 0)
+		length -= 2;
+		if (length > 0)
 			goto bucless;
 	}
 
diff --git a/engines/drascula/texts.cpp b/engines/drascula/texts.cpp
index 6389097c1d..c84f176d35 100644
--- a/engines/drascula/texts.cpp
+++ b/engines/drascula/texts.cpp
@@ -4677,7 +4677,7 @@ const char *_textt[][25] = {
 	"QU'EST-CE QU'IL Y A, QU'Y A-T-IL?",
 	"D'ACCORD. CHAMBRE 512. PAR LES ESCALIERS. LA CL EST SUR LA PORTE",
 	"LE COMTE DRASCULA?!",
-	"NON, RIEN, CE TYPE A UNE MAUVAISE RPUTATION PAR ICI",
+	"NON, RIEN, CE TYPE A UNE MAUVAISE R\220PUTATION PAR ICI",
 	// 5
 	"EH BIEN, IL Y A DES RUMEURS QUI  COURENT SUR LUI. CERTAINS DISENT QUE C'EST UN VAMPIRE ET QU'IL ENLEVE DU MONDE POUR SUCER LEUR SANG ",
 	"MAIS D'AUTRES PENSENT QU'IL EST SEULEMENT UN TRAFICANT D'ORGANES, ET C'EST POUR CELA QUE DES PERSONNES DPECES SONT APPARUES DANS LES ALENTOURS",
@@ -5308,20 +5308,20 @@ const char *_textverbs[][6] = {
 	"mover",
 },
 {
-	"look", // TODO Translate it
-	"take",
-	"open",
-	"close",
-	"talk",
-	"push",
+	"Schau",
+	"Nimm",
+	"oeFFNE",
+	"Schliesse",
+	"Rede",
+	"Druecke",
 },
 {
-	"look", // TODO Translate it
-	"take",
-	"open",
-	"close",
-	"talk",
-	"push",
+	"regardez",
+	"ramassez",
+	"ouvrez",
+	"fermez",
+	"parlez",
+	"poussez",
 },
 {
 	"esamina",
@@ -5334,21 +5334,26 @@ const char *_textverbs[][6] = {
 };
 
 
-const char *_textmisc[][1] = {
+const char *_textmisc[][2] = {
 {
 	"HUNCHBACKED",
+	"Transilvania, 1993 d.c.",
 },
 {
 	"jorobado",
+	"Transilvania, 1993 d.c. (despues de cenar)",
 },
 {
 	"HUNCHBACKED",
+	"Transilvania, 1993 d.c.",
 },
 {
 	"HUNCHBACKED",
+	"Transilvania, 1993 d.c.",
 },
 {
 	"HUNCHBACKED",
+	"Transilvania, 1993 d.c.",
 },
 };
 
diff --git a/engines/gob/coktelvideo.cpp b/engines/gob/coktelvideo.cpp
index c3625574d0..415790e67b 100644
--- a/engines/gob/coktelvideo.cpp
+++ b/engines/gob/coktelvideo.cpp
@@ -123,8 +123,9 @@ bool Imd::load(Common::SeekableReadStream &stream) {
 			return false;
 		}
 
-		_soundSliceLength = 1000 / (_soundFreq / _soundSliceSize);
-		_frameLength = _soundSliceLength;
+		_soundSliceLength = (uint32) (((double) (1000 << 16)) / 
+				((double) _soundFreq / (double) _soundSliceSize));
+		_frameLength = _soundSliceLength >> 16;
 
 		_soundStage = 1;
 		_hasSound = true;
@@ -325,11 +326,11 @@ void Imd::waitEndFrame() {
 			return;
 
 		if (_skipFrames == 0) {
-			int32 waitTime = (_curFrame * _soundSliceLength) -
-				(g_system->getMillis() - _soundStartTime);
+			int32 waitTime = (int16) (((_curFrame * _soundSliceLength) -
+				((g_system->getMillis() - _soundStartTime) << 16)) >> 16);
 
 			if (waitTime < 0) {
-				_skipFrames = -waitTime / _soundSliceLength;
+				_skipFrames = -waitTime / (_soundSliceLength >> 16);
 				warning("Video A/V sync broken, skipping %d frame(s)", _skipFrames + 1);
 			} else if (waitTime > 0)
 				g_system->delayMillis(waitTime);
@@ -340,6 +341,11 @@ void Imd::waitEndFrame() {
 		g_system->delayMillis(_frameLength);
 }
 
+void Imd::notifyPaused(uint32 duration) {
+	if (_soundStage == 2)
+		_soundStartTime += duration;
+}
+
 void Imd::copyCurrentFrame(byte *dest,
 		uint16 left, uint16 top, uint16 width, uint16 height,
 		uint16 x, uint16 y, uint16 pitch, int16 transp) {
@@ -938,10 +944,9 @@ bool Vmd::load(Common::SeekableReadStream &stream) {
 			_soundSliceSize = -_soundSliceSize;
 		}
 
-		_soundSliceLength = (uint16) (1000.0 /
+		_soundSliceLength = (uint32) (((double) (1000 << 16)) / 
 				((double) _soundFreq / (double) _soundSliceSize));
-
-		_frameLength = _soundSliceLength;
+		_frameLength = _soundSliceLength >> 16;
 
 		_soundStage = 1;
 		_audioStream = Audio::makeAppendableAudioStream(_soundFreq,
@@ -1073,8 +1078,8 @@ CoktelVideo::State Vmd::processFrame(uint16 frame) {
 
 	state.flags |= kStateNoVideoData;
 	state.left = 0x7FFF;
-	state.right = 0x7FFF;
-	state.top = 0;
+	state.top = 0x7FFF;
+	state.right = 0;
 	state.bottom = 0;
 
 	if (!_vidMem)
@@ -1128,6 +1133,8 @@ CoktelVideo::State Vmd::processFrame(uint16 frame) {
 		} else if (part.type == kPartTypeVideo) {
 			state.flags &= ~kStateNoVideoData;
 
+			uint32 size = part.size;
+
 			// New palette
 			if (part.flags & 2) {
 				uint8 index = _stream->readByte();
@@ -1137,9 +1144,12 @@ CoktelVideo::State Vmd::processFrame(uint16 frame) {
 				_stream->skip((255 - count) * 3);
 
 				state.flags |= kStatePalette;
+
+				size -= (768 + 2);
 			}
 
-			_stream->read(_frameData, part.size);
+			_stream->read(_frameData, size);
+
 			if (renderFrame(part.left, part.top, part.right, part.bottom)) {
 				// Rendering succeeded, merging areas
 				state.left = MIN(state.left, part.left);
diff --git a/engines/gob/coktelvideo.h b/engines/gob/coktelvideo.h
index 581ac2ae81..348e5e3ab1 100644
--- a/engines/gob/coktelvideo.h
+++ b/engines/gob/coktelvideo.h
@@ -134,7 +134,7 @@ public:
 	/** Use an own memory block as video memory. */
 	virtual void setVideoMemory() = 0;
 
-	/** Play sound (if the IMD has sound). */
+	/** Play sound (if the video has sound). */
 	virtual void enableSound(Audio::Mixer &mixer) = 0;
 	/** Don't play sound or stop currently playing sound. */
 	virtual void disableSound() = 0;
@@ -155,6 +155,9 @@ public:
 	/** Wait for the frame to end. */
 	virtual void waitEndFrame() = 0;
 
+	/** Notifies the video that it was paused for duration ms. */
+	virtual void notifyPaused(uint32 duration) = 0;
+
 	/** Copy the current frame.
 	 *
 	 *  @param dest The memory to which to copy the current frame.
@@ -187,7 +190,11 @@ public:
 	int16 getHeight() const { return _height; }
 	uint16 getFramesCount() const { return _framesCount; }
 	uint16 getCurrentFrame() const { return _curFrame; }
-	int16 getFrameRate() const { if (_hasSound) return 1000 / _soundSliceLength; return _frameRate; }
+	int16 getFrameRate() const {
+		if (_hasSound)
+			return 1000 / (_soundSliceLength >> 16);
+		return _frameRate;
+	}
 	uint32 getSyncLag() const { return _skipFrames; }
 	const byte *getPalette() const { return _palette; }
 
@@ -213,6 +220,8 @@ public:
 	State nextFrame();
 	void waitEndFrame();
 
+	void notifyPaused(uint32 duration);
+
 	void copyCurrentFrame(byte *dest,
 			uint16 left, uint16 top, uint16 width, uint16 height,
 			uint16 x, uint16 y, uint16 pitch, int16 transp = -1);
@@ -255,7 +264,7 @@ protected:
 	int16 _soundFreq;
 	int16 _soundSliceSize;
 	int16 _soundSlicesCount;
-	uint16 _soundSliceLength;
+	uint32 _soundSliceLength;
 
 	Audio::AppendableAudioStream *_audioStream;
 	Audio::SoundHandle _audioHandle;
diff --git a/engines/gob/detection.cpp b/engines/gob/detection.cpp
index cbc9272e80..8351f2ecfb 100644
--- a/engines/gob/detection.cpp
+++ b/engines/gob/detection.cpp
@@ -1684,6 +1684,71 @@ static const GOBGameDescription gameDescriptions[] = {
 		kFeatures640,
 		"intro"
 	},
+	{ // Supplied by DjDiabolik in bug report #1971294
+		{
+			"woodruff",
+			"",
+			AD_ENTRY1s("intro.stk", "60348a87651f92e8492ee070556a96d8", 7069736),
+			EN_GRB,
+			kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		kGameTypeWoodruff,
+		kFeatures640,
+		"intro"
+	},
+	{ // Supplied by DjDiabolik in bug report #1971294
+		{
+			"woodruff",
+			"",
+			AD_ENTRY1s("intro.stk", "60348a87651f92e8492ee070556a96d8", 7069736),
+			DE_DEU,
+			kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		kGameTypeWoodruff,
+		kFeatures640,
+		"intro"
+	},
+	{ // Supplied by DjDiabolik in bug report #1971294
+		{
+			"woodruff",
+			"",
+			AD_ENTRY1s("intro.stk", "60348a87651f92e8492ee070556a96d8", 7069736),
+			FR_FRA,
+			kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		kGameTypeWoodruff,
+		kFeatures640,
+		"intro"
+	},
+	{ // Supplied by DjDiabolik in bug report #1971294
+		{
+			"woodruff",
+			"",
+			AD_ENTRY1s("intro.stk", "60348a87651f92e8492ee070556a96d8", 7069736),
+			IT_ITA,
+			kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		kGameTypeWoodruff,
+		kFeatures640,
+		"intro"
+	},
+	{ // Supplied by DjDiabolik in bug report #1971294
+		{
+			"woodruff",
+			"",
+			AD_ENTRY1s("intro.stk", "60348a87651f92e8492ee070556a96d8", 7069736),
+			ES_ESP,
+			kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		kGameTypeWoodruff,
+		kFeatures640,
+		"intro"
+	},
 	{
 		{
 			"dynasty",
diff --git a/engines/gob/draw_v2.cpp b/engines/gob/draw_v2.cpp
index 1195e35e93..8c12079b83 100644
--- a/engines/gob/draw_v2.cpp
+++ b/engines/gob/draw_v2.cpp
@@ -247,10 +247,7 @@ void Draw_v2::printTotText(int16 id) {
 	if (_renderFlags & RENDERFLAG_FROMSPLIT) {
 		int16 start;
 
-		if (_vm->_video->_splitHeight1 < _vm->_height)
-			start = _vm->_video->_splitHeight1;
-		else
-			start = _vm->_video->_splitStart;
+		start = _vm->_video->_splitStart;
 
 		destY = start;
 		spriteBottom = READ_LE_UINT16(ptr + 6) - READ_LE_UINT16(ptr + 2);
@@ -654,22 +651,23 @@ void Draw_v2::spriteOperation(int16 operation) {
 	int16 destSurface = _destSurface;
 	int16 sourceSurface = _sourceSurface;
 
-	if ((_destSpriteY >= _vm->_video->_splitHeight1) &&
-	    ((_destSurface == 20) || (_destSurface == 21))) {
-
-		if (_vm->_video->_splitHeight1 < _vm->_height) {
-			_destSpriteY = (_destSpriteY - _vm->_video->_splitHeight1) + _vm->_video->_splitStart;
+	if (_vm->_video->_splitSurf && ((_destSurface == 20) || (_destSurface == 21))) {
+		if ((_destSpriteY >= _vm->_video->_splitStart)) {
+			_destSpriteY -= _vm->_video->_splitStart;
 			if ((operation == DRAW_DRAWLINE) ||
 				 ((operation >= DRAW_DRAWBAR) && (operation <= DRAW_FILLRECTABS)))
-				_spriteBottom = (_spriteBottom - _vm->_video->_splitHeight1) + _vm->_video->_splitStart;
+				_spriteBottom -= _vm->_video->_splitStart;
+
+			_destSurface += 4;
 		}
 
-	}
+		if ((_spriteTop >= _vm->_video->_splitStart) && (operation == DRAW_BLITSURF)) {
+			_spriteTop -= _vm->_video->_splitStart;
+			if (_destSurface < 24)
+				_destSurface += 4;
+		}
 
-	if ((_spriteTop >= _vm->_video->_splitHeight1) && (operation == DRAW_BLITSURF) &&
-	    ((_destSurface == 20) || (_destSurface == 21)))
-		if (_vm->_video->_splitHeight1 < _vm->_height)
-			_spriteTop = (_spriteTop - _vm->_video->_splitHeight1) + _vm->_video->_splitStart;
+	}
 
 	adjustCoords(0, &_destSpriteX, &_destSpriteY);
 	if ((operation != DRAW_LOADSPRITE) && (_needAdjust != 2)) {
diff --git a/engines/gob/driver_vga.cpp b/engines/gob/driver_vga.cpp
index c4861ca146..f68ce47783 100644
--- a/engines/gob/driver_vga.cpp
+++ b/engines/gob/driver_vga.cpp
@@ -109,10 +109,16 @@ void VGAVideoDriver::drawSprite(SurfaceDesc *source, SurfaceDesc *dest,
 	int16 width = MIN((right - left) + 1, (int) dest->getWidth());
 	int16 height = MIN((bottom - top) + 1, (int) dest->getHeight());
 
+	if ((width < 1) || (height < 1))
+		return;
+
 	byte *srcPos = source->getVidMem() + (top * source->getWidth()) + left;
 	byte *destPos = dest->getVidMem() + (y * dest->getWidth()) + x;
 
+	uint32 size = width * height;
+	
 	if (transp) {
+
 		while (height--) {
 			for (int16 i = 0; i < width; ++i) {
 				if (srcPos[i])
@@ -122,13 +128,26 @@ void VGAVideoDriver::drawSprite(SurfaceDesc *source, SurfaceDesc *dest,
 			srcPos += source->getWidth();
 			destPos += dest->getWidth();
 		}
+
+	} else if (((srcPos  >= destPos) && (srcPos  <= (destPos + size))) ||
+	           ((destPos >= srcPos)  && (destPos <= (srcPos  + size)))) {
+
+		while (height--) {
+			memmove(destPos, srcPos, width);
+
+			srcPos += source->getWidth();
+			destPos += dest->getWidth();
+		}
+
 	} else {
+
 		while (height--) {
 			memcpy(destPos, srcPos, width);
 
 			srcPos += source->getWidth();
 			destPos += dest->getWidth();
 		}
+
 	}
 }
 
diff --git a/engines/gob/game_v2.cpp b/engines/gob/game_v2.cpp
index ff444f4a69..e783f5bfb5 100644
--- a/engines/gob/game_v2.cpp
+++ b/engines/gob/game_v2.cpp
@@ -632,13 +632,15 @@ void Game_v2::collisionsBlock(void) {
 	Collision *collArea;
 	int16 timeKey;
 	byte *savedIP;
+	byte collAreaStart;
 
 	if (_shouldPushColls)
 		pushCollisions(0);
 
-	collArea = _collisionAreas;
-	while (collArea->left != 0xFFFF)
-		collArea++;
+	collAreaStart = 0;
+	while (_collisionAreas[collAreaStart].left != 0xFFFF)
+		collAreaStart++;
+	collArea = &_collisionAreas[collAreaStart];
 
 	_shouldPushColls = 0;
 	collResId = -1;
@@ -964,7 +966,7 @@ void Game_v2::collisionsBlock(void) {
 							continue;
 
 						_activeCollResId = collPtr->id;
-						_activeCollIndex = i;
+						_activeCollIndex = i + collAreaStart;
 						_vm->_inter->storeMouse();
 						if (VAR(16) != 0)
 							break;
@@ -1006,7 +1008,7 @@ void Game_v2::collisionsBlock(void) {
 							if ((collPtr->id & 0xF000) == 0x8000)
 								if (++counter == descIndex) {
 									_activeCollResId = collPtr->id;
-									_activeCollIndex = i;
+									_activeCollIndex = i + collAreaStart;
 									break;
 								}
 						}
diff --git a/engines/gob/gob.cpp b/engines/gob/gob.cpp
index 5871151d6e..a3fe0ebbe2 100644
--- a/engines/gob/gob.cpp
+++ b/engines/gob/gob.cpp
@@ -75,6 +75,8 @@ GobEngine::GobEngine(OSystem *syst) : Engine(syst) {
 	_scenery   = 0; _draw     = 0; _util   = 0;
 	_video     = 0; _saveLoad = 0;
 
+	_pauseStart = 0;
+
 	// Setup mixer
 	_mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, ConfMan.getInt("sfx_volume"));
 	_mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, ConfMan.getInt("music_volume"));
@@ -85,12 +87,13 @@ GobEngine::GobEngine(OSystem *syst) : Engine(syst) {
 	Common::addSpecialDebugLevel(kDebugFuncOp, "FuncOpcodes", "Script FuncOpcodes debug level");
 	Common::addSpecialDebugLevel(kDebugDrawOp, "DrawOpcodes", "Script DrawOpcodes debug level");
 	Common::addSpecialDebugLevel(kDebugGobOp, "GoblinOpcodes", "Script GoblinOpcodes debug level");
-	Common::addSpecialDebugLevel(kDebugMusic, "Music", "CD, Adlib and Infogrames music debug level");
+	Common::addSpecialDebugLevel(kDebugSound, "Sound", "Sound output debug level");
 	Common::addSpecialDebugLevel(kDebugParser, "Parser", "Parser debug level");
 	Common::addSpecialDebugLevel(kDebugGameFlow, "Gameflow", "Gameflow debug level");
 	Common::addSpecialDebugLevel(kDebugFileIO, "FileIO", "File Input/Output debug level");
 	Common::addSpecialDebugLevel(kDebugSaveLoad, "SaveLoad", "Saving/Loading debug level");
 	Common::addSpecialDebugLevel(kDebugGraphics, "Graphics", "Graphics debug level");
+	Common::addSpecialDebugLevel(kDebugVideo, "Video", "IMD/VMD video debug level");
 	Common::addSpecialDebugLevel(kDebugCollisions, "Collisions", "Collisions debug level");
 
 	syst->getEventManager()->registerRandomSource(_rnd, "gob");
@@ -247,6 +250,23 @@ int GobEngine::init() {
 	return 0;
 }
 
+void GobEngine::pauseEngineIntern(bool pause) {
+	if (pause) {
+		_pauseStart = _system->getMillis();
+	} else {
+		uint32 duration = _system->getMillis() - _pauseStart;
+
+		_vm->_vidPlayer->notifyPaused(duration);
+
+		_vm->_game->_startTimeKey += duration;
+		_vm->_draw->_cursorTimeKey += duration;
+		if (_vm->_inter->_soundEndTimeKey != 0)
+			_vm->_inter->_soundEndTimeKey += duration;
+	}
+
+	_mixer->pauseAll(pause);
+}
+
 bool GobEngine::initGameParts() {
 	_noMusic = MidiDriver::parseMusicDriver(ConfMan.get("music_driver")) == MD_NULL;
 
diff --git a/engines/gob/gob.h b/engines/gob/gob.h
index 0a82bceed5..efc9718098 100644
--- a/engines/gob/gob.h
+++ b/engines/gob/gob.h
@@ -100,13 +100,14 @@ enum {
 	kDebugFuncOp = 1 << 0,
 	kDebugDrawOp = 1 << 1,
 	kDebugGobOp = 1 << 2,
-	kDebugMusic = 1 << 3,     // CD, Adlib and Infogrames music
+	kDebugSound = 1 << 3,
 	kDebugParser = 1 << 4,
 	kDebugGameFlow = 1 << 5,
 	kDebugFileIO = 1 << 6,
 	kDebugSaveLoad = 1 << 7,
 	kDebugGraphics = 1 << 8,
-	kDebugCollisions = 1 << 9
+	kDebugVideo = 1 << 9,
+	kDebugCollisions = 1 << 10
 };
 
 inline char *strncpy0(char *dest, const char *src, size_t n) {
@@ -177,9 +178,12 @@ private:
 	int32 _features;
 	Common::Platform _platform;
 
+	uint32 _pauseStart;
+
 	int go();
 	int init();
 
+	void pauseEngineIntern(bool pause);
 	bool initGameParts();
 	void deinitGameParts();
 
diff --git a/engines/gob/inter.cpp b/engines/gob/inter.cpp
index dd3fdf3684..9e5005f443 100644
--- a/engines/gob/inter.cpp
+++ b/engines/gob/inter.cpp
@@ -23,6 +23,8 @@
  *
  */
 
+#include <time.h>	// FIXME: for Inter::renewTimeInVars()
+
 #include "common/endian.h"
 
 #include "gob/gob.h"
@@ -35,8 +37,6 @@
 #include "gob/scenery.h"
 #include "gob/sound/sound.h"
 
-#include <time.h>	// FIXME: for Inter::renewTimeInVars()
-
 namespace Gob {
 
 Inter::Inter(GobEngine *vm) : _vm(vm) {
diff --git a/engines/gob/inter.h b/engines/gob/inter.h
index 582e57a2d4..e43cb4e891 100644
--- a/engines/gob/inter.h
+++ b/engines/gob/inter.h
@@ -519,6 +519,7 @@ protected:
 	virtual const char *getOpcodeFuncDesc(byte i, byte j);
 	virtual const char *getOpcodeGoblinDesc(int i);
 
+	void o4_initScreen();
 	void o4_playVmdOrMusic();
 };
 
diff --git a/engines/gob/inter_v2.cpp b/engines/gob/inter_v2.cpp
index 493efa8438..e442ec4eca 100644
--- a/engines/gob/inter_v2.cpp
+++ b/engines/gob/inter_v2.cpp
@@ -1087,6 +1087,8 @@ void Inter_v2::o2_playCDTrack() {
 }
 
 void Inter_v2::o2_waitCDTrackEnd() {
+	debugC(1, kDebugSound, "CDROM: Waiting for playback to end");
+
 	while (_vm->_sound->cdGetTrackPos() >= 0)
 		_vm->_util->longDelay(1);
 }
@@ -1431,49 +1433,17 @@ void Inter_v2::o2_initScreen() {
 	if (height > 0)
 		_vm->_video->_surfHeight = height;
 
-	if (videoMode == 0x18) {
-
-		if (_vm->_video->_surfWidth < _vm->_width)
-			_vm->_video->_screenDeltaX = (_vm->_width - _vm->_video->_surfWidth) / 2;
-		else
-			_vm->_video->_screenDeltaX = 0;
-
-		_vm->_global->_mouseMinX = _vm->_video->_screenDeltaX;
-		_vm->_global->_mouseMaxX = _vm->_video->_screenDeltaX + _vm->_video->_surfWidth - 1;
-
-
-		int16 screenHeight = _vm->_video->_surfHeight;
-
-		if (screenHeight < _vm->_height) {
-			_vm->_video->_surfHeight += offY;
-			_vm->_video->_splitStart = screenHeight;
-		} else 
-			_vm->_video->_splitStart = screenHeight - offY;
-
-			_vm->_video->_splitHeight1 = MIN<int16>(_vm->_height, screenHeight - offY);
-			_vm->_video->_splitHeight2 = offY;
-
-			if ((_vm->_video->_surfHeight + offY) < _vm->_height)
-				_vm->_video->_screenDeltaY = (_vm->_height - (screenHeight + offY)) / 2;
-			else
-				_vm->_video->_screenDeltaY = 0;
-
-			_vm->_global->_mouseMaxY = (screenHeight + _vm->_video->_screenDeltaY) - offY - 1;
-			_vm->_global->_mouseMinY = _vm->_video->_screenDeltaY;
+	_vm->_video->_splitHeight1 = MIN<int16>(_vm->_height, _vm->_video->_surfHeight - offY);
+	_vm->_video->_splitHeight2 = offY;
+	_vm->_video->_splitStart = _vm->_video->_surfHeight - offY;
 
-	} else {
-		_vm->_video->_splitHeight1 = MIN<int16>(_vm->_height, _vm->_video->_surfHeight - offY);
-		_vm->_video->_splitHeight2 = offY;
-		_vm->_video->_splitStart = _vm->_video->_surfHeight - offY;
+	_vm->_video->_screenDeltaX = 0;
+	_vm->_video->_screenDeltaY = 0;
 
-		_vm->_video->_screenDeltaX = 0;
-		_vm->_video->_screenDeltaY = 0;
-
-		_vm->_global->_mouseMinX = 0;
-		_vm->_global->_mouseMinY = 0;
-		_vm->_global->_mouseMaxX = _vm->_width;
-		_vm->_global->_mouseMaxY = _vm->_height - _vm->_video->_splitHeight2 - 1;
-	}
+	_vm->_global->_mouseMinX = 0;
+	_vm->_global->_mouseMinY = 0;
+	_vm->_global->_mouseMaxX = _vm->_width;
+	_vm->_global->_mouseMaxY = _vm->_height - _vm->_video->_splitHeight2 - 1;
 
 	_vm->_draw->closeScreen();
 	_vm->_util->clearPalette();
@@ -1532,18 +1502,27 @@ void Inter_v2::o2_scroll() {
 }
 
 void Inter_v2::o2_setScrollOffset() {
-	int16 offset;
+	int16 offsetX, offsetY;
 
-	offset = _vm->_parse->parseValExpr();
+	offsetX = _vm->_parse->parseValExpr();
+	offsetY = _vm->_parse->parseValExpr();
 
-	if (offset == -1) {
-		_vm->_parse->parseValExpr();
+	if (offsetX == -1) {
 		WRITE_VAR(2, _vm->_draw->_scrollOffsetX);
 		WRITE_VAR(3, _vm->_draw->_scrollOffsetY);
 	} else {
-		_vm->_draw->_scrollOffsetX = offset;
-		_vm->_draw->_scrollOffsetY = _vm->_parse->parseValExpr();
+		int16 screenW = _vm->_video->_surfWidth;
+		int16 screenH = _vm->_video->_surfHeight;
+
+		if (screenW > _vm->_width)
+			screenW -= _vm->_width;
+		if (screenH > _vm->_height)
+			screenH -= _vm->_height;
+
+		_vm->_draw->_scrollOffsetX = CLIP<int16>(offsetX, 0, screenW);
+		_vm->_draw->_scrollOffsetY = CLIP<int16>(offsetY, 0, screenH);
 	}
+
 	_vm->_util->setScrollOffset();
 	_noBusyWait = true;
 }
@@ -1574,6 +1553,10 @@ void Inter_v2::o2_playImd() {
 	palEnd = _vm->_parse->parseValExpr();
 	palCmd = 1 << (flags & 0x3F);
 
+	debugC(1, kDebugVideo, "Playing video \"%s\" @ %d+%d, frames %d - %d, "
+			"paletteCmd %d (%d - %d), flags %X", _vm->_global->_inter_resStr, x, y,
+			startFrame, lastFrame, palCmd, palStart, palEnd, flags);
+
 	if ((imd[0] != 0) && !_vm->_vidPlayer->primaryOpen(imd, x, y, flags)) {
 		WRITE_VAR(11, -1);
 		return;
@@ -1607,6 +1590,12 @@ void Inter_v2::o2_getImdInfo() {
 	varWidth = _vm->_parse->parseVarIndex();
 	varHeight = _vm->_parse->parseVarIndex();
 
+	// WORKAROUND: The nut rolling animation in the administration center
+	// in Woodruff is called "noixroul", but the scripts think it's "noixroule".
+	if ((_vm->getGameType() == kGameTypeWoodruff) &&
+			(!scumm_stricmp(_vm->_global->_inter_resStr, "noixroule")))
+		strcpy(_vm->_global->_inter_resStr, "noixroul");
+
 	_vm->_vidPlayer->writeVideoInfo(_vm->_global->_inter_resStr, varX, varY,
 			varFrames, varWidth, varHeight);
 }
@@ -2056,7 +2045,6 @@ void Inter_v2::o2_loadInfogramesIns(OpGobParams &params) {
 
 	strncpy0(fileName, GET_VAR_STR(varName), 15);
 	strcat(fileName, ".INS");
-	debugC(1, kDebugMusic, "Loading Infogrames instrument file \"%s\"", fileName);
 
 	_vm->_sound->infogramesLoadInstruments(fileName);
 }
@@ -2069,7 +2057,6 @@ void Inter_v2::o2_playInfogrames(OpGobParams &params) {
 
 	strncpy0(fileName, GET_VAR_STR(varName), 15);
 	strcat(fileName, ".DUM");
-	debugC(1, kDebugMusic, "Playing Infogrames music file \"%s\"", fileName);
 
 	_vm->_sound->infogramesLoadSong(fileName);
 	_vm->_sound->infogramesPlay();
diff --git a/engines/gob/inter_v4.cpp b/engines/gob/inter_v4.cpp
index 76b11752e0..fd90b731a2 100644
--- a/engines/gob/inter_v4.cpp
+++ b/engines/gob/inter_v4.cpp
@@ -29,6 +29,7 @@
 #include "gob/gob.h"
 #include "gob/inter.h"
 #include "gob/global.h"
+#include "gob/draw.h"
 #include "gob/game.h"
 #include "gob/parse.h"
 #include "gob/videoplayer.h"
@@ -279,7 +280,7 @@ void Inter_v4::setupOpcodes() {
 		{NULL, ""},
 		{NULL, ""},
 		/* 80 */
-		OPCODE(o2_initScreen),
+		OPCODE(o4_initScreen),
 		OPCODE(o2_scroll),
 		OPCODE(o2_setScrollOffset),
 		OPCODE(o4_playVmdOrMusic),
@@ -504,7 +505,7 @@ void Inter_v4::setupOpcodes() {
 		/* 30 */
 		OPCODE(o1_returnTo),
 		OPCODE(o1_loadSpriteContent),
-		OPCODE(o3_copySprite),
+		OPCODE(o1_copySprite),
 		OPCODE(o1_fillRect),
 		/* 34 */
 		OPCODE(o1_drawLine),
@@ -687,6 +688,8 @@ void Inter_v4::executeGoblinOpcode(int i, OpGobParams &params) {
 		}
 
 	if (op == NULL) {
+		warning("unimplemented opcodeGoblin: %d", i);
+
 		int16 val;
 
 		_vm->_global->_inter_execPtr -= 2;
@@ -714,6 +717,86 @@ const char *Inter_v4::getOpcodeGoblinDesc(int i) {
 	return "";
 }
 
+void Inter_v4::o4_initScreen() {
+	int16 offY;
+	int16 videoMode;
+	int16 width, height;
+
+	offY = load16();
+
+	videoMode = offY & 0xFF;
+	offY = (offY >> 8) & 0xFF;
+
+	width = _vm->_parse->parseValExpr();
+	height = _vm->_parse->parseValExpr();
+
+	_vm->_video->clearScreen();
+
+	_vm->_global->_fakeVideoMode = videoMode;
+
+	// Some versions require this
+	if (videoMode == 0xD)
+		videoMode = _vm->_mode;
+
+	if ((videoMode == _vm->_global->_videoMode) && (width == -1))
+		return;
+
+	if (width > 0)
+		_vm->_video->_surfWidth = width;
+	if (height > 0)
+		_vm->_video->_surfHeight = height;
+
+	_vm->_video->_screenDeltaX = 0;
+	if (_vm->_video->_surfWidth < _vm->_width)
+		_vm->_video->_screenDeltaX = (_vm->_width - _vm->_video->_surfWidth) / 2;
+
+	_vm->_global->_mouseMinX = _vm->_video->_screenDeltaX;
+	_vm->_global->_mouseMaxX = _vm->_video->_screenDeltaX + _vm->_video->_surfWidth - 1;
+
+	_vm->_video->_splitStart = _vm->_video->_surfHeight - offY;
+
+	_vm->_video->_splitHeight1 = MIN<int16>(_vm->_height, _vm->_video->_surfHeight);
+	_vm->_video->_splitHeight2 = offY;
+
+	if ((_vm->_video->_surfHeight + offY) < _vm->_height)
+		_vm->_video->_screenDeltaY = (_vm->_height - (_vm->_video->_surfHeight + offY)) / 2;
+	else
+		_vm->_video->_screenDeltaY = 0;
+
+	_vm->_global->_mouseMaxY = (_vm->_video->_surfHeight + _vm->_video->_screenDeltaY) - offY - 1;
+	_vm->_global->_mouseMinY = _vm->_video->_screenDeltaY;
+
+	_vm->_draw->closeScreen();
+	_vm->_util->clearPalette();
+	memset(_vm->_global->_redPalette, 0, 256);
+	memset(_vm->_global->_greenPalette, 0, 256);
+	memset(_vm->_global->_bluePalette, 0, 256);
+
+	_vm->_video->_splitSurf = 0;
+	_vm->_draw->_spritesArray[24] = 0;
+	_vm->_draw->_spritesArray[25] = 0;
+
+	_vm->_global->_videoMode = videoMode;
+	_vm->_video->initPrimary(videoMode);
+	WRITE_VAR(15, _vm->_global->_fakeVideoMode);
+
+	_vm->_global->_setAllPalette = true;
+
+	_vm->_util->setMousePos(_vm->_global->_inter_mouseX,
+			_vm->_global->_inter_mouseY);
+	_vm->_util->clearPalette();
+
+	_vm->_draw->initScreen();
+
+	_vm->_util->setScrollOffset();
+
+	if (offY > 0) {
+		_vm->_draw->_spritesArray[24] = new SurfaceDesc(videoMode, _vm->_width, offY);
+		_vm->_draw->_spritesArray[25] = new SurfaceDesc(videoMode, _vm->_width, offY);
+		_vm->_video->_splitSurf = _vm->_draw->_spritesArray[25];
+	}
+}
+
 void Inter_v4::o4_playVmdOrMusic() {
 	char fileName[128];
 	int16 x, y;
@@ -729,6 +812,12 @@ void Inter_v4::o4_playVmdOrMusic() {
 	evalExpr(0);
 	strncpy0(fileName, _vm->_global->_inter_resStr, 127);
 
+	// WORKAROUND: The nut rolling animation in the administration center
+	// in Woodruff is called "noixroul", but the scripts think it's "noixroule".
+	if ((_vm->getGameType() == kGameTypeWoodruff) &&
+			(!scumm_stricmp(fileName, "noixroule")))
+		strcpy(fileName, "noixroul");
+
 	x = _vm->_parse->parseValExpr();
 	y = _vm->_parse->parseValExpr();
 	startFrame = _vm->_parse->parseValExpr();
@@ -739,11 +828,14 @@ void Inter_v4::o4_playVmdOrMusic() {
 	palEnd = _vm->_parse->parseValExpr();
 	palCmd = 1 << (flags & 0x3F);
 
+	debugC(1, kDebugVideo, "Playing video \"%s\" @ %d+%d, frames %d - %d, "
+			"paletteCmd %d (%d - %d), flags %X", fileName, x, y, startFrame, lastFrame,
+			palCmd, palStart, palEnd, flags);
+
 	close = false;
 	if (lastFrame == -1) {
 		close = true;
 	} else if (lastFrame == -3) {
-//		warning("Woodruff Stub: Video/Music command -3: Play background video %s, %d, %d, %d, %d", fileName, startFrame, x, y, VAR_OFFSET(7872));
 
 		_vm->_mult->_objects[startFrame].pAnimData->animation = -startFrame - 1;
 
@@ -767,17 +859,16 @@ void Inter_v4::o4_playVmdOrMusic() {
 		warning("Woodruff Stub: Video/Music command -4: Play background video %s", fileName);
 		return;
 	} else if (lastFrame == -5) {
-//		warning("Woodruff Stub: Video/Music command -5: Stop background music");
 		_vm->_sound->bgStop();
 		return;
 	} else if (lastFrame == -6) {
-//		warning("Woodruff Stub: Video/Music command -6: Load background video %s", fileName);
+		return;
+	} else if (lastFrame == -7) {
 		return;
 	} else if (lastFrame == -8) {
 		warning("Woodruff Stub: Video/Music command -8: Play background video %s", fileName);
 		return;
 	} else if (lastFrame == -9) {
-//		warning("Woodruff Stub: Video/Music command -9: Play background music %s (%d-%d)", fileName, palEnd, palStart);
 		_vm->_sound->bgStop();
 		_vm->_sound->bgSetPlayMode(BackgroundAtmosphere::kPlayModeRandom);
 		_vm->_sound->bgPlay(fileName, palStart);
diff --git a/engines/gob/map_v4.cpp b/engines/gob/map_v4.cpp
index 721f040341..a3c3222213 100644
--- a/engines/gob/map_v4.cpp
+++ b/engines/gob/map_v4.cpp
@@ -113,7 +113,7 @@ void Map_v4::loadMapObjects(const char *avjFile) {
 	}
 
 	if (_widthByte == 4)
-		_mapWidth = (int16) READ_VARO_UINT16(68);
+		_mapWidth = VAR(17);
 
 	_passWidth = _mapWidth;
 
diff --git a/engines/gob/mult_v2.cpp b/engines/gob/mult_v2.cpp
index 8a299649c7..3a83ac1867 100644
--- a/engines/gob/mult_v2.cpp
+++ b/engines/gob/mult_v2.cpp
@@ -755,7 +755,7 @@ void Mult_v2::newCycleAnim(Mult_Object &animObj) {
 		animData.frame = 0;
 		if ((animData.animation < 0) && (animObj.videoSlot > 0)) {
 			_vm->_vidPlayer->slotClose(animObj.videoSlot - 1);
-				animObj.videoSlot = 0;
+			animObj.videoSlot = 0;
 		}
 		
 		break;
@@ -764,12 +764,14 @@ void Mult_v2::newCycleAnim(Mult_Object &animObj) {
 	case 7:
 		animData.frame--;
 		animData.isPaused = 1;
+/*
 		if ((animData.animation < 0) && (animObj.videoSlot > 0)) {
 			if (_vm->_vidPlayer->getFlags(animObj.videoSlot - 1) & 0x1000) {
 				_vm->_vidPlayer->slotClose(animObj.videoSlot - 1);
 				animObj.videoSlot = 0;
 			}
 		}
+*/
 		break;
 
 	case 10:
diff --git a/engines/gob/scenery.cpp b/engines/gob/scenery.cpp
index 25df5b7e71..6b52cdbbd6 100644
--- a/engines/gob/scenery.cpp
+++ b/engines/gob/scenery.cpp
@@ -100,7 +100,6 @@ int16 Scenery::loadStatic(char search) {
 	byte *extData = 0;
 	byte *dataPtr;
 	Static *ptr;
-	int16 pictDescId;
 	int16 width;
 	int16 height;
 	int16 sprResId;
@@ -143,8 +142,6 @@ int16 Scenery::loadStatic(char search) {
 	dataPtr += 2;
 
 	ptr->layers = new StaticLayer[ptr->layersCount];
-	ptr->pieces = new PieceDesc*[picsCount];
-	ptr->piecesFromExt = new bool[picsCount];
 
 	for (int i = 0; i < ptr->layersCount; i++) {
 		int16 offset = READ_LE_UINT16(dataPtr + i * 2);
@@ -166,18 +163,13 @@ int16 Scenery::loadStatic(char search) {
 		backsPtr++;
 	}
 
+	ptr->pieces = new PieceDesc*[picsCount];
+	ptr->piecesCount = new uint32[picsCount];
+
 	for (int i = 0; i < picsCount; i++) {
-		pictDescId = _vm->_inter->load16();
+		int16 pictDescId = _vm->_inter->load16();
 
-		if (pictDescId >= 30000) {
-			ptr->pieces[i] =
-				(PieceDesc *) _vm->_game->loadExtData(pictDescId, 0, 0);
-			ptr->piecesFromExt[i] = true;
-		} else {
-			ptr->pieces[i] =
-				(PieceDesc *) _vm->_game->loadTotResource(pictDescId);
-			ptr->piecesFromExt[i] = false;
-		}
+		loadPieces(pictDescId, ptr->pieces[i], ptr->piecesCount[i]);
 
 		width = _vm->_inter->load16();
 		height = _vm->_inter->load16();
@@ -224,8 +216,7 @@ void Scenery::freeStatic(int16 index) {
 		return;
 
 	for (int i = 0; i < _staticPictCount[index]; i++) {
-		if (_statics[index].piecesFromExt[i])
-			delete[] _statics[index].pieces[i];
+		delete[] _statics[index].pieces[i];
 
 		spr = _staticPictToSprite[index * 7 + i];
 		_spriteRefs[spr]--;
@@ -239,7 +230,7 @@ void Scenery::freeStatic(int16 index) {
 		delete[] _statics[index].layers[i].planes;
 	delete[] _statics[index].layers;
 	delete[] _statics[index].pieces;
-	delete[] _statics[index].piecesFromExt;
+	delete[] _statics[index].piecesCount;
 
 	_statics[index].layersCount = 0;
 	_staticPictCount[index] = -1;
@@ -253,8 +244,8 @@ void Scenery::renderStatic(int16 scenery, int16 layer) {
 	int16 order;
 	int16 plane;
 
-	int16 pieceIndex;
-	int16 pictIndex;
+	uint16 pieceIndex;
+	uint16 pictIndex;
 
 	int16 left;
 	int16 right;
@@ -286,12 +277,21 @@ void Scenery::renderStatic(int16 scenery, int16 layer) {
 			pieceIndex = planePtr->pieceIndex;
 			pictIndex = planePtr->pictIndex - 1;
 
+			if (pictIndex >= _staticPictCount[scenery])
+				continue;
+
+			if (!ptr->pieces || !ptr->pieces[pictIndex])
+				continue;
+
+			if (pieceIndex >= ptr->piecesCount[pictIndex])
+				continue;
+
 			_vm->_draw->_destSpriteX = planePtr->destX;
 			_vm->_draw->_destSpriteY = planePtr->destY;
-			left = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].left);
-			right = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].right);
-			top = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].top);
-			bottom = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].bottom);
+			left = ptr->pieces[pictIndex][pieceIndex].left;
+			right = ptr->pieces[pictIndex][pieceIndex].right;
+			top = ptr->pieces[pictIndex][pieceIndex].top;
+			bottom = ptr->pieces[pictIndex][pieceIndex].bottom;
 
 			_vm->_draw->_sourceSurface =
 			    _staticPictToSprite[scenery * 7 + pictIndex];
@@ -313,8 +313,8 @@ void Scenery::updateStatic(int16 orderFrom, byte index, byte layer) {
 	int16 planeCount;
 	int16 order;
 	int16 plane;
-	int16 pieceIndex;
-	int16 pictIndex;
+	uint16 pieceIndex;
+	uint16 pictIndex;
 
 	int16 left;
 	int16 right;
@@ -338,16 +338,22 @@ void Scenery::updateStatic(int16 orderFrom, byte index, byte layer) {
 			pieceIndex = planePtr->pieceIndex;
 			pictIndex = planePtr->pictIndex - 1;
 
-			if ((pictIndex >= _staticPictCount[index]) || (!pictPtr[pictIndex]))
+			if (pictIndex >= _staticPictCount[index])
+				continue;
+
+			if (!pictPtr || !pictPtr[pictIndex])
+				continue;
+
+			if (pieceIndex >= _statics[index].piecesCount[pictIndex])
 				continue;
 
 			_vm->_draw->_destSpriteX = planePtr->destX;
 			_vm->_draw->_destSpriteY = planePtr->destY;
 
-			left = FROM_LE_16(pictPtr[pictIndex][pieceIndex].left);
-			right = FROM_LE_16(pictPtr[pictIndex][pieceIndex].right);
-			top = FROM_LE_16(pictPtr[pictIndex][pieceIndex].top);
-			bottom = FROM_LE_16(pictPtr[pictIndex][pieceIndex].bottom);
+			left = pictPtr[pictIndex][pieceIndex].left;
+			right = pictPtr[pictIndex][pieceIndex].right;
+			top = pictPtr[pictIndex][pieceIndex].top;
+			bottom = pictPtr[pictIndex][pieceIndex].bottom;
 
 			if (_vm->_draw->_destSpriteX > _toRedrawRight)
 				continue;
@@ -418,7 +424,6 @@ int16 Scenery::loadAnim(char search) {
 	byte *extData;
 	byte *dataPtr;
 	Animation *ptr;
-	int16 pictDescId;
 	int16 width;
 	int16 height;
 	int16 sprResId;
@@ -457,9 +462,6 @@ int16 Scenery::loadAnim(char search) {
 	dataPtr += 2;
 
 	ptr->layers = new AnimLayer[ptr->layersCount];
-	ptr->pieces = new PieceDesc*[picsCount];
-	ptr->piecesFromExt = new bool[picsCount];
-	ptr->sizes = new uint16[picsCount];
 
 	for (i = 0; i < ptr->layersCount; i++) {
 		int16 offset = READ_LE_UINT16(dataPtr + i * 2);
@@ -495,23 +497,13 @@ int16 Scenery::loadAnim(char search) {
 		}
 	}
 
+	ptr->pieces = new PieceDesc*[picsCount];
+	ptr->piecesCount = new uint32[picsCount];
+
 	for (i = 0; i < picsCount; i++) {
-		pictDescId = _vm->_inter->load16();
-		if (pictDescId >= 30000) {
-			uint32 size;
-
-			ptr->pieces[i] =
-				(PieceDesc *) _vm->_game->loadExtData(pictDescId, 0, 0, &size);
-			ptr->piecesFromExt[i] = true;
-			ptr->sizes[i] = size / 8;
-		} else {
-			int16 size;
+		int16 pictDescId = _vm->_inter->load16();
 
-			ptr->pieces[i] =
-				(PieceDesc *) _vm->_game->loadTotResource(pictDescId, &size);
-			ptr->piecesFromExt[i] = false;
-			ptr->sizes[i] = size / 8;
-		}
+		loadPieces(pictDescId, ptr->pieces[i], ptr->piecesCount[i]);
 
 		width = _vm->_inter->load16();
 		height = _vm->_inter->load16();
@@ -557,8 +549,7 @@ void Scenery::freeAnim(int16 index) {
 		return;
 
 	for (int i = 0; i < _animPictCount[index]; i++) {
-		if (_animations[index].piecesFromExt[i])
-			delete[] _animations[index].pieces[i];
+		delete[] _animations[index].pieces[i];
 
 		spr = _animPictToSprite[index * 7 + i];
 		_spriteRefs[spr]--;
@@ -572,8 +563,7 @@ void Scenery::freeAnim(int16 index) {
 		delete[] _animations[index].layers[i].frames;
 	delete[] _animations[index].layers;
 	delete[] _animations[index].pieces;
-	delete[] _animations[index].piecesFromExt;
-	delete[] _animations[index].sizes;
+	delete[] _animations[index].piecesCount;
 
 	_animPictCount[index] = 0;
 }
@@ -623,8 +613,8 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 
 		Mult::Mult_Object &obj = _vm->_mult->_objects[-animation - 1];
 
-		if (!_vm->_vidPlayer->slotIsOpen(obj.videoSlot - 1)) {
-			_toRedrawLeft = -1234;
+		if ((obj.videoSlot == 0) || !_vm->_vidPlayer->slotIsOpen(obj.videoSlot - 1)) {
+			_toRedrawLeft = -12345;
 			return;
 		}
 
@@ -736,7 +726,7 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 
 		}
 
-		if (flags & 4) {
+		if (!(flags & 4)) {
 			_animLeft = _toRedrawLeft = left;
 			_animTop = _toRedrawTop = top;
 			_animRight = _toRedrawRight = right;
@@ -824,20 +814,19 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 
 		pictIndex = (pictIndex & 15) - 1;
 
-		if ((pictIndex == 0xFFFF) || (_animPictCount[animation] <= pictIndex)) {
-			warning("Scenery::updateAnim: pictIndex out of range");
-			return;
-		}
+		if (pictIndex >= _animPictCount[animation])
+			continue;
 
-		if (_animations[animation].sizes[pictIndex] <= pieceIndex) {
-			warning("Scenery::updateAnim: pieceIndex out of range");
+		if (!pictPtr[pictIndex])
+			continue;
+
+		if (pieceIndex >= _animations[animation].piecesCount[pictIndex])
 			continue;
-		}
 
-		left = READ_LE_UINT16(&pictPtr[pictIndex][pieceIndex].left);
-		right = READ_LE_UINT16(&pictPtr[pictIndex][pieceIndex].right);
-		top = READ_LE_UINT16(&pictPtr[pictIndex][pieceIndex].top);
-		bottom = READ_LE_UINT16(&pictPtr[pictIndex][pieceIndex].bottom);
+		left = pictPtr[pictIndex][pieceIndex].left;
+		right = pictPtr[pictIndex][pieceIndex].right;
+		top = pictPtr[pictIndex][pieceIndex].top;
+		bottom = pictPtr[pictIndex][pieceIndex].bottom;
 
 		if (flags & 2) {
 			if (destX < _vm->_mult->_animLeft) {
@@ -958,4 +947,42 @@ Scenery::AnimLayer *Scenery::getAnimLayer(uint16 index, uint16 layer) {
 	return &_animations[index].layers[layer];
 }
 
+void Scenery::loadPieces(int16 pictDescId, PieceDesc *&pieceDesc, uint32 &piecesCount) {
+	byte *data;
+	uint32 size;
+	bool fromExt = false;
+
+	if (pictDescId >= 30000) {
+		fromExt = true;
+
+		uint32 eSize;
+
+		data = _vm->_game->loadExtData(pictDescId, 0, 0, &eSize);
+		size = eSize;
+	} else {
+		int16 tSize;
+
+		data = _vm->_game->loadTotResource(pictDescId, &tSize);
+		size = tSize;
+	}
+
+	if (!data)
+		error("Scenery::loadPieces(): Can't load pictDescId %d", pictDescId);
+
+	piecesCount = size / 8;
+	pieceDesc = new PieceDesc[piecesCount];
+
+	Common::MemoryReadStream pieceData(data, size);
+
+	for (uint32 i = 0; i < piecesCount; i++) {
+		pieceDesc[i].left = (int16) pieceData.readUint16LE();
+		pieceDesc[i].right = (int16) pieceData.readUint16LE();
+		pieceDesc[i].top = (int16) pieceData.readUint16LE();
+		pieceDesc[i].bottom = (int16) pieceData.readUint16LE();
+	}
+
+	if (fromExt)
+		delete[] data;
+}
+
 } // End of namespace Gob
diff --git a/engines/gob/scenery.h b/engines/gob/scenery.h
index 03ef84e16d..21bf29deda 100644
--- a/engines/gob/scenery.h
+++ b/engines/gob/scenery.h
@@ -34,10 +34,10 @@ public:
 #include "common/pack-start.h"	// START STRUCT PACKING
 
 	struct PieceDesc {
-		int16 left;		//NOTE:
-		int16 right;		//These are stored in Little Endian format
-		int16 top;		//And should be converted by client code when accessed
-		int16 bottom;		//i.e. use FROM_LE_16()
+		int16 left;
+		int16 right;
+		int16 top;
+		int16 bottom;
 	} PACKED_STRUCT;
 
 	struct StaticPlane {
@@ -82,19 +82,16 @@ public:
 		int16 layersCount;
 		StaticLayer *layers;
 		PieceDesc **pieces;
-		bool *piecesFromExt;
-		Static() : layersCount(0), layers(0), pieces(0),
-				   piecesFromExt(0) {}
+		uint32 *piecesCount;
+		Static() : layersCount(0), layers(0), pieces(0), piecesCount(0) {}
 	};
 
 	struct Animation {
 		int16 layersCount;
 		AnimLayer *layers;
 		PieceDesc **pieces;
-		bool *piecesFromExt;
-		uint16 *sizes;
-		Animation() : layersCount(0), layers(0), pieces(0),
-			              piecesFromExt(0) {}
+		uint32 *piecesCount;
+		Animation() : layersCount(0), layers(0), pieces(0), piecesCount(0) {}
 	};
 
 	int16 _curStatic;
@@ -151,6 +148,8 @@ protected:
 
 	GobEngine *_vm;
 
+	void loadPieces(int16 pictDescId, PieceDesc *&pieceDesc, uint32 &piecesCount);
+
 	void updateStatic(int16 orderFrom, byte index, byte layer);
 };
 
diff --git a/engines/gob/sound/adlib.cpp b/engines/gob/sound/adlib.cpp
index fb0d9d58c1..b3d392ad1e 100644
--- a/engines/gob/sound/adlib.cpp
+++ b/engines/gob/sound/adlib.cpp
@@ -125,7 +125,7 @@ int AdLib::readBuffer(int16 *buffer, const int numSamples) {
 }
 
 void AdLib::writeOPL(byte reg, byte val) {
-	debugC(6, kDebugMusic, "writeOPL(%02X, %02X)", reg, val);
+	debugC(6, kDebugSound, "writeOPL(%02X, %02X)", reg, val);
 	OPLWriteReg(_opl, reg, val);
 }
 
diff --git a/engines/gob/sound/cdrom.cpp b/engines/gob/sound/cdrom.cpp
index f3bc70807e..eef8025cc2 100644
--- a/engines/gob/sound/cdrom.cpp
+++ b/engines/gob/sound/cdrom.cpp
@@ -83,8 +83,6 @@ void CDROM::startTrack(const char *trackName) {
 	if (!_LICbuffer)
 		return;
 
-	debugC(1, kDebugMusic, "CDROM::startTrack(%s)", trackName);
-
 	byte *matchPtr = getTrackBuffer(trackName);
 	if (!matchPtr) {
 		warning("Track \"%s\" not found", trackName);
@@ -114,8 +112,6 @@ void CDROM::play(uint32 from, uint32 to) {
 	// HSG encodes frame information into a double word:
 	// minute multiplied by 4500, plus second multiplied by 75,
 	// plus frame, minus 150
-	debugC(1, kDebugMusic, "CDROM::play(%d, %d)", from, to);
-
 	AudioCD.play(1, 1, from, to - from + 1);
 	_cdPlaying = true;
 }
@@ -159,8 +155,6 @@ void CDROM::stopPlaying() {
 }
 
 void CDROM::stop() {
-	debugC(1, kDebugMusic, "CDROM::stop()");
-
 	_curTrackBuffer = 0;
 	AudioCD.stop();
 	_cdPlaying = false;
diff --git a/engines/gob/sound/sound.cpp b/engines/gob/sound/sound.cpp
index 63b74ca36f..a90afe0e27 100644
--- a/engines/gob/sound/sound.cpp
+++ b/engines/gob/sound/sound.cpp
@@ -56,6 +56,8 @@ Sound::~Sound() {
 	delete _blaster;
 	delete _adlib;
 	delete _infogrames;
+	delete _cdrom;
+	delete _bgatmos;
 
 	for (int i = 0; i < kSoundsCount; i++)
 		_sounds[i].free();
@@ -92,6 +94,8 @@ bool Sound::sampleLoad(SoundDesc *sndDesc, const char *fileName, bool tryExist)
 	if (!sndDesc)
 		return false;
 
+	debugC(2, kDebugSound, "Loading sample \"%s\"", fileName);
+
 	int16 handle = _vm->_dataIO->openData(fileName);
 	if (handle < 0) {
 		warning("Can't open sample file \"%s\"", fileName);
@@ -137,6 +141,8 @@ void Sound::speakerOn(int16 frequency, int32 length) {
 	if (!_pcspeaker)
 		return;
 
+	debugC(1, kDebugSound, "PCSpeaker: Playing tone (%d, %d)", frequency, length);
+
 	_pcspeaker->speakerOn(frequency, length);
 }
 
@@ -144,6 +150,8 @@ void Sound::speakerOff() {
 	if (!_pcspeaker)
 		return;
 
+	debugC(1, kDebugSound, "PCSpeaker: Stopping tone");
+
 	_pcspeaker->speakerOff();
 }
 
@@ -158,6 +166,8 @@ bool Sound::infogramesLoadInstruments(const char *fileName) {
 	if (!_infogrames)
 		return false;
 
+	debugC(1, kDebugSound, "Infogrames: Loading instruments \"%s\"", fileName);
+
 	return _infogrames->loadInstruments(fileName);
 }
 
@@ -165,6 +175,8 @@ bool Sound::infogramesLoadSong(const char *fileName) {
 	if (!_infogrames)
 		return false;
 
+	debugC(1, kDebugSound, "Infogrames: Loading song \"%s\"", fileName);
+
 	return _infogrames->loadSong(fileName);
 }
 
@@ -172,6 +184,8 @@ void Sound::infogramesPlay() {
 	if (!_infogrames)
 		return;
 
+	debugC(1, kDebugSound, "Infogrames: Starting playback");
+
 	_infogrames->play();
 }
 
@@ -179,6 +193,8 @@ void Sound::infogramesStop() {
 	if (!_infogrames)
 		return;
 
+	debugC(1, kDebugSound, "Infogrames: Stopping playback");
+
 	_infogrames->stop();
 }
 
@@ -186,6 +202,8 @@ bool Sound::adlibLoad(const char *fileName) {
 	if (!_adlib)
 		return false;
 
+	debugC(1, kDebugSound, "Adlib: Loading data (\"%s\")", fileName);
+
 	return _adlib->load(fileName);
 }
 
@@ -193,6 +211,8 @@ bool Sound::adlibLoad(byte *data, uint32 size, int index) {
 	if (!_adlib)
 		return false;
 
+	debugC(1, kDebugSound, "Adlib: Loading data (%d)", index);
+
 	return _adlib->load(data, size, index);
 }
 
@@ -200,6 +220,8 @@ void Sound::adlibUnload() {
 	if (!_adlib)
 		return;
 
+	debugC(1, kDebugSound, "Adlib: Unloading data");
+
 	_adlib->unload();
 }
 
@@ -207,7 +229,7 @@ void Sound::adlibPlayTrack(const char *trackname) {
 	if (!_adlib || _adlib->isPlaying())
 		return;
 
-	debugC(1, kDebugMusic, "Adlib::playTrack(%s)", trackname);
+	debugC(1, kDebugSound, "Adlib: Playing track \"%s\"", trackname);
 
 	_adlib->unload();
 	_adlib->load(trackname);
@@ -235,6 +257,8 @@ void Sound::adlibPlay() {
 	if (!_adlib)
 		return;
 
+	debugC(1, kDebugSound, "Adlib: Starting playback");
+
 	_adlib->startPlay();
 }
 
@@ -242,6 +266,8 @@ void Sound::adlibStop() {
 	if (!_adlib)
 		return;
 
+	debugC(1, kDebugSound, "Adlib: Stopping playback");
+
 	_adlib->stopPlay();
 }
 
@@ -278,6 +304,9 @@ void Sound::blasterPlay(SoundDesc *sndDesc, int16 repCount,
 	if (!_blaster || !sndDesc)
 		return;
 
+	debugC(1, kDebugSound, "SoundBlaster: Playing sample (%d, %d, %d)",
+			repCount, frequency, fadeLength);
+
 	_blaster->playSample(*sndDesc, repCount, frequency, fadeLength);
 }
 
@@ -285,6 +314,8 @@ void Sound::blasterStop(int16 fadeLength, SoundDesc *sndDesc) {
 	if (!_blaster)
 		return;
 
+	debugC(1, kDebugSound, "SoundBlaster: Stopping playback");
+
 	_blaster->stopSound(fadeLength, sndDesc);
 }
 
@@ -293,6 +324,9 @@ void Sound::blasterPlayComposition(int16 *composition, int16 freqVal,
 	if (!_blaster)
 		return;
 
+	debugC(1, kDebugSound, "SoundBlaster: Playing composition (%d, %d)",
+			freqVal, sndCount);
+
 	blasterWaitEndPlay();
 	_blaster->stopComposition();
 
@@ -306,6 +340,8 @@ void Sound::blasterStopComposition() {
 	if (!_blaster)
 		return;
 
+	debugC(1, kDebugSound, "SoundBlaster: Stopping composition");
+
 	_blaster->stopComposition();
 }
 
@@ -327,6 +363,8 @@ void Sound::blasterWaitEndPlay(bool interruptible, bool stopComp) {
 	if (!_blaster)
 		return;
 
+	debugC(1, kDebugSound, "SoundBlaster: Waiting for playback to end");
+
 	if (stopComp)
 		_blaster->endComposition();
 
@@ -345,6 +383,8 @@ void Sound::cdLoadLIC(const char *fname) {
 	if (!_cdrom)
 		return;
 
+	debugC(1, kDebugSound, "CDROM: Loading LIC \"%s\"", fname);
+
 	int handle = _vm->_dataIO->openData(fname);
 
 	if (handle == -1)
@@ -366,6 +406,8 @@ void Sound::cdUnloadLIC() {
 	if (!_cdrom)
 		return;
 
+	debugC(1, kDebugSound, "CDROM: Unloading LIC");
+
 	_cdrom->freeLICBuffer();
 }
 
@@ -400,6 +442,9 @@ void Sound::cdPlayBgMusic() {
 
 	for (int i = 0; i < ARRAYSIZE(tracks); i++)
 		if (!scumm_stricmp(_vm->_game->_curTotFile, tracks[i][0])) {
+			debugC(1, kDebugSound, "CDROM: Playing background music \"%s\" (\"%s\")",
+					tracks[i][1], _vm->_game->_curTotFile);
+
 			_cdrom->startTrack(tracks[i][1]);
 			break;
 		}
@@ -422,6 +467,9 @@ void Sound::cdPlayMultMusic() {
 	int language = _vm->_global->_language <= 4 ? _vm->_global->_language : 2;
 	for (int i = 0; i < ARRAYSIZE(tracks); i++)
 		if (!scumm_stricmp(_vm->_game->_curTotFile, tracks[i][0])) {
+			debugC(1, kDebugSound, "CDROM: Playing mult music \"%s\" (\"%s\")",
+					tracks[i][language + 1], _vm->_game->_curTotFile);
+
 			_cdrom->startTrack(tracks[i][language + 1]);
 			break;
 		}
@@ -431,6 +479,7 @@ void Sound::cdPlay(const char *trackName) {
 	if (!_cdrom)
 		return;
 
+	debugC(1, kDebugSound, "CDROM: Playing track \"%s\"", trackName);
 	_cdrom->startTrack(trackName);
 }
 
@@ -438,6 +487,7 @@ void Sound::cdStop() {
 	if (!_cdrom)
 		return;
 
+	debugC(1, kDebugSound, "CDROM: Stopping playback");
 	_cdrom->stopPlaying();
 }
 
@@ -473,6 +523,8 @@ void Sound::bgPlay(const char *base, int count) {
 	if (!_bgatmos)
 		return;
 
+	debugC(1, kDebugSound, "BackgroundAtmosphere: Playing \"%s\" (%d)", base, count);
+
 	_bgatmos->stop();
 	_bgatmos->queueClear();
 
@@ -495,6 +547,8 @@ void Sound::bgStop() {
 	if (!_bgatmos)
 		return;
 
+	debugC(1, kDebugSound, "BackgroundAtmosphere: Stopping playback");
+
 	_bgatmos->stop();
 	_bgatmos->queueClear();
 }
@@ -510,6 +564,8 @@ void Sound::bgShade() {
 	if (!_bgatmos)
 		return;
 
+	debugC(1, kDebugSound, "BackgroundAtmosphere: Shading playback");
+
 	_bgatmos->shade();
 }
 
@@ -517,6 +573,8 @@ void Sound::bgUnshade() {
 	if (!_bgatmos)
 		return;
 
+	debugC(1, kDebugSound, "BackgroundAtmosphere: Unshading playback");
+
 	_bgatmos->unshade();
 }
 
diff --git a/engines/gob/video.cpp b/engines/gob/video.cpp
index 3034a38079..453613d1ae 100644
--- a/engines/gob/video.cpp
+++ b/engines/gob/video.cpp
@@ -86,10 +86,14 @@ void SurfaceDesc::swap(SurfaceDesc &surf) {
 Video::Video(GobEngine *vm) : _vm(vm) {
 	_doRangeClamp = false;
 	_videoDriver = 0;
+
 	_surfWidth = 320;
 	_surfHeight = 200;
+
 	_scrollOffsetX = 0;
 	_scrollOffsetY = 0;
+
+	_splitSurf = 0;
 	_splitHeight1 = 200;
 	_splitHeight2 = 0;
 	_splitStart = 0;
@@ -178,13 +182,25 @@ void Video::retrace(bool mouse) {
 		int screenOffset = _scrollOffsetY * _surfWidth + _scrollOffsetX;
 		int screenX = _screenDeltaX;
 		int screenY = _screenDeltaY;
-		int screenWidth = MIN<int>(_surfWidth, _vm->_width);
-		int screenHeight = MIN<int>(_splitHeight1, _vm->_height - _splitHeight2 - _screenDeltaY);
+		int screenWidth = MIN<int>(_surfWidth - _scrollOffsetX, _vm->_width);
+		int screenHeight = MIN<int>(_surfHeight - _splitHeight2 - _scrollOffsetY, _vm->_height);
 
 		g_system->copyRectToScreen(_vm->_global->_primarySurfDesc->getVidMem() + screenOffset,
 				_surfWidth, screenX, screenY, screenWidth, screenHeight);
 
-		if (_splitHeight2 > 0) {
+		if (_splitSurf) {
+
+			screenOffset = 0;
+			screenX = 0;
+			screenY = _vm->_height - _splitSurf->getHeight();
+			screenWidth = MIN<int>(_vm->_width, _splitSurf->getWidth());
+			screenHeight = _splitSurf->getHeight();
+
+			g_system->copyRectToScreen(_splitSurf->getVidMem() + screenOffset,
+					_splitSurf->getWidth(), screenX, screenY, screenWidth, screenHeight);
+
+		} else if (_splitHeight2 > 0) {
+
 			screenOffset = _splitStart * _surfWidth;
 			screenX = 0;
 			screenY = _vm->_height - _splitHeight2;
@@ -193,6 +209,7 @@ void Video::retrace(bool mouse) {
 
 			g_system->copyRectToScreen(_vm->_global->_primarySurfDesc->getVidMem() + screenOffset,
 					_surfWidth, screenX, screenY, screenWidth, screenHeight);
+
 		}
 
 		g_system->updateScreen();
diff --git a/engines/gob/video.h b/engines/gob/video.h
index 1ab513205b..1338885588 100644
--- a/engines/gob/video.h
+++ b/engines/gob/video.h
@@ -98,13 +98,18 @@ public:
 	};
 
 	bool _doRangeClamp;
+
 	int16 _surfWidth;
 	int16 _surfHeight;
+
 	int16 _scrollOffsetX;
 	int16 _scrollOffsetY;
+
+	SurfaceDesc::Ptr _splitSurf;
 	int16 _splitHeight1;
 	int16 _splitHeight2;
 	int16 _splitStart;
+
 	int16 _screenDeltaX;
 	int16 _screenDeltaY;
 
diff --git a/engines/gob/videoplayer.cpp b/engines/gob/videoplayer.cpp
index c435136b75..4a337d48b4 100644
--- a/engines/gob/videoplayer.cpp
+++ b/engines/gob/videoplayer.cpp
@@ -348,15 +348,30 @@ int VideoPlayer::slotOpen(const char *videoFile, Type which) {
 	video->getVideo()->setVideoMemory();
 	video->getVideo()->enableSound(*_vm->_mixer);
 
-	_videoSlots.push_back(video);
+	int slot = getNextFreeSlot();
+
+	_videoSlots[slot] = video;
 
 	WRITE_VAR(7, video->getVideo()->getFramesCount());
 
-	return _videoSlots.size() - 1;
+	return slot;
+}
+
+int VideoPlayer::getNextFreeSlot() {
+	uint slot;
+
+	for (slot = 0; slot < _videoSlots.size(); slot++)
+		if (!_videoSlots[slot])
+			break;
+
+	if (slot == _videoSlots.size())
+		_videoSlots.push_back(0);
+	
+	return slot;
 }
 
 void VideoPlayer::slotPlay(int slot, int16 frame) {
-	if ((slot < 0) || (((uint) slot) >= _videoSlots.size()))
+	if ((slot < 0) || (((uint) slot) >= _videoSlots.size()) || !_videoSlots[slot])
 		return;
 
 	CoktelVideo &video = *(_videoSlots[slot]->getVideo());
@@ -377,18 +392,18 @@ void VideoPlayer::slotPlay(int slot, int16 frame) {
 }
 
 void VideoPlayer::slotClose(int slot) {
-	if ((slot < 0) || (((uint) slot) >= _videoSlots.size()))
+	if ((slot < 0) || (((uint) slot) >= _videoSlots.size()) || !_videoSlots[slot])
 		return;
 
 	delete _videoSlots[slot];
-	_videoSlots.remove_at(slot);
+	_videoSlots[slot] = 0;
 }
 
 void VideoPlayer::slotCopyFrame(int slot, byte *dest,
 		uint16 left, uint16 top, uint16 width, uint16 height,
 		uint16 x, uint16 y, uint16 pitch, int16 transp) {
 
-	if ((slot < 0) || (((uint) slot) >= _videoSlots.size()))
+	if ((slot < 0) || (((uint) slot) >= _videoSlots.size()) || !_videoSlots[slot])
 		return;
 
 	_videoSlots[slot]->getVideo()->copyCurrentFrame(dest,
@@ -396,14 +411,14 @@ void VideoPlayer::slotCopyFrame(int slot, byte *dest,
 }
 
 void VideoPlayer::slotCopyPalette(int slot, int16 palStart, int16 palEnd) {
-	if ((slot < 0) || (((uint) slot) >= _videoSlots.size()))
+	if ((slot < 0) || (((uint) slot) >= _videoSlots.size()) || !_videoSlots[slot])
 		return;
 
 	copyPalette(*(_videoSlots[slot]->getVideo()), palStart, palEnd);
 }
 
 void VideoPlayer::slotWaitEndFrame(int slot, bool onlySound) {
-	if ((slot < 0) || (((uint) slot) >= _videoSlots.size()))
+	if ((slot < 0) || (((uint) slot) >= _videoSlots.size()) || !_videoSlots[slot])
 		return;
 
 	CoktelVideo &video = *(_videoSlots[slot]->getVideo());
@@ -413,7 +428,7 @@ void VideoPlayer::slotWaitEndFrame(int slot, bool onlySound) {
 }
 
 bool VideoPlayer::slotIsOpen(int slot) const {
-	if ((slot >= 0) && (((uint) slot) < _videoSlots.size()))
+	if ((slot >= 0) && (((uint) slot) < _videoSlots.size()) && _videoSlots[slot])
 		return true;
 
 	return false;
@@ -423,7 +438,7 @@ const VideoPlayer::Video *VideoPlayer::getVideoBySlot(int slot) const {
 	if (slot < 0) {
 		if (_primaryVideo->isOpen())
 			return _primaryVideo;
-	} else if (((uint) slot) < _videoSlots.size())
+	} else if (((uint) slot) < _videoSlots.size() && _videoSlots[slot])
 		return _videoSlots[slot];
 
 	return 0;
@@ -527,7 +542,7 @@ bool VideoPlayer::doPlay(int16 frame, int16 breakKey,
 		_vm->_draw->_noInvalidated = true;
 	}
 
-	if (state.flags & CoktelVideo::kStatePalette) {
+	if ((state.flags & CoktelVideo::kStatePalette) && (palCmd > 1)) {
 		copyPalette(*(_primaryVideo->getVideo()), palStart, palEnd);
 
 		if (!_backSurf)
@@ -587,20 +602,19 @@ void VideoPlayer::writeVideoInfo(const char *videoFile, int16 varX, int16 varY,
 	if (primaryOpen(videoFile)) {
 		int16 x, y, width, height;
 
-		if ((VAR_OFFSET(varX) != 0xFFFFFFFF) ||
-		    !_primaryVideo->getVideo()->getAnchor(1, 2, x, y, width, height)) {
+		x = _primaryVideo->getVideo()->getX();
+		y = _primaryVideo->getVideo()->getY();
+		width = _primaryVideo->getVideo()->getWidth();
+		height = _primaryVideo->getVideo()->getHeight();
 
-			x = _primaryVideo->getVideo()->getX();
-			y = _primaryVideo->getVideo()->getY();
-			width = _primaryVideo->getVideo()->getWidth();
-			height = _primaryVideo->getVideo()->getHeight();
-		}
+		if (VAR_OFFSET(varX) == 0xFFFFFFFF)
+			_primaryVideo->getVideo()->getAnchor(1, 2, x, y, width, height);
 
 		WRITE_VAR_OFFSET(varX, x);
 		WRITE_VAR_OFFSET(varY, y);
 		WRITE_VAR_OFFSET(varFrames, _primaryVideo->getVideo()->getFramesCount());
 		WRITE_VAR_OFFSET(varWidth, width);
-		WRITE_VAR_OFFSET(varHeight, height);
+		WRITE_VARO_UINT16(varHeight & 0xFFFFFFFC, height);
 
 		primaryClose();
 	} else {
@@ -619,4 +633,13 @@ void VideoPlayer::evalBgShading(CoktelVideo &video) {
 		_vm->_sound->bgUnshade();
 }
 
+void VideoPlayer::notifyPaused(uint32 duration) {
+	if (_primaryVideo->isOpen())
+		_primaryVideo->getVideo()->notifyPaused(duration);
+
+	for (uint i = 0; i < _videoSlots.size(); i++)
+		if (_videoSlots[i] && _videoSlots[i]->isOpen())
+			_videoSlots[i]->getVideo()->notifyPaused(duration);
+}
+
 } // End of namespace Gob
diff --git a/engines/gob/videoplayer.h b/engines/gob/videoplayer.h
index 29531f7ce2..b7aa7313b0 100644
--- a/engines/gob/videoplayer.h
+++ b/engines/gob/videoplayer.h
@@ -83,6 +83,8 @@ public:
 	void writeVideoInfo(const char *videoFile, int16 varX, int16 varY,
 			int16 varFrames, int16 varWidth, int16 varHeight);
 
+	void notifyPaused(uint32 duration);
+
 private:
 	class Video {
 		public:
@@ -128,6 +130,8 @@ private:
 
 	const Video *getVideoBySlot(int slot = -1) const;
 
+	int getNextFreeSlot();
+
 	void copyPalette(CoktelVideo &video, int16 palStart = -1, int16 palEnd = -1);
 	bool doPlay(int16 frame, int16 breakKey,
 			uint16 palCmd, int16 palStart, int16 palEnd,
diff --git a/engines/kyra/animator_hof.cpp b/engines/kyra/animator_hof.cpp
index 1192145530..c5d44d10af 100644
--- a/engines/kyra/animator_hof.cpp
+++ b/engines/kyra/animator_hof.cpp
@@ -127,12 +127,8 @@ void KyraEngine_HoF::updateItemAnimations() {
 		return;	
 
 	const ItemAnimData_v2 *s = &_itemAnimData[_nextAnimItem];
-	ActiveItemAnim *a = &_activeItemAnim[_nextAnimItem];
-	
-	if (++_nextAnimItem == 14) {
-		_nextAnimItem = 0;
-		return;
-	}
+	ActiveItemAnim *a = &_activeItemAnim[_nextAnimItem];	
+	_nextAnimItem = ++_nextAnimItem % _itemAnimDataSize;
 
 	uint32 ctime = _system->getMillis();
 	if (ctime < a->nextFrame)
diff --git a/engines/kyra/animator_mr.cpp b/engines/kyra/animator_mr.cpp
index f04ca0345d..9702499fe7 100644
--- a/engines/kyra/animator_mr.cpp
+++ b/engines/kyra/animator_mr.cpp
@@ -205,11 +205,7 @@ void KyraEngine_MR::updateItemAnimations() {
 
 	const ItemAnimData_v2 *s = &_itemAnimData[_nextAnimItem];
 	ActiveItemAnim *a = &_activeItemAnim[_nextAnimItem];
-
-	if (++_nextAnimItem == 11) {
-		_nextAnimItem = 0;
-		return;
-	}
+	_nextAnimItem = ++_nextAnimItem % 10;
 
 	uint32 ctime = _system->getMillis();
 	if (ctime < a->nextFrame)
diff --git a/engines/kyra/debugger.cpp b/engines/kyra/debugger.cpp
index 0d170dbf05..7ae5414d82 100644
--- a/engines/kyra/debugger.cpp
+++ b/engines/kyra/debugger.cpp
@@ -192,6 +192,7 @@ bool Debugger::cmd_setTimerCountdown(int argc, const char **argv) {
 
 Debugger_LoK::Debugger_LoK(KyraEngine_LoK *vm)
 	: Debugger(vm), _vm(vm) {
+	DCmd_Register("enter",				WRAP_METHOD(Debugger_LoK, cmd_enterRoom));
 	DCmd_Register("rooms",				WRAP_METHOD(Debugger_LoK, cmd_listRooms));
 	DCmd_Register("give",				WRAP_METHOD(Debugger_LoK, cmd_giveItem));
 	DCmd_Register("birthstones",		WRAP_METHOD(Debugger_LoK, cmd_listBirthstones));
diff --git a/engines/kyra/detection.cpp b/engines/kyra/detection.cpp
index 3c4c87e12b..a3ca2f829e 100644
--- a/engines/kyra/detection.cpp
+++ b/engines/kyra/detection.cpp
@@ -41,22 +41,25 @@ struct KYRAGameDescription {
 
 namespace {
 
-#define FLAGS(x, y, z, a, b, id) { Common::UNK_LANG, Common::kPlatformUnknown, x, y, z, a, b, id }
-
-#define KYRA1_FLOPPY_FLAGS FLAGS(false, false, false, false, false, Kyra::GI_KYRA1)
-#define KYRA1_AMIGA_FLAGS FLAGS(false, false, false, false, false, Kyra::GI_KYRA1)
-#define KYRA1_TOWNS_FLAGS FLAGS(false, true, false, false, false, Kyra::GI_KYRA1)
-#define KYRA1_TOWNS_SJIS_FLAGS FLAGS(false, true, false, true, false, Kyra::GI_KYRA1)
-#define KYRA1_CD_FLAGS FLAGS(false, true, true, false, false, Kyra::GI_KYRA1)
-#define KYRA1_DEMO_FLAGS FLAGS(true, false, false, false, false, Kyra::GI_KYRA1)
-
-#define KYRA2_CD_FLAGS FLAGS(false, false, true, false, false, Kyra::GI_KYRA2)
-#define KYRA2_CD_DEMO_FLAGS FLAGS(true, false, true, false, false, Kyra::GI_KYRA2)
-#define KYRA2_DEMO_FLAGS FLAGS(true, false, false, false, false, Kyra::GI_KYRA2)
-#define KYRA2_TOWNS_FLAGS FLAGS(false, false, false, false, false, Kyra::GI_KYRA2)
-#define KYRA2_TOWNS_SJIS_FLAGS FLAGS(false, false, false, true, false, Kyra::GI_KYRA2)
-
-#define KYRA3_CD_FLAGS FLAGS(false, false, true, false, true, Kyra::GI_KYRA3)
+#define FLAGS(x, y, z, a, b, c, id) { Common::UNK_LANG, Common::kPlatformUnknown, x, y, z, a, b, c, id }
+
+#define KYRA1_FLOPPY_FLAGS FLAGS(false, false, false, false, false, false, Kyra::GI_KYRA1)
+#define KYRA1_AMIGA_FLAGS FLAGS(false, false, false, false, false, false, Kyra::GI_KYRA1)
+#define KYRA1_TOWNS_FLAGS FLAGS(false, true, false, false, false, false, Kyra::GI_KYRA1)
+#define KYRA1_TOWNS_SJIS_FLAGS FLAGS(false, true, false, true, false, false, Kyra::GI_KYRA1)
+#define KYRA1_CD_FLAGS FLAGS(false, true, true, false, false, false, Kyra::GI_KYRA1)
+#define KYRA1_DEMO_FLAGS FLAGS(true, false, false, false, false, false, Kyra::GI_KYRA1)
+
+#define KYRA2_FLOPPY_FLAGS FLAGS(false, false, false, false, false, false, Kyra::GI_KYRA2)
+#define KYRA2_FLOPPY_CMP_FLAGS FLAGS(false, false, false, false, false, true, Kyra::GI_KYRA2)
+#define KYRA2_CD_FLAGS FLAGS(false, false, true, false, false, false, Kyra::GI_KYRA2)
+#define KYRA2_CD_DEMO_FLAGS FLAGS(true, false, true, false, false, false, Kyra::GI_KYRA2)
+#define KYRA2_DEMO_FLAGS FLAGS(true, false, false, false, false, false, Kyra::GI_KYRA2)
+#define KYRA2_TOWNS_FLAGS FLAGS(false, false, false, false, false, false, Kyra::GI_KYRA2)
+#define KYRA2_TOWNS_SJIS_FLAGS FLAGS(false, false, false, true, false, false, Kyra::GI_KYRA2)
+
+#define KYRA3_CD_FLAGS FLAGS(false, false, true, false, true, true, Kyra::GI_KYRA3)
+#define KYRA3_CD_INS_FLAGS FLAGS(false, false, true, false, true, true, Kyra::GI_KYRA3)
 
 const KYRAGameDescription adGameDescs[] = {
 	{
@@ -296,6 +299,66 @@ const KYRAGameDescription adGameDescs[] = {
 		KYRA1_DEMO_FLAGS
 	},
 
+	{ // Floppy version
+		{
+			"kyra2",
+			0,
+			AD_ENTRY1("WESTWOOD.001", "3f52dda68c4f7696c8309038be9f4151"),
+			Common::EN_ANY,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		KYRA2_FLOPPY_CMP_FLAGS
+	},
+
+	{ // Floppy version
+		{
+			"kyra2",
+			0,
+			AD_ENTRY1("WESTWOOD.001", "d787b9559afddfe058b84c0b3a787224"),
+			Common::DE_DEU,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		KYRA2_FLOPPY_CMP_FLAGS
+	},
+
+	{ // // Floppy version extracted
+		{
+			"kyra2",
+			"Extracted",
+			AD_ENTRY1("FATE.PAK", "1ba18be685ad8e5a0ab5d46a0ce4d345"),
+			Common::EN_ANY,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		KYRA2_FLOPPY_FLAGS
+	},
+
+	{ // Floppy version extracted
+		{
+			"kyra2",
+			"Extracted",
+			AD_ENTRY1("FATE.PAK", "262fb69dd8e52e596c7aefc6456f7c1b"),
+			Common::DE_DEU,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		KYRA2_FLOPPY_FLAGS
+	},
+
+	{ // Floppy version extracted
+		{
+			"kyra2",
+			"Extracted",
+			AD_ENTRY1("FATE.PAK", "f7de11506b4c8fdf64bc763206c3e4e7"),
+			Common::FR_FRA,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		KYRA2_FLOPPY_FLAGS
+	},
+
 	{ // CD version
 		{
 			"kyra2",
@@ -417,7 +480,7 @@ const KYRAGameDescription adGameDescs[] = {
 			Common::kPlatformPC,
 			Common::ADGF_DROPLANGUAGE
 		},
-		KYRA3_CD_FLAGS
+		KYRA3_CD_INS_FLAGS
 	},
 	{
 		{
@@ -432,7 +495,7 @@ const KYRAGameDescription adGameDescs[] = {
 			Common::kPlatformPC,
 			Common::ADGF_DROPLANGUAGE
 		},
-		KYRA3_CD_FLAGS
+		KYRA3_CD_INS_FLAGS
 	},
 	{
 		{
@@ -447,7 +510,7 @@ const KYRAGameDescription adGameDescs[] = {
 			Common::kPlatformPC,
 			Common::ADGF_DROPLANGUAGE
 		},
-		KYRA3_CD_FLAGS
+		KYRA3_CD_INS_FLAGS
 	},
 
 	// installed version
@@ -497,7 +560,7 @@ const KYRAGameDescription adGameDescs[] = {
 		KYRA3_CD_FLAGS
 	},
 
-	{ AD_TABLE_END_MARKER, FLAGS(0, 0, 0, 0, 0, 0) }
+	{ AD_TABLE_END_MARKER, FLAGS(0, 0, 0, 0, 0, 0, 0) }
 };
 
 const PlainGameDescriptor gameList[] = {
diff --git a/engines/kyra/gui_hof.cpp b/engines/kyra/gui_hof.cpp
index 10f7f657a3..555934cb7f 100644
--- a/engines/kyra/gui_hof.cpp
+++ b/engines/kyra/gui_hof.cpp
@@ -455,12 +455,12 @@ void KyraEngine_HoF::showBookPage() {
 	char filename[16];
 
 	sprintf(filename, "PAGE%.01X.", _bookCurPage);
-	strcat(filename, _languageExtension[_lang]);
+	strcat(filename, (_flags.isTalkie || _flags.platform == Common::kPlatformFMTowns || _lang) ? _languageExtension[_lang] : "TXT");
 	uint8 *leftPage = _res->fileData(filename, 0);
 	int leftPageY = _bookPageYOffset[_bookCurPage];
 
 	sprintf(filename, "PAGE%.01X.", _bookCurPage+1);
-	strcat(filename, _languageExtension[_lang]);
+	strcat(filename, (_flags.isTalkie || _flags.platform == Common::kPlatformFMTowns || _lang) ? _languageExtension[_lang] : "TXT");
 	uint8 *rightPage = (_bookCurPage != _bookMaxPage) ? _res->fileData(filename, 0) : 0;
 	int rightPageY = _bookPageYOffset[_bookCurPage+1];
 
diff --git a/engines/kyra/gui_lok.cpp b/engines/kyra/gui_lok.cpp
index 2b823b1ae7..6fa30c9e9a 100644
--- a/engines/kyra/gui_lok.cpp
+++ b/engines/kyra/gui_lok.cpp
@@ -337,6 +337,8 @@ void GUI_LoK::setGUILabels() {
 	} else if (_vm->gameFlags().lang == Common::ES_ESP) {
 		offsetOn = offsetMainMenu = offsetOptions = offset = -4;
 		menuLabelGarbageOffset = 72;
+	} else if (_vm->gameFlags().lang == Common::IT_ITA) {
+		offsetOn = offsetMainMenu = offsetOptions = offset = 32;
 	} else if (_vm->gameFlags().lang == Common::DE_DEU) {
 		offset = offsetMainMenu = offsetOn = offsetOptions = 24;
 	} else if (_vm->gameFlags().platform == Common::kPlatformFMTowns || _vm->gameFlags().platform == Common::kPlatformPC98) {
diff --git a/engines/kyra/items_lok.cpp b/engines/kyra/items_lok.cpp
index e86be25707..8eb62c20c2 100644
--- a/engines/kyra/items_lok.cpp
+++ b/engines/kyra/items_lok.cpp
@@ -176,7 +176,7 @@ void KyraEngine_LoK::placeItemInGenericMapScene(int item, int index) {
 }
 
 void KyraEngine_LoK::setHandItem(uint16 item) {
-	debugC(9, kDebugLevelMain, "KyraEngine_LoK::setHandItem(%d)", item);
+	debugC(9, kDebugLevelMain, "KyraEngine_LoK::setHandItem(%u)", item);
 	_screen->hideMouse();
 	setMouseItem(item);
 	_itemInHand = item;
@@ -191,9 +191,9 @@ void KyraEngine_LoK::removeHandItem() {
 	_screen->showMouse();
 }
 
-void KyraEngine_LoK::setMouseItem(int item) {
-	debugC(9, kDebugLevelMain, "KyraEngine_LoK::setMouseItem(%d)", item);
-	if (item == -1)
+void KyraEngine_LoK::setMouseItem(uint16 item) {
+	debugC(9, kDebugLevelMain, "KyraEngine_LoK::setMouseItem(%u)", item);
+	if (item == 0xFFFF)
 		_screen->setMouseCursor(1, 1, _shapes[6]);
 	else
 		_screen->setMouseCursor(8, 15, _shapes[216+item]);
diff --git a/engines/kyra/kyra_hof.cpp b/engines/kyra/kyra_hof.cpp
index 0bc5162e94..9c5548c1f7 100644
--- a/engines/kyra/kyra_hof.cpp
+++ b/engines/kyra/kyra_hof.cpp
@@ -177,6 +177,39 @@ KyraEngine_HoF::~KyraEngine_HoF() {
 	_timOpcodes.clear();
 }
 
+void KyraEngine_HoF::pauseEngineIntern(bool pause) {
+	KyraEngine_v2::pauseEngineIntern(pause);
+
+	if (!pause) {
+		uint32 pausedTime = _system->getMillis() - _pauseStart;
+		_pauseStart = 0;
+
+		// sequence player
+		//
+		// Timers in KyraEngine_HoF::seq_cmpFadeFrame() and KyraEngine_HoF::seq_animatedSubFrame()
+		// have been left out for now. I think we don't need them here.
+
+		_seqStartTime += pausedTime;
+		_seqSubFrameStartTime += pausedTime;
+		_seqEndTime += pausedTime;
+		_seqSubFrameEndTimeInternal += pausedTime;
+		_seqWsaChatTimeout += pausedTime;
+		_seqWsaChatFrameTimeout += pausedTime;
+
+		for (int x = 0; x < 10; x++) {
+			if (_activeText[x].duration != -1)
+				_activeText[x].startTime += pausedTime;
+		}
+
+		for (int x = 0; x < 8; x++) {
+			if (_activeWSA[x].flags != -1)
+				_activeWSA[x].nextFrame += pausedTime;
+		}
+
+		// TODO: item animation, idle animation, tim player, etc
+	}
+}
+
 int KyraEngine_HoF::init() {
 	_screen = new Screen_HoF(this, _system);
 	assert(_screen);
@@ -254,6 +287,8 @@ int KyraEngine_HoF::go() {
 	if (_menuChoice != 4) {
 		// load just the pak files needed for ingame
 		_res->loadPakFile(StaticResource::staticDataFilename());
+		if (_flags.useInstallerPackage)
+			_res->loadPakFile("WESTWOOD.001");
 		if (_flags.platform == Common::kPlatformPC && _flags.isTalkie)
 			_res->loadFileList("FILEDATA.FDT");
 		else
diff --git a/engines/kyra/kyra_hof.h b/engines/kyra/kyra_hof.h
index fe4b6390b7..866dd55d16 100644
--- a/engines/kyra/kyra_hof.h
+++ b/engines/kyra/kyra_hof.h
@@ -182,6 +182,8 @@ public:
 	KyraEngine_HoF(OSystem *system, const GameFlags &flags);
 	~KyraEngine_HoF();
 
+	void pauseEngineIntern(bool pause);
+
 	Screen *screen() { return _screen; }
 	Screen_v2 *screen_v2() const { return _screen; }
 	GUI_v2 *gui_v2() const { return _gui; }
@@ -856,7 +858,12 @@ protected:
 
 	uint32 _seqFrameDelay;
 	uint32 _seqStartTime;
+	uint32 _seqSubFrameStartTime;
 	uint32 _seqEndTime;
+	uint32 _seqSubFrameEndTimeInternal;
+	uint32 _seqWsaChatTimeout;
+	uint32 _seqWsaChatFrameTimeout;
+
 	int _seqFrameCounter;
 	int _seqScrollTextCounter;
 	int _seqWsaCurrentFrame;
diff --git a/engines/kyra/kyra_lok.cpp b/engines/kyra/kyra_lok.cpp
index 0668cc7202..c852f6e3ee 100644
--- a/engines/kyra/kyra_lok.cpp
+++ b/engines/kyra/kyra_lok.cpp
@@ -91,6 +91,7 @@ KyraEngine_LoK::KyraEngine_LoK(OSystem *system, const GameFlags &flags)
 	memset(_panPagesTable, 0, sizeof(_panPagesTable));
 	memset(_sceneAnimTable, 0, sizeof(_sceneAnimTable));
 	_currHeadShape = 0;
+	_speechPlayTime = 0;
 
 	memset(&_itemBkgBackUp, 0, sizeof(_itemBkgBackUp));
 }
diff --git a/engines/kyra/kyra_lok.h b/engines/kyra/kyra_lok.h
index 5e244e4925..cb3062847e 100644
--- a/engines/kyra/kyra_lok.h
+++ b/engines/kyra/kyra_lok.h
@@ -113,6 +113,10 @@ public:
 	KyraEngine_LoK(OSystem *system, const GameFlags &flags);
 	~KyraEngine_LoK();
 
+	//TODO: proper extended implementation of KyraEngine_v1::pauseEngineIntern.
+	// _sprites and _seqplayer should be paused here too, to avoid some animation glitches,
+	// also parts of the hardcoded Malcolm fight might need some special handling.
+
 	Screen *screen() { return _screen; }
 	Animator_LoK *animator() { return _animator; }
 	virtual Movie *createWSAMovie();
@@ -205,8 +209,11 @@ public:
 	void snd_playWanderScoreViaMap(int command, int restart);
 	virtual void snd_playVoiceFile(int id);
 	void snd_voiceWaitForFinish(bool ingame = true);
+	uint32 snd_getVoicePlayTime();
 
 protected:
+	int32 _speechPlayTime;
+
 	void saveGame(const char *fileName, const char *saveName);
 	void loadGame(const char *fileName);
 
@@ -284,7 +291,7 @@ protected:
 	// -> mouse item
 	void setHandItem(uint16 item);
 	void removeHandItem();
-	void setMouseItem(int item);
+	void setMouseItem(uint16 item);
 
 	// -> graphics effects
 	void wipeDownMouseItem(int xpos, int ypos);
@@ -628,9 +635,6 @@ protected:
 	int _cdaTrackTableSize;
 	const AudioDataStruct * _soundData;
 
-	static const int8 _charXPosTable[];
-	static const int8 _charYPosTable[];
-
 	// positions of the inventory
 	static const uint16 _itemPosX[];
 	static const uint8 _itemPosY[];
@@ -791,9 +795,9 @@ protected:
 	int o1_pauseMusicSeconds(EMCState *script);
 	int o1_resetMaskRegion(EMCState *script);
 	int o1_setPaletteChangeFlag(EMCState *script);
-	int o1_dummy(EMCState *script);
 	int o1_vocUnload(EMCState *script);
 	int o1_vocLoad(EMCState *script);
+	int o1_dummy(EMCState *script);
 };
 
 } // end of namespace Kyra
diff --git a/engines/kyra/kyra_mr.cpp b/engines/kyra/kyra_mr.cpp
index c0c04cb370..c842e318ec 100644
--- a/engines/kyra/kyra_mr.cpp
+++ b/engines/kyra/kyra_mr.cpp
@@ -370,7 +370,10 @@ void KyraEngine_MR::playVQA(const char *name) {
 	snprintf(filename, sizeof(filename), "%s%d.VQA", name, size);
 
 	if (vqa.open(filename)) {
-		_soundDigital->stopAllSounds();
+		for (int i = 0; i < 4; ++i) {
+			if (i != _musicSoundChannel)
+				_soundDigital->stopSound(i);
+		}
 
 		_screen->hideMouse();
 		memcpy(_screen->getPalette(1), _screen->getPalette(0), 768);
@@ -402,14 +405,12 @@ void KyraEngine_MR::playMenuAudioFile() {
 	if (_soundDigital->isPlaying(_musicSoundChannel))
 		return;
 
-	_musicSoundChannel = _soundDigital->playSound(_menuAudioFile, 0xFF, Audio::Mixer::kMusicSoundType);
+	_musicSoundChannel = _soundDigital->playSound(_menuAudioFile, 0xFF, Audio::Mixer::kMusicSoundType, 255, true);
 }
 
 void KyraEngine_MR::snd_playWanderScoreViaMap(int track, int force) {
 	debugC(9, kDebugLevelMain, "KyraEngine_MR::snd_playWanderScoreViaMap(%d, %d)", track, force);
 
-	// XXX byte_3C87C compare
-
 	if (_musicSoundChannel != -1 && !_soundDigital->isPlaying(_musicSoundChannel))
 		force = 1;
 	else if (_musicSoundChannel == -1)
diff --git a/engines/kyra/kyra_mr.h b/engines/kyra/kyra_mr.h
index 4ec02c7849..5af138373c 100644
--- a/engines/kyra/kyra_mr.h
+++ b/engines/kyra/kyra_mr.h
@@ -50,6 +50,11 @@ public:
 	KyraEngine_MR(OSystem *system, const GameFlags &flags);
 	~KyraEngine_MR();
 
+	//TODO: proper extended implementation of KyraEngine_v2::pauseEngineIntern.
+	// Idle animation time, item animations and album animations should be taken
+	// care of, but since those would just produce minor glitches it's not that
+	// important.
+
 	Screen *screen() { return _screen; }
 	Screen_v2 *screen_v2() const { return _screen; }
 	GUI_v2 *gui_v2() const { return _gui; }
diff --git a/engines/kyra/kyra_v1.cpp b/engines/kyra/kyra_v1.cpp
index a3d18f7713..1cc1d728bf 100644
--- a/engines/kyra/kyra_v1.cpp
+++ b/engines/kyra/kyra_v1.cpp
@@ -87,6 +87,11 @@ KyraEngine_v1::KyraEngine_v1(OSystem *system, const GameFlags &flags)
 	return _debugger;
 }
 
+void KyraEngine_v1::pauseEngineIntern(bool pause) {
+	Engine::pauseEngineIntern(pause);
+	_timer->pause(pause);
+}
+
 int KyraEngine_v1::init() {
 	registerDefaultSettings();
 
diff --git a/engines/kyra/kyra_v1.h b/engines/kyra/kyra_v1.h
index 81a6254c7f..4f38ceca98 100644
--- a/engines/kyra/kyra_v1.h
+++ b/engines/kyra/kyra_v1.h
@@ -46,11 +46,12 @@ struct GameFlags {
 	Common::Language lang;
 	Common::Platform platform;
 
-	bool isDemo				: 1;
-	bool useAltShapeHeader	: 1;	// alternative shape header (uses 2 bytes more, those are unused though)
-	bool isTalkie			: 1;
-	bool useHiResOverlay	: 1;
-	bool useDigSound		: 1;
+	bool isDemo					: 1;
+	bool useAltShapeHeader		: 1;	// alternative shape header (uses 2 bytes more, those are unused though)
+	bool isTalkie				: 1;
+	bool useHiResOverlay		: 1;
+	bool useDigSound			: 1;
+	bool useInstallerPackage	: 1;
 
 	byte gameID;
 };
@@ -109,6 +110,8 @@ public:
 
 	::GUI::Debugger *getDebugger();
 
+	virtual void pauseEngineIntern(bool pause);
+
 	bool quit() const { return _quitFlag; }
 
 	uint8 game() const { return _flags.gameID; }
@@ -263,6 +266,11 @@ protected:
 	static const int8 _addXPosTable[];
 	static const int8 _addYPosTable[];
 
+	// Character
+	
+	static const int8 _charAddXPosTable[];
+	static const int8 _charAddYPosTable[];
+
 	// save/load
 	int _gameToLoad;
 
diff --git a/engines/kyra/kyra_v2.cpp b/engines/kyra/kyra_v2.cpp
index 7b720259cc..12da338843 100644
--- a/engines/kyra/kyra_v2.cpp
+++ b/engines/kyra/kyra_v2.cpp
@@ -68,6 +68,8 @@ KyraEngine_v2::KyraEngine_v2(OSystem *system, const GameFlags &flags, const Engi
 
 	memset(&_mainCharacter, 0, sizeof(_mainCharacter));
 	memset(&_mainCharacter.inventory, -1, sizeof(_mainCharacter.inventory));
+
+	_pauseStart = 0;
 }
 
 KyraEngine_v2::~KyraEngine_v2() {
@@ -93,6 +95,22 @@ KyraEngine_v2::~KyraEngine_v2() {
 	delete[] _screenBuffer;
 }
 
+void KyraEngine_v2::pauseEngineIntern(bool pause) {
+	KyraEngine_v1::pauseEngineIntern(pause);
+
+	if (!pause) {
+		uint32 pausedTime = _system->getMillis() - _pauseStart;
+
+		for (int i = 0; i < ARRAYSIZE(_sceneSpecialScriptsTimer); ++i) {
+			if (_sceneSpecialScriptsTimer[i])
+				_sceneSpecialScriptsTimer[i] += pausedTime;
+		}
+
+	} else {
+		_pauseStart = _system->getMillis();
+	}
+}
+
 void KyraEngine_v2::delay(uint32 amount, bool updateGame, bool isMainLoop) {
 	debugC(9, kDebugLevelMain, "KyraEngine_v2::delay(%u, %d, %d)", amount, updateGame, isMainLoop);
 
@@ -326,8 +344,8 @@ int KyraEngine_v2::updateCharPos(int *table, int force) {
 	debugC(9, kDebugLevelMain, "KyraEngine_v2::updateCharPos(%p, %d)", (const void*)table, force);
 	if (_updateCharPosNextUpdate > _system->getMillis() && !force)
 		return 0;
-	_mainCharacter.x1 += _updateCharPosXTable[_mainCharacter.facing];
-	_mainCharacter.y1 += _updateCharPosYTable[_mainCharacter.facing];
+	_mainCharacter.x1 += _charAddXPosTable[_mainCharacter.facing];
+	_mainCharacter.y1 += _charAddYPosTable[_mainCharacter.facing];
 	updateCharAnimFrame(0, table);
 	_updateCharPosNextUpdate = _system->getMillis() + getCharacterWalkspeed() * _tickLength;
 	return 1;
diff --git a/engines/kyra/kyra_v2.h b/engines/kyra/kyra_v2.h
index 2f6d8a6185..24f7aad614 100644
--- a/engines/kyra/kyra_v2.h
+++ b/engines/kyra/kyra_v2.h
@@ -75,6 +75,8 @@ public:
 	KyraEngine_v2(OSystem *system, const GameFlags &flags, const EngineDesc &desc);
 	~KyraEngine_v2();
 
+	virtual void pauseEngineIntern(bool pause);
+
 	virtual Screen_v2 *screen_v2() const = 0;
 	virtual GUI *gui_v2() const = 0;
 
@@ -85,6 +87,7 @@ protected:
 	EngineDesc _desc;
 
 	// run
+	uint32 _pauseStart;
 	bool _runFlag;
 	bool _showOutro;
 
@@ -355,8 +358,6 @@ protected:
 	void updateCharPosWithUpdate();
 
 	uint32 _updateCharPosNextUpdate;
-	static const int8 _updateCharPosXTable[];
-	static const int8 _updateCharPosYTable[];
 
 	virtual int getCharacterWalkspeed() const = 0;
 	virtual void updateCharAnimFrame(int num, int *table) = 0;
diff --git a/engines/kyra/resource.cpp b/engines/kyra/resource.cpp
index 9d34c669a1..6b38a0f907 100644
--- a/engines/kyra/resource.cpp
+++ b/engines/kyra/resource.cpp
@@ -30,10 +30,10 @@
 #include "common/fs.h"
 #include "common/func.h"
 
-#include "gui/message.h"
-
 #include "kyra/resource.h"
 
+#define INS_CACHE_THRESHOLD		300000	// all files with file size greater than this will be cached
+
 namespace Kyra {
 
 Resource::Resource(KyraEngine_v1 *vm) : _loaders(), _map(), _vm(vm) {
@@ -55,8 +55,7 @@ bool Resource::reset() {
 
 	if (!loadPakFile(StaticResource::staticDataFilename()) || !StaticResource::checkKyraDat()) {
 		Common::String errorMessage = "You're missing the '" + StaticResource::staticDataFilename() + "' file or it got corrupted, (re)get it from the ScummVM website";
-		::GUI::MessageDialog errorMsg(errorMessage);
-		errorMsg.runModal();
+		_vm->GUIErrorMessage(errorMessage);
 		error(errorMessage.c_str());
 	}
 
@@ -69,17 +68,31 @@ bool Resource::reset() {
 		if (_vm->gameFlags().isTalkie)
 			loadPakFile("CHAPTER1.VRM");
 	} else if (_vm->game() == GI_KYRA2) {
+		if (_vm->gameFlags().useInstallerPackage)
+			loadPakFile("WESTWOOD.001");
+
 		// mouse pointer, fonts, etc. required for initializing
 		if (_vm->gameFlags().isDemo && !_vm->gameFlags().isTalkie) {
 			loadPakFile("GENERAL.PAK");
 		} else {
+			if (_vm->gameFlags().isTalkie) {
+				// Add default file directories
+				Common::File::addDefaultDirectory(ConfMan.get("path") + "hof_cd");
+				Common::File::addDefaultDirectory(ConfMan.get("path") + "HOF_CD");
+			}
+
 			loadPakFile("INTROGEN.PAK");
 			loadPakFile("OTHER.PAK");
 		}
 
 		return true;
 	} else if (_vm->game() == GI_KYRA3) {
-		loadPakFile("WESTWOOD.001");
+		if (_vm->gameFlags().useInstallerPackage)
+			loadPakFile("WESTWOOD.001");
+		// Add default file directories
+		Common::File::addDefaultDirectory(ConfMan.get("path") + "malcolm");
+		Common::File::addDefaultDirectory(ConfMan.get("path") + "MALCOLM");
+
 		loadFileList("FILEDATA.FDT");
 
 		return true;
@@ -210,7 +223,7 @@ bool Resource::loadFileList(const Common::String &filedata) {
 		buffer[12] = 0;
 		f.seek(offset + 16, SEEK_SET);
 
-		Common::String filename = (char*)buffer;
+		Common::String filename = Common::String((char*)buffer);
 		filename.toUppercase();
 
 		if (filename.hasSuffix(".PAK")) {
@@ -569,7 +582,7 @@ Common::SeekableReadStream *ResLoaderPak::loadFileFromArchive(const Common::Stri
 	return stream;
 }
 
-class ResLoaderIns : public ResArchiveLoader {
+class ResLoaderInsKyra : public ResArchiveLoader {
 public:
 	bool checkFilename(Common::String filename) const;
 	bool isLoadable(const Common::String &filename, Common::SeekableReadStream &stream) const;
@@ -577,16 +590,790 @@ public:
 	Common::SeekableReadStream *loadFileFromArchive(const Common::String &file, Common::SeekableReadStream *archive, const ResFileEntry entry) const;
 
 	ResFileEntry::kType getType() const {
-		return ResFileEntry::kIns;
+		return ResFileEntry::kInsKyra;
+	}
+};
+
+bool ResLoaderInsKyra::checkFilename(Common::String filename) const {
+	return false;
+}
+
+bool ResLoaderInsKyra::isLoadable(const Common::String &filename, Common::SeekableReadStream &stream) const {
+	return true;
+}
+
+bool ResLoaderInsKyra::loadFile(const Common::String &filename, Common::SeekableReadStream &stream, FileList &files) const {
+	return true;
+}
+
+Common::SeekableReadStream *ResLoaderInsKyra::loadFileFromArchive(const Common::String &file, Common::SeekableReadStream *archive, const ResFileEntry entry) const {
+	return 0;
+}
+
+class FileExpanderSource {
+public:
+	FileExpanderSource(const uint8 *data) : _dataPtr(data), _bitsLeft(8), _key(0), _index(0) {}
+	~FileExpanderSource() {}
+
+	void advSrcRefresh();
+	void advSrcBitsBy1();
+	void advSrcBitsByIndex(uint8 newIndex);
+
+	uint8 getKeyLower() { return _key & 0xff; }
+	void setIndex(uint8 index) { _index = index; }
+	uint16 getKeyMasked(uint8 newIndex);
+	uint16 keyMaskedAlign(uint16 val);
+
+	void copyBytes(uint8 *& dst);
+
+private:
+	const uint8 *_dataPtr;
+	uint16 _key;
+	int8 _bitsLeft;
+	uint8 _index;
+};
+
+void FileExpanderSource::advSrcBitsBy1() {
+	_key >>= 1;		
+	if (!--_bitsLeft) {
+		_key = ((*_dataPtr++) << 8 ) | (_key & 0xff);
+		_bitsLeft = 8;
+	}
+}
+
+void FileExpanderSource::advSrcBitsByIndex(uint8 newIndex) {
+	_index = newIndex;
+	_bitsLeft -= _index;
+	if (_bitsLeft <= 0) {
+		_key >>= (_index + _bitsLeft);
+		_index = -_bitsLeft;
+		_bitsLeft = 8 - _index;
+		_key = (*_dataPtr++ << 8) | (_key & 0xff);
+	}
+	_key >>= _index;
+}
+
+uint16 FileExpanderSource::getKeyMasked(uint8 newIndex) {
+	static const uint8 mskTable[] = { 0x0F, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF };
+	_index = newIndex;
+	uint16 res = 0;
+
+	if (_index > 8) {
+		newIndex = _index - 8;
+		res = (_key & 0xff) & mskTable[8];		
+		advSrcBitsByIndex(8);
+		_index = newIndex;
+		res |= (((_key & 0xff) & mskTable[_index]) << 8);
+		advSrcBitsByIndex(_index);
+	} else {
+		res = (_key & 0xff) & mskTable[_index];
+		advSrcBitsByIndex(_index);
 	}
+
+	return res;
+}
+
+void FileExpanderSource::copyBytes(uint8 *& dst) {
+	advSrcBitsByIndex(_bitsLeft);
+	uint16 r = (READ_LE_UINT16(_dataPtr) ^ _key) + 1;
+	_dataPtr += 2;
+
+	if (r)
+		error("decompression failure");
+
+	memcpy(dst, _dataPtr, _key);
+	_dataPtr += _key;
+	dst += _key;
+}
+
+uint16 FileExpanderSource::keyMaskedAlign(uint16 val) {
+	val -= 0x101;
+	_index = (val & 0xff) >> 2;
+	int16 b = ((_bitsLeft << 8) | _index) - 1;
+	_bitsLeft = b >> 8;
+	_index = b & 0xff;
+	return (((val & 3) + 4) << _index) + 0x101 + getKeyMasked(_index);
+}
+
+void FileExpanderSource::advSrcRefresh() {
+	_key = READ_LE_UINT16(_dataPtr);
+	_dataPtr += 2;		
+	_bitsLeft = 8;
+}
+
+class FileExpander {
+public:
+	FileExpander();
+	~FileExpander();
+
+	bool process(uint8 *dst, const uint8 *src, uint32 outsize, uint32 insize);
+
+private:
+	void generateTables(uint8 srcIndex, uint8 dstIndex, uint8 dstIndex2, int cnt);
+	uint8 calcCmdAndIndex(const uint8 *tbl, int16 &para);
+
+	FileExpanderSource *_src;
+	uint8 *_tables[9];
+	uint16 *_tables16[3];
 };
 
-bool ResLoaderIns::checkFilename(Common::String filename) const {
+FileExpander::FileExpander() : _src(0) {
+	_tables[0] = new uint8[3914];
+	assert(_tables[0]);
+
+	_tables[1] = _tables[0] + 320;
+	_tables[2] = _tables[0] + 352;
+	_tables[3] = _tables[0] + 864;
+	_tables[4] = _tables[0] + 2016;
+	_tables[5] = _tables[0] + 2528;
+	_tables[6] = _tables[0] + 2656;
+	_tables[7] = _tables[0] + 2736;
+	_tables[8] = _tables[0] + 2756;
+
+	_tables16[0] = (uint16 *)(_tables[0] + 3268);
+	_tables16[1] = (uint16 *)(_tables[0] + 3302);
+	_tables16[2] = (uint16 *)(_tables[0] + 3338);
+}
+
+FileExpander::~FileExpander() {
+	delete _src;
+	delete[] _tables[0];
+}
+
+bool FileExpander::process(uint8 *dst, const uint8 *src, uint32 outsize, uint32 compressedSize) {
+	static const uint8 indexTable[] = {
+		0x10, 0x11, 0x12, 0x00, 0x08, 0x07, 0x09, 0x06, 0x0A,
+		0x05, 0x0B, 0x04, 0x0C, 0x03, 0x0D, 0x02, 0x0E, 0x01, 0x0F
+	};
+	
+	memset(_tables[0], 0, 3914);
+
+	uint8 *d = dst;
+	uint16 tableSize0 = 0;
+	uint16 tableSize1 = 0;
+	bool needrefresh = true;
+	bool postprocess = false;
+
+	_src = new FileExpanderSource(src);
+
+	while (d < dst + outsize) {
+
+		if (needrefresh) {
+			needrefresh = false;
+			_src->advSrcRefresh();
+		}
+
+		_src->advSrcBitsBy1();
+
+		int mode = _src->getKeyMasked(2) - 1;
+		if (mode == 1) {
+			tableSize0 = _src->getKeyMasked(5) + 257;
+			tableSize1 = _src->getKeyMasked(5) + 1;
+			memset(_tables[7], 0, 19);
+				
+			const uint8 *itbl = indexTable;
+			int numbytes = _src->getKeyMasked(4) + 4;
+			
+			while (numbytes--)
+				_tables[7][*itbl++] = _src->getKeyMasked(3);
+
+			generateTables(7, 8, 255, 19);
+
+			int cnt = tableSize0 + tableSize1;
+			uint8 *tmp = _tables[0];
+
+			while (cnt) {
+				uint16 cmd = _src->getKeyLower();
+				cmd = READ_LE_UINT16(&_tables[8][cmd << 1]);
+				_src->advSrcBitsByIndex(_tables[7][cmd]);
+
+				if (cmd < 16) {
+					*tmp++ = cmd;
+					cnt--;
+				} else {
+					uint8 tmpI = 0;
+					if (cmd == 16) {
+						cmd = _src->getKeyMasked(2) + 3;
+						tmpI = *(tmp - 1);							
+					} else if (cmd == 17) {
+						cmd = _src->getKeyMasked(3) + 3;
+					} else {
+						cmd = _src->getKeyMasked(7) + 11;
+					}
+					_src->setIndex(tmpI);
+					memset(tmp, tmpI, cmd);
+					tmp += cmd;
+
+					cnt -= cmd;
+					if (cnt < 0)
+						error("decompression failure");
+				}
+			}
+				
+			memcpy(_tables[1], _tables[0] + tableSize0, tableSize1);
+			generateTables(0, 2, 3, tableSize0);
+			generateTables(1, 4, 5, tableSize1);
+			postprocess = true;
+		} else if (mode < 0) {
+			_src->copyBytes(d);
+			postprocess = false;
+			needrefresh = true;
+		} else if (mode == 0){
+			uint8 *d2 = _tables[0];			
+			memset(d2, 8, 144);
+			memset(d2 + 144, 9, 112);
+			memset(d2 + 256, 7, 24);
+			memset(d2 + 280, 8, 8);
+			d2 = _tables[1];
+			memset(d2, 5, 32);
+			tableSize0 = 288;
+			tableSize1 = 32;
+
+			generateTables(0, 2, 3, tableSize0);
+			generateTables(1, 4, 5, tableSize1);
+			postprocess = true;
+		} else {
+			error("decompression failure");
+		}
+
+		if (!postprocess)
+			continue;
+		
+		int16 cmd = 0;
+		
+		do  {
+			cmd = ((int16*) _tables[2])[_src->getKeyLower()];
+			_src->advSrcBitsByIndex(cmd < 0 ? calcCmdAndIndex(_tables[3], cmd) : _tables[0][cmd]);
+
+			if (cmd == 0x11d) {
+				cmd = 0x200;
+			} else if (cmd > 0x108) {
+				cmd = _src->keyMaskedAlign(cmd);
+			}
+
+			if (!(cmd >> 8)) {
+				*d++ = cmd & 0xff;
+			} else if (cmd != 0x100) {
+				cmd -= 0xfe;
+				int16 offset = ((int16*) _tables[4])[_src->getKeyLower()];
+				_src->advSrcBitsByIndex(offset < 0 ? calcCmdAndIndex(_tables[5], offset) : _tables[1][offset]);
+				if ((offset & 0xff) >= 4) {
+					uint8 newIndex = ((offset & 0xff) >> 1) - 1;
+					offset = (((offset & 1) + 2) << newIndex) + _src->getKeyMasked(newIndex);
+				}
+
+				uint8 *s2 = d - 1 - offset;
+				if (s2 >= dst) {
+					while (cmd--)
+						*d++ = *s2++;
+				} else {
+					uint32 pos = dst - s2;
+					s2 += (d - dst);
+
+					if (pos < (uint32) cmd) {
+						cmd -= pos;
+						while (pos--)
+							*d++ = *s2++;
+						s2 = dst;
+					}
+					while (cmd--)
+						*d++ = *s2++;
+				}
+			}
+		} while (cmd != 0x100);
+	}
+
+	delete _src;
+	_src = 0;
+
+	return true;
+}
+
+void FileExpander::generateTables(uint8 srcIndex, uint8 dstIndex, uint8 dstIndex2, int cnt) {
+	const uint8 *tbl1 = _tables[srcIndex];
+	const uint8 *tbl2 = _tables[dstIndex];
+	const uint8 *tbl3 = dstIndex2 == 0xff ? 0 : _tables[dstIndex2];
+
+	if (!cnt)
+		return;
+
+	const uint8 *s = tbl1;
+	memset(_tables16[0], 0, 32);
+	
+	for (int i = 0; i < cnt; i++) 
+		_tables16[0][(*s++)]++;
+
+	_tables16[1][1] = 0;
+
+	for (uint16 i = 1, r = 0; i < 16; i++) {
+		r = (r + _tables16[0][i]) << 1;
+		_tables16[1][i + 1] = r;
+	}
+
+	if (_tables16[1][16]) {
+		uint16 r = 0;
+		for (uint16 i = 1; i < 16; i++)
+			r += _tables16[0][i];
+		if (r > 1)
+			error("decompression failure");
+	}
+
+	s = tbl1;
+	uint16 *d = _tables16[2];
+	for (int i = 0; i < cnt; i++) {
+		uint16 t = *s++;
+		if (t) {
+			_tables16[1][t]++;
+			t = _tables16[1][t] - 1;
+		}
+		*d++ = t;
+	}
+
+	s = tbl1;
+	d = _tables16[2];
+	for (int i = 0; i < cnt; i++) {
+		int8 t = ((int8)(*s++)) - 1;
+		if (t > 0) {
+			uint16 v1 = *d;
+			uint16 v2 = 0;
+			
+			do {
+				v2 = (v2 << 1) | (v1 & 1);
+				v1 >>= 1;
+			} while (--t && v1);
+			
+			t++;
+			uint8 c1 = (v1 & 1);
+			while (t--) {
+				uint8 c2 = v2 >> 15;
+				v2 = (v2 << 1) | c1;
+				c1 = c2;
+			};
+
+			*d++ = v2;
+		} else {
+			d++;
+		}		
+	}
+
+	memset((void*) tbl2, 0, 512);
+
+	cnt--;
+	s = tbl1 + cnt;
+	d = &_tables16[2][cnt];
+	uint16 * bt = (uint16*) tbl3;
+	uint16 inc = 0;
+	uint16 cnt2 = 0;
+
+	do {
+		uint8 t = *s--;
+		uint16 *s2 = (uint16*) tbl2;
+
+		if (t && t < 9) {
+			inc = 1 << t;
+			uint16 o = *d;
+			
+			do {
+				s2[o] = cnt;
+				o += inc;
+			} while (!(o & 0xf00));
+
+		} else if (t > 8) {
+			if (!bt)
+				error("decompression failure");
+
+			t -= 8;
+			uint8 shiftCnt = 1;
+			uint8 v = (*d) >> 8;
+			s2 = &((uint16*) tbl2)[*d & 0xff];
+
+			do {
+				if (!*s2) {
+					*s2 = (uint16)(~cnt2);
+					*(uint32*)&bt[cnt2] = 0;
+					cnt2 += 2;
+				}
+
+				s2 = &bt[(uint16)(~*s2)];
+				if (v & shiftCnt)
+					s2++;
+
+				shiftCnt <<= 1;
+			} while (--t);
+			*s2 = cnt;
+		}
+		d--;		
+	} while (--cnt >= 0);
+}
+
+uint8 FileExpander::calcCmdAndIndex(const uint8 *tbl, int16 &para) {
+	const uint16 *t = (const uint16*)tbl;
+	_src->advSrcBitsByIndex(8);
+	uint8 newIndex = 0;
+	uint16 v = _src->getKeyLower();
+
+	do {
+		newIndex++;
+		para = t[((~para) & 0xfffe) | (v & 1)];
+		v >>= 1;
+	} while (para < 0);
+
+	return newIndex;
+}
+
+class FileCache {
+public:
+	FileCache() : _size(0) {}
+	~FileCache() {}
+
+	void add(ResFileEntry entry, const uint8 *data);
+	bool getData(ResFileEntry entry, uint8 *dst);
+	void flush();
+
+private:
+	struct FileCacheEntry {
+		ResFileEntry entry;
+		const uint8 *data;
+	};
+
+	Common::List<FileCacheEntry> _cachedFileList;
+	uint32 _size;
+};
+
+void FileCache::add(ResFileEntry entry, const uint8 *data) {
+	FileCacheEntry fileCacheEntry;
+	fileCacheEntry.entry.compressedSize = entry.compressedSize;
+	fileCacheEntry.entry.mounted = entry.mounted;
+	fileCacheEntry.entry.offset = entry.offset;
+	fileCacheEntry.entry.parent = entry.parent;
+	fileCacheEntry.entry.preload = entry.preload;
+	fileCacheEntry.entry.prot = entry.prot;
+	fileCacheEntry.entry.size = entry.size;
+	fileCacheEntry.entry.type = entry.type;
+	fileCacheEntry.entry.fileIndex = entry.fileIndex;
+	uint8 *dst = new uint8[entry.size];
+	assert(dst);
+	memcpy(dst, data, entry.size);
+	fileCacheEntry.data = dst;
+	_cachedFileList.push_back(fileCacheEntry);
+	_size += entry.size;
+}
+
+bool FileCache::getData(ResFileEntry entry, uint8 *dst) {
+	for (Common::List<FileCacheEntry>::const_iterator c = _cachedFileList.begin(); c != _cachedFileList.end(); ++c) {
+		if (c->entry.offset == entry.offset && c->entry.compressedSize == entry.compressedSize &&
+			c->entry.fileIndex == entry.fileIndex && c->entry.size == entry.size) {
+				memcpy(dst, c->data, c->entry.size);
+				return true;
+		}
+	}
+	return false;
+}
+
+void FileCache::flush() {
+	debug(1, "total amount of cache memory used: %d", _size);
+	for (Common::List<FileCacheEntry>::const_iterator c = _cachedFileList.begin(); c != _cachedFileList.end(); ++c)
+		delete[] c->data;
+	_cachedFileList.clear();
+	_size = 0;
+}
+
+class ResLoaderInsHof : public ResArchiveLoader {
+public:
+	ResLoaderInsHof() {}
+	~ResLoaderInsHof() { _fileCache.flush(); }
+
+	bool checkFilename(Common::String filename) const;
+	bool isLoadable(const Common::String &filename, Common::SeekableReadStream &stream) const;
+	bool loadFile(const Common::String &filename, Common::SeekableReadStream &stream, FileList &files) const;
+	Common::SeekableReadStream *loadFileFromArchive(const Common::String &file, Common::SeekableReadStream *archive, const ResFileEntry entry) const;
+
+	ResFileEntry::kType getType() const {
+		return ResFileEntry::kInsHof;
+	}
+private:
+	mutable FileCache _fileCache;
+};
+
+bool ResLoaderInsHof::checkFilename(Common::String filename) const {
+	filename.toUppercase();
+	if (!filename.hasSuffix(".001"))
+		return false;
+	filename.insertChar('2', filename.size() - 1);
+	filename.deleteLastChar();
+	if (!Common::File::exists(filename))
+		return false;
+	return true;
+}
+
+bool ResLoaderInsHof::isLoadable(const Common::String &filename, Common::SeekableReadStream &stream) const {
+	uint8 fileId = stream.readByte();
+	uint32 size = stream.readUint32LE();
+	
+	if (size < stream.size() + 1)
+		return false;
+
+	return (fileId == 1);
+}
+
+bool ResLoaderInsHof::loadFile(const Common::String &filename, Common::SeekableReadStream &stream, FileList &files) const {
+	Common::File tmpFile;
+
+	uint32 pos = 0;
+	uint32 bytesleft = 0;
+	bool startFile = true;
+
+	Common::String filenameBase(filename.c_str(), 10);
+	Common::String filenameTemp;
+	char filenameExt[4];
+
+	while (filenameBase.lastChar() != '.')
+		filenameBase.deleteLastChar();
+
+	InsHofArchive newArchive;
+
+	Common::List<InsHofArchive> archives;
+
+	for (int8 currentFile = 1; currentFile; currentFile++) {	
+		sprintf(filenameExt, "%03d", currentFile);
+		filenameTemp = filenameBase + Common::String(filenameExt);
+
+		if (!tmpFile.open(filenameTemp)) {
+			debug(3, "couldn't open file '%s'\n", filenameTemp.c_str());
+			break;
+		}
+
+		tmpFile.seek(pos);
+		uint8 fileId = tmpFile.readByte();
+		pos++;
+
+		uint32 size = tmpFile.size() - 1;
+		if (startFile) {
+			size -= 4;
+			if (fileId == currentFile) {
+				size -= 6;
+				pos += 6;
+				tmpFile.seek(6, SEEK_CUR);
+			} else {
+				size = size + 1 - pos;
+			}
+			newArchive.filename = filenameBase;
+			bytesleft = newArchive.totalSize = tmpFile.readUint32LE();
+			pos += 4;
+			newArchive.firstFile = currentFile;
+			newArchive.startOffset = pos;
+			startFile = false;
+		}
+
+		uint32 cs = MIN(size, bytesleft);
+		bytesleft -= cs;
+
+		tmpFile.close();
+		
+		pos += cs;
+		if (cs == size) {
+			if (!bytesleft) {
+				newArchive.lastFile = currentFile;
+				newArchive.endOffset = --pos;
+				archives.push_back(newArchive);
+				currentFile = -1;
+			} else {
+				pos = 0;
+			}
+		} else {
+			startFile = true;
+			bytesleft = size - cs;
+			newArchive.lastFile = currentFile--;
+			newArchive.endOffset = --pos;
+			archives.push_back(newArchive);
+		}
+	}
+
+	ResFileEntry newEntry;
+	pos = 0;
+
+	const uint32 kExecSize = 0x0bba;
+	const uint32 kHeaderSize = 30;
+	const uint32 kHeaderSize2 = 46;
+
+	for (Common::List<InsHofArchive>::iterator a = archives.begin(); a != archives.end(); ++a) {
+		startFile = true;
+		for (uint32 i = a->firstFile; i != (a->lastFile + 1); i++) {
+			sprintf(filenameExt, "%03d", i);
+			filenameTemp = a->filename + Common::String(filenameExt);
+
+			if (!tmpFile.open(filenameTemp)) {
+				debug(3, "couldn't open file '%s'\n", filenameTemp.c_str());
+				break;
+			}
+
+			uint32 size = (i == a->lastFile) ? a->endOffset : tmpFile.size();
+			
+			if (startFile) {
+				startFile = false;
+				pos = a->startOffset + kExecSize;
+				if (pos > size) {
+					pos -= size;
+					tmpFile.close();
+					continue;
+				}
+			} else {
+				pos ++;
+			}
+
+			while (pos < size) {
+				uint8 hdr[43];
+				uint32 m = 0;
+				tmpFile.seek(pos);
+
+				if (pos + 42 > size) {
+					m = size - pos;
+					uint32 b = 42 - m;
+
+					if (m >= 4) {
+						uint32 id = tmpFile.readUint32LE();
+						if (id == 0x06054B50) {
+							startFile = true;
+							break;
+						} else {
+							tmpFile.seek(pos);
+						}
+					}
+				
+					sprintf(filenameExt, "%03d", i + 1);
+					filenameTemp = a->filename + Common::String(filenameExt);
+
+					Common::File tmpFile2;
+					tmpFile2.open(filenameTemp);
+					tmpFile.read(hdr, m);
+					tmpFile2.read(hdr + m, b);
+					tmpFile2.close();
+
+				} else {
+					tmpFile.read(hdr, 42);
+				}
+
+				uint32 id = READ_LE_UINT32(hdr);
+				
+				if (id == 0x04034B50) {
+					if (hdr[8] != 8)
+						error("compression type not implemented");
+					newEntry.compressedSize = READ_LE_UINT32(hdr + 18);
+					newEntry.size = READ_LE_UINT32(hdr + 22);
+			
+					uint16 filestrlen = READ_LE_UINT16(hdr + 26);
+					*(hdr + 30 + filestrlen) = 0;
+					pos += (kHeaderSize + filestrlen - m);
+
+					newEntry.parent = filename;
+					newEntry.offset = pos;
+					newEntry.type = ResFileEntry::kAutoDetect;
+					newEntry.mounted = false;
+					newEntry.preload = false;
+					newEntry.prot = false;
+					newEntry.fileIndex = i;
+					files.push_back(File(Common::String((const char *)(hdr + 30)), newEntry));
+
+					pos += newEntry.compressedSize;
+					if (pos > size) {
+						pos -= size;
+						break;
+					}
+				} else {
+					uint32 filestrlen = READ_LE_UINT32(hdr + 28);
+					pos += (kHeaderSize2 + filestrlen - m);
+				}
+			}
+			tmpFile.close();
+		}
+	}
+
+	archives.clear();
+	
+	return true;
+}
+
+Common::SeekableReadStream *ResLoaderInsHof::loadFileFromArchive(const Common::String &file, Common::SeekableReadStream *archive, const ResFileEntry entry) const {
+	if (archive) {
+		delete archive;
+		archive = 0;
+	}
+
+	uint8 *outbuffer = (uint8 *)malloc(entry.size);
+	assert(outbuffer);
+
+	if (!_fileCache.getData(entry, outbuffer)) {
+		Common::File tmpFile;
+		char filename[13];
+		sprintf(filename, "WESTWOOD.%03d", entry.fileIndex);
+
+		if (!tmpFile.open(filename)) {
+			free(outbuffer);
+			return 0;
+		}
+
+		tmpFile.seek(entry.offset);
+
+		uint8 *inbuffer = new uint8[entry.compressedSize];
+		assert(inbuffer);
+
+		if ((entry.offset + entry.compressedSize) > tmpFile.size()) {
+			// this is for files that are split between two archive files
+			uint32 a = tmpFile.size() - entry.offset;
+			uint32 b = entry.compressedSize - a;
+				
+			tmpFile.read(inbuffer, a);
+			tmpFile.close();
+
+			filename[strlen(filename) - 1]++;
+
+			if (!tmpFile.open(filename))
+				return 0;
+			tmpFile.seek(1);
+			tmpFile.read(inbuffer + a, b);
+		} else {
+			tmpFile.read(inbuffer, entry.compressedSize);
+		}
+
+		tmpFile.close();
+
+		FileExpander().process(outbuffer, inbuffer, entry.size, entry.compressedSize);
+		delete[] inbuffer;
+
+		if (entry.size > INS_CACHE_THRESHOLD)
+			_fileCache.add(entry, outbuffer);
+	}
+	
+	Common::MemoryReadStream *stream = new Common::MemoryReadStream(outbuffer, entry.size, true);
+	assert(stream);	
+	
+	return stream;
+}
+
+class ResLoaderInsMalcolm : public ResArchiveLoader {
+public:
+	bool checkFilename(Common::String filename) const;
+	bool isLoadable(const Common::String &filename, Common::SeekableReadStream &stream) const;
+	bool loadFile(const Common::String &filename, Common::SeekableReadStream &stream, FileList &files) const;
+	Common::SeekableReadStream *loadFileFromArchive(const Common::String &file, Common::SeekableReadStream *archive, const ResFileEntry entry) const;
+
+	ResFileEntry::kType getType() const {
+		return ResFileEntry::kInsMal;
+	}
+};
+
+bool ResLoaderInsMalcolm::checkFilename(Common::String filename) const {
 	filename.toUppercase();
-	return (filename.hasSuffix(".001"));
+	if (!filename.hasSuffix(".001"))
+		return false;
+	filename.insertChar('2', filename.size() - 1);
+	filename.deleteLastChar();
+	if (Common::File::exists(filename))
+		return false;
+	return true;
 }
 
-bool ResLoaderIns::isLoadable(const Common::String &filename, Common::SeekableReadStream &stream) const {
+bool ResLoaderInsMalcolm::isLoadable(const Common::String &filename, Common::SeekableReadStream &stream) const {
 	stream.seek(3);
 	uint32 size = stream.readUint32LE();
 
@@ -600,7 +1387,7 @@ bool ResLoaderIns::isLoadable(const Common::String &filename, Common::SeekableRe
 	return (buffer[0] == 0x0D && buffer[1] == 0x0A);
 }
 
-bool ResLoaderIns::loadFile(const Common::String &filename, Common::SeekableReadStream &stream, FileList &files) const {
+bool ResLoaderInsMalcolm::loadFile(const Common::String &filename, Common::SeekableReadStream &stream, FileList &files) const {
 	Common::List<Common::String> filenames;
 
 	// thanks to eriktorbjorn for this code (a bit modified though)
@@ -645,7 +1432,7 @@ bool ResLoaderIns::loadFile(const Common::String &filename, Common::SeekableRead
 	return true;
 }
 
-Common::SeekableReadStream *ResLoaderIns::loadFileFromArchive(const Common::String &file, Common::SeekableReadStream *archive, const ResFileEntry entry) const {
+Common::SeekableReadStream *ResLoaderInsMalcolm::loadFileFromArchive(const Common::String &file, Common::SeekableReadStream *archive, const ResFileEntry entry) const {
 	assert(archive);
 
 	archive->seek(entry.offset, SEEK_SET);
@@ -738,7 +1525,9 @@ Common::SeekableReadStream *ResLoaderTlk::loadFileFromArchive(const Common::Stri
 
 void Resource::initializeLoaders() {
 	_loaders.push_back(LoaderList::value_type(new ResLoaderPak()));
-	_loaders.push_back(LoaderList::value_type(new ResLoaderIns()));
+	_loaders.push_back(LoaderList::value_type(new ResLoaderInsKyra()));
+	_loaders.push_back(LoaderList::value_type(new ResLoaderInsHof()));
+	_loaders.push_back(LoaderList::value_type(new ResLoaderInsMalcolm()));
 	_loaders.push_back(LoaderList::value_type(new ResLoaderTlk()));
 }
 
diff --git a/engines/kyra/resource.h b/engines/kyra/resource.h
index a8de21b5ca..90405690a4 100644
--- a/engines/kyra/resource.h
+++ b/engines/kyra/resource.h
@@ -41,6 +41,15 @@
 
 namespace Kyra {
 
+struct InsHofArchive {
+	Common::String filename;
+	uint32 firstFile;
+	uint32 startOffset;
+	uint32 lastFile;
+	uint32 endOffset;
+	uint32 totalSize;
+};
+
 struct ResFileEntry {
 	Common::String parent;
 	uint32 size;
@@ -52,12 +61,17 @@ struct ResFileEntry {
 	enum kType {
 		kRaw = 0,
 		kPak = 1,
-		kIns = 2,
-		kTlk = 3,
+		kInsKyra = 2,
+		kInsHof = 3,
+		kInsMal = 4,
+		kTlk = 5,
 		kAutoDetect
 	};
 	kType type;
 	uint32 offset;
+
+	int fileIndex;
+	uint32 compressedSize;
 };
 
 typedef Common::HashMap<Common::String, ResFileEntry, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> ResFileMap;
@@ -271,7 +285,7 @@ public:
 	bool prefetchId(int id);
 	void unloadId(int id);
 private:
-	void outputError();
+	void outputError(const Common::String &error);
 
 	KyraEngine_v1 *_vm;
 
diff --git a/engines/kyra/scene_lok.cpp b/engines/kyra/scene_lok.cpp
index 085332b525..e4ae67f751 100644
--- a/engines/kyra/scene_lok.cpp
+++ b/engines/kyra/scene_lok.cpp
@@ -295,13 +295,13 @@ int KyraEngine_LoK::setCharacterPosition(int character, int *facingTable) {
 	debugC(9, kDebugLevelMain, "KyraEngine_LoK::setCharacterPosition(%d, %p)", character, (const void *)facingTable);
 
 	if (character == 0) {
-		_currentCharacter->x1 += _charXPosTable[_currentCharacter->facing];
-		_currentCharacter->y1 += _charYPosTable[_currentCharacter->facing];
+		_currentCharacter->x1 += _charAddXPosTable[_currentCharacter->facing];
+		_currentCharacter->y1 += _charAddYPosTable[_currentCharacter->facing];
 		setCharacterPositionHelper(0, facingTable);
 		return 1;
 	} else {
-		_characterList[character].x1 += _charXPosTable[_characterList[character].facing];
-		_characterList[character].y1 += _charYPosTable[_characterList[character].facing];
+		_characterList[character].x1 += _charAddXPosTable[_characterList[character].facing];
+		_characterList[character].y1 += _charAddYPosTable[_characterList[character].facing];
 		if (_characterList[character].sceneId == _currentCharacter->sceneId)
 			setCharacterPositionHelper(character, 0);
 	}
@@ -1009,8 +1009,8 @@ int KyraEngine_LoK::changeScene(int facing) {
 			return 0;
 	}
 
-	int xpos = _charXPosTable[facing] + _currentCharacter->x1;
-	int ypos = _charYPosTable[facing] + _currentCharacter->y1;
+	int xpos = _charAddXPosTable[facing] + _currentCharacter->x1;
+	int ypos = _charAddYPosTable[facing] + _currentCharacter->y1;
 
 	if (xpos >= 12 && xpos <= 308) {
 		if (!lineIsPassable(xpos, ypos))
diff --git a/engines/kyra/scene_v2.cpp b/engines/kyra/scene_v2.cpp
index 7072cfc9a5..3bf81bfb39 100644
--- a/engines/kyra/scene_v2.cpp
+++ b/engines/kyra/scene_v2.cpp
@@ -98,7 +98,7 @@ int KyraEngine_v2::findWay(int x, int y, int toX, int toY, int *moveTable, int m
 		temp = pathfinderInitPositionIndexTable(temp, x, y);
 		pathfinderFinializePath(moveTable, temp, x, y, moveTableSize);
 		usePostProcess = false;
-	} 
+	}
 	return usePostProcess ? size : getMoveTableSize(moveTable);
 }
 
@@ -106,13 +106,14 @@ bool KyraEngine_v2::directLinePassable(int x, int y, int toX, int toY) {
 	debugC(9, kDebugLevelMain, "KyraEngine_v2::directLinePassable(%d, %d, %d, %d)", x, y, toX, toY);
 	Screen *scr = screen();
 
-	while (x != toX && y != toY) {
+	while (x != toX || y != toY) {
 		int facing = getFacingFromPointToPoint(x, y, toX, toY);
 		x += _addXPosTable[facing];
 		y += _addYPosTable[facing];
 		if (!scr->getShapeFlag1(x, y))
 			return false;
 	}
+
 	return true;
 }
 
diff --git a/engines/kyra/script_hof.cpp b/engines/kyra/script_hof.cpp
index d2b6b08183..91fbfb3e49 100644
--- a/engines/kyra/script_hof.cpp
+++ b/engines/kyra/script_hof.cpp
@@ -760,7 +760,7 @@ int KyraEngine_HoF::o2_showItemString(EMCState *script) {
 
 int KyraEngine_HoF::o2_isAnySoundPlaying(EMCState *script) {
 	debugC(3, kDebugLevelScriptFuncs, "KyraEngine_HoF::o2_isAnySoundPlaying(%p) ()", (const void *)script);
-	return _sound->voiceIsPlaying();
+	return _sound->voiceIsPlaying() ? 1 : 0;
 }
 
 int KyraEngine_HoF::o2_setDrawNoShapeFlag(EMCState *script) {
@@ -800,7 +800,7 @@ int KyraEngine_HoF::o2_showLetter(EMCState *script) {
 	_screen->fadeToBlack(0x14);
 	
 	sprintf(filename, "LETTER%.1d.", letter);
-	strcat(filename, _languageExtension[_lang]);
+	strcat(filename, (_flags.isTalkie || _flags.platform == Common::kPlatformFMTowns || _lang) ? _languageExtension[_lang] : "TXT");
 
 	uint8 *letterBuffer = _res->fileData(filename, 0);
 	if (letterBuffer) {
diff --git a/engines/kyra/script_lok.cpp b/engines/kyra/script_lok.cpp
index 670c7282e3..efa0f8e48f 100644
--- a/engines/kyra/script_lok.cpp
+++ b/engines/kyra/script_lok.cpp
@@ -35,6 +35,7 @@
 #include "kyra/animator_lok.h"
 #include "kyra/text.h"
 #include "kyra/timer.h"
+#include "kyra/sound.h"
 
 namespace Kyra {
 int KyraEngine_LoK::o1_magicInMouseItem(EMCState *script) {
@@ -320,9 +321,20 @@ int KyraEngine_LoK::o1_setBrandonStatusBit(EMCState *script) {
 }
 
 int KyraEngine_LoK::o1_delaySecs(EMCState *script) {
-	debugC(3, kDebugLevelScriptFuncs, "KyraEngine_LoK::o1_delaySecs(%p) (%d)", (const void *)script, stackPos(0));
-	if (stackPos(0) > 0 && !_skipFlag)
-		delay(stackPos(0)*1000, true);
+	if (_flags.isTalkie && speechEnabled()) {
+		debugC(3, kDebugLevelScriptFuncs, "KyraEngine_LoK::o1_voiceDelay(%p) (%d)", (const void *)script, stackPos(0));
+		if (stackPos(0) == 0) {
+			snd_voiceWaitForFinish(true);
+		} else if (stackPos(0) < 0) {
+			uint32 time = ABS(stackPos(0)) * _tickLength;
+			delay(time, true);
+		}
+	} else {
+		debugC(3, kDebugLevelScriptFuncs, "KyraEngine_LoK::o1_delaySecs(%p) (%d)", (const void *)script, stackPos(0));
+		if (stackPos(0) >= 0 && !_skipFlag)
+			delay(stackPos(0)*1000, true);
+	}
+
 	_skipFlag = false;
 	return 0;
 }
@@ -700,7 +712,10 @@ int KyraEngine_LoK::o1_displayWSAFrameOnHidPage(EMCState *script) {
 }
 
 int KyraEngine_LoK::o1_displayWSASequentialFrames(EMCState *script) {
-	debugC(3, kDebugLevelScriptFuncs, "KyraEngine_LoK::o1_displayWSASequentialFrames(%p) (%d, %d, %d, %d, %d, %d, %d)", (const void *)script, stackPos(0), stackPos(1), stackPos(2), stackPos(3), stackPos(4), stackPos(5), stackPos(6));
+	if (_flags.isTalkie)
+		debugC(3, kDebugLevelScriptFuncs, "KyraEngine_LoK::o1_displayWSASequentialFrames(%p) (%d, %d, %d, %d, %d, %d, %d, %d)", (const void *)script, stackPos(0), stackPos(1), stackPos(2), stackPos(3), stackPos(4), stackPos(5), stackPos(6), stackPos(7));
+	else
+		debugC(3, kDebugLevelScriptFuncs, "KyraEngine_LoK::o1_displayWSASequentialFrames(%p) (%d, %d, %d, %d, %d, %d, %d)", (const void *)script, stackPos(0), stackPos(1), stackPos(2), stackPos(3), stackPos(4), stackPos(5), stackPos(6));
 	int startFrame = stackPos(0);
 	int endFrame = stackPos(1);
 	int xpos = stackPos(2);
@@ -708,6 +723,40 @@ int KyraEngine_LoK::o1_displayWSASequentialFrames(EMCState *script) {
 	int waitTime = stackPos(4);
 	int wsaIndex = stackPos(5);
 	int maxTime = stackPos(6);
+
+	if (_flags.isTalkie) {
+		int specialTime = stackPos(7);
+		if (specialTime) {
+			uint32 voiceTime = snd_getVoicePlayTime();
+			if (voiceTime) {
+				int displayFrames = ABS(endFrame-startFrame)+1;
+				displayFrames *= maxTime;
+				assert(displayFrames != 0);
+
+				bool voiceSync = false;
+
+				if (specialTime < 0) {
+					voiceSync = true;
+					specialTime = ABS(specialTime);
+				}
+
+				voiceTime *= specialTime;
+				voiceTime /= 100;
+
+				if (voiceSync) {
+					uint32 voicePlayedTime = _sound->voicePlayedTime(_speechFile.c_str());
+					if (voicePlayedTime >= voiceTime)
+						voiceTime = 0;
+					else
+						voiceTime -= voicePlayedTime;
+				}
+
+				waitTime = voiceTime / displayFrames;
+				waitTime /= _tickLength;
+			}
+		}
+	}
+
 	if (maxTime - 1 <= 0)
 		maxTime = 1;
 
@@ -734,7 +783,8 @@ int KyraEngine_LoK::o1_displayWSASequentialFrames(EMCState *script) {
 			while (endFrame >= frame) {
 				uint32 continueTime = waitTime * _tickLength + _system->getMillis();
 				_movieObjects[wsaIndex]->displayFrame(frame);
-				_animator->_updateScreen = true;
+				if (waitTime)
+					_animator->_updateScreen = true;
 				while (_system->getMillis() < continueTime) {
 					_sprites->updateSceneAnims();
 					_animator->updateAllObjectShapes();
@@ -751,7 +801,8 @@ int KyraEngine_LoK::o1_displayWSASequentialFrames(EMCState *script) {
 			while (endFrame <= frame) {
 				uint32 continueTime = waitTime * _tickLength + _system->getMillis();
 				_movieObjects[wsaIndex]->displayFrame(frame);
-				_animator->_updateScreen = true;
+				if (waitTime)
+					_animator->_updateScreen = true;
 				while (_system->getMillis() < continueTime) {
 					_sprites->updateSceneAnims();
 					_animator->updateAllObjectShapes();
@@ -1691,7 +1742,7 @@ int KyraEngine_LoK::o1_pauseMusicSeconds(EMCState *script) {
 	debugC(3, kDebugLevelScriptFuncs, "KyraEngine_LoK::o1_pauseMusicSeconds(%p) ()", (const void *)script);
 	// if music disabled
 	//     return
-	o1_delaySecs(script);
+	delay(stackPos(0)*1000, true);
 	return 0;
 }
 
diff --git a/engines/kyra/script_v1.cpp b/engines/kyra/script_v1.cpp
index 7881605b9e..f74c7e3560 100644
--- a/engines/kyra/script_v1.cpp
+++ b/engines/kyra/script_v1.cpp
@@ -96,9 +96,9 @@ int KyraEngine_v1::o1_playWanderScoreViaMap(EMCState *script) {
 	return 0;
 }
 
-int	KyraEngine_v1::o1_fillRect(EMCState *script) {
+int KyraEngine_v1::o1_fillRect(EMCState *script) {
 	debugC(3, kDebugLevelScriptFuncs, "KyraEngine_v1::o1_fillRect(%p) (%d, %d, %d, %d, %d, %d)", (const void *)script, stackPos(0), stackPos(1), stackPos(2), stackPos(3), stackPos(4), stackPos(5));
-	screen()->fillRect(stackPos(1), stackPos(2), stackPos(1)+stackPos(3), stackPos(2)+stackPos(4), stackPos(5), stackPos(0));
+	screen()->fillRect(stackPos(1), stackPos(2), stackPos(3), stackPos(4), stackPos(5), stackPos(0));
 	return 0;
 }
 
diff --git a/engines/kyra/sequences_hof.cpp b/engines/kyra/sequences_hof.cpp
index 3e9f6030ac..0751fc15db 100644
--- a/engines/kyra/sequences_hof.cpp
+++ b/engines/kyra/sequences_hof.cpp
@@ -231,7 +231,7 @@ void KyraEngine_HoF::seq_playSequences(int startSeq, int endSeq) {
 			_seqFrameDelay = cseq.frameDelay;
 			_seqEndTime = _system->getMillis() + _seqFrameDelay * _tickLength;
 			while (!((skipFlag() && allowSkip) || _quitFlag || (_abortIntroFlag && allowSkip) || _menuChoice)) {
-				uint32 starttime = _system->getMillis();
+				_seqSubFrameStartTime = _system->getMillis();
 				seq_processWSAs();
 				if (cb)
 					(this->*cb)(0, 0, 0, 0);
@@ -246,8 +246,8 @@ void KyraEngine_HoF::seq_playSequences(int startSeq, int endSeq) {
 				if (now >= _seqEndTime && !_seqSubframePlaying)
 					break;
 
-				uint32 tdiff = _seqEndTime - starttime;
-				int32 dly = _tickLength - (now - starttime);
+				uint32 tdiff = _seqEndTime - _seqSubFrameStartTime;
+				int32 dly = _tickLength - (now - _seqSubFrameStartTime);
 				if (dly > 0)
 					delay(MIN<uint32>(dly, tdiff));
 			}
@@ -263,7 +263,7 @@ void KyraEngine_HoF::seq_playSequences(int startSeq, int endSeq) {
 		_seqEndTime = _system->getMillis() + dl;
 
 		while (!((skipFlag() && allowSkip) || _quitFlag || (_abortIntroFlag && allowSkip) || _menuChoice)) {
-			uint32 starttime = _system->getMillis();
+			_seqSubFrameStartTime = _system->getMillis();
 			seq_processWSAs();
 
 			_screen->copyPage(2, 0);
@@ -275,8 +275,8 @@ void KyraEngine_HoF::seq_playSequences(int startSeq, int endSeq) {
 				break;
 			}
 
-			uint32 tdiff = _seqEndTime - starttime;
-			int32 dly = _tickLength - (now - starttime);
+			uint32 tdiff = _seqEndTime - _seqSubFrameStartTime;
+			int32 dly = _tickLength - (now - _seqSubFrameStartTime);
 			if (dly > 0)
 				delay(MIN<uint32>(dly, tdiff));
 		}
@@ -289,13 +289,7 @@ void KyraEngine_HoF::seq_playSequences(int startSeq, int endSeq) {
 			_sound->voiceStop();
 		}
 
-		if (_flags.isDemo && !_flags.isTalkie) {
-			if (seqNum == kSequenceDemoFisher) {
-				_abortIntroFlag = false;
-				resetSkipFlag();
-				seqNum = kSequenceDemoVirgin;
-			}
-		} else {
+		if (!_flags.isDemo || _flags.isTalkie) {
 			if ((seqNum != kSequenceTitle && seqNum < kSequenceZanfaun &&
 			(_abortIntroFlag || skipFlag())) || seqNum == kSequenceZanfaun) {
 				_abortIntroFlag = false;
@@ -319,8 +313,13 @@ void KyraEngine_HoF::seq_playSequences(int startSeq, int endSeq) {
 		}
 	}
 
+	if (_flags.isDemo && !_flags.isTalkie) {
+		_eventList.clear();
+		_screen->fadeToBlack();
+	}
+	
 	if (!_menuChoice)
-		delay(1000);
+		delay(1200);
 
 	_screen->setCurPage(oldPage);
 	_screen->showMouse();
@@ -375,13 +374,14 @@ int KyraEngine_HoF::seq_introOverview(WSAMovie_v2 *wsaObj, int x, int y, int frm
 
 	uint8 *tmpPal = &(_screen->getPalette(3)[0x101]);
 	memset(tmpPal, 0, 256);
-	uint32 endtime = 0, now = 0;
+	_seqSubFrameEndTimeInternal = 0;
+	uint32 now = 0;
 
 	switch (_seqFrameCounter) {
 	case 0:
 		_seqSubframePlaying = true;
 		_sound->playTrack(4);
-		endtime = _system->getMillis() + 60 * _tickLength;
+		_seqSubFrameEndTimeInternal = _system->getMillis() + 60 * _tickLength;
 
 		_seqTextColor[1] = _screen->findLeastDifferentColor(_seqTextColorPresets, _screen->getPalette(0) + 3, 255) & 0xff;
 		memset(_seqTextColorMap, _seqTextColor[1], 16);
@@ -390,8 +390,8 @@ int KyraEngine_HoF::seq_introOverview(WSAMovie_v2 *wsaObj, int x, int y, int frm
 		_screen->setTextColorMap(_seqTextColorMap);
 
 		now = _system->getMillis();
-		if (endtime > now)
-			delay(endtime - now);
+		if (_seqSubFrameEndTimeInternal > now)
+			delay(_seqSubFrameEndTimeInternal - now);
 		break;
 
 	case 1:
@@ -830,7 +830,7 @@ int KyraEngine_HoF::seq_introHand3(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
 }
 
 int KyraEngine_HoF::seq_finaleFunters(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
-	uint32 endtime = 0;
+	_seqSubFrameEndTimeInternal = 0;
 	int chatX = 0;
 	int chatY = 0;
 	int chatW = 0;
@@ -851,12 +851,12 @@ int KyraEngine_HoF::seq_finaleFunters(WSAMovie_v2 *wsaObj, int x, int y, int frm
 		_seqTextColor[0] = _seqTextColorMap[1] = 0xff;
 		_screen->setTextColorMap(_seqTextColorMap);
 
-		endtime = _system->getMillis() + 480 * _tickLength;
+		_seqSubFrameEndTimeInternal = _system->getMillis() + 480 * _tickLength;
 		seq_printCreditsString(81, 240, 70, _seqTextColorMap, 252);
 		seq_printCreditsString(82, 240, 90, _seqTextColorMap, _seqTextColor[0]);
 		_screen->copyPage(2, 12);
-		delay(endtime - _system->getMillis());
 		seq_playTalkText(_flags.isTalkie ? 28 : 24);
+		delay(_seqSubFrameEndTimeInternal - _system->getMillis());
 		_seqTextColor[0] = 1;
 
 		if (_flags.isTalkie) {
@@ -914,7 +914,7 @@ int KyraEngine_HoF::seq_finaleFunters(WSAMovie_v2 *wsaObj, int x, int y, int frm
 }
 
 int KyraEngine_HoF::seq_finaleFerb(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
-	uint32 endtime = 0;
+	_seqSubFrameEndTimeInternal = 0;
 	int chatX = 0;
 	int chatY = 0;
 	int chatW = 0;
@@ -925,7 +925,7 @@ int KyraEngine_HoF::seq_finaleFerb(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
 	switch (frm) {
 	case -2:
 		seq_sequenceCommand(9);
-		endtime = _system->getMillis() + 480 * _tickLength;
+		_seqSubFrameEndTimeInternal = _system->getMillis() + 480 * _tickLength;
 		seq_printCreditsString(34, 240, _flags.isTalkie ? 60 : 40, _seqTextColorMap, 252);
 		seq_printCreditsString(35, 240, _flags.isTalkie ? 70 : 50, _seqTextColorMap, _seqTextColor[0]);
 		seq_printCreditsString(36, 240, _flags.isTalkie ? 90 : 70, _seqTextColorMap, 252);
@@ -934,7 +934,7 @@ int KyraEngine_HoF::seq_finaleFerb(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
 		seq_printCreditsString(39, 240, _flags.isTalkie ? 130 : 120, _seqTextColorMap, _seqTextColor[0]);
 		if (_flags.platform == Common::kPlatformFMTowns || _flags.platform == Common::kPlatformPC98)
 			seq_printCreditsString(103, 240, 130, _seqTextColorMap, _seqTextColor[0]);
-		delay(endtime - _system->getMillis());
+		delay(_seqSubFrameEndTimeInternal - _system->getMillis());
 		_seqEndTime = 0;
 		break;
 
@@ -998,7 +998,7 @@ int KyraEngine_HoF::seq_finaleFerb(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
 }
 
 int KyraEngine_HoF::seq_finaleFish(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
-	uint32 endtime = 0;
+	_seqSubFrameEndTimeInternal = 0;
 	int chatX = 0;
 	int chatY = 0;
 	int chatW = 0;
@@ -1007,7 +1007,7 @@ int KyraEngine_HoF::seq_finaleFish(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
 	switch (frm) {
 	case -2:
 		seq_sequenceCommand(9);
-		endtime = _system->getMillis() + 480 * _tickLength;
+		_seqSubFrameEndTimeInternal = _system->getMillis() + 480 * _tickLength;
 
 		seq_printCreditsString(40, 240, _flags.isTalkie ? 55 : 40, _seqTextColorMap, 252);
 		seq_printCreditsString(41, 240, _flags.isTalkie ? 65 : 50, _seqTextColorMap, _seqTextColor[0]);
@@ -1016,7 +1016,7 @@ int KyraEngine_HoF::seq_finaleFish(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
 		seq_printCreditsString(44, 240, _flags.isTalkie ? 105 : 90, _seqTextColorMap, _seqTextColor[0]);
 		seq_printCreditsString(93, 240, _flags.isTalkie ? 125 : 110, _seqTextColorMap, 252);
 		seq_printCreditsString(94, 240, _flags.isTalkie ? 135 : 120, _seqTextColorMap, _seqTextColor[0]);
-		delay(endtime - _system->getMillis());
+		delay(_seqSubFrameEndTimeInternal - _system->getMillis());
 		_seqEndTime = 0;
 		break;
 
@@ -1075,7 +1075,7 @@ int KyraEngine_HoF::seq_finaleFish(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
 }
 
 int KyraEngine_HoF::seq_finaleFheep(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
-	uint32 endtime = 0;
+	_seqSubFrameEndTimeInternal = 0;
 	int chatX = 0;
 	int chatY = 0;
 	int chatW = 0;
@@ -1089,7 +1089,7 @@ int KyraEngine_HoF::seq_finaleFheep(WSAMovie_v2 *wsaObj, int x, int y, int frm)
 		_screen->copyPage(2, 0);
 		_screen->updateScreen();
 		seq_sequenceCommand(9);
-		endtime = _system->getMillis() + 480 * _tickLength;
+		_seqSubFrameEndTimeInternal = _system->getMillis() + 480 * _tickLength;
 		seq_printCreditsString(49, 240, 20, _seqTextColorMap, 252);
 		seq_printCreditsString(50, 240, 30, _seqTextColorMap, _seqTextColor[0]);
 		seq_printCreditsString(51, 240, 40, _seqTextColorMap, _seqTextColor[0]);
@@ -1106,7 +1106,7 @@ int KyraEngine_HoF::seq_finaleFheep(WSAMovie_v2 *wsaObj, int x, int y, int frm)
 		seq_printCreditsString(63, 240, 150, _seqTextColorMap, _seqTextColor[0]);
 		seq_printCreditsString(64, 240, 160, _seqTextColorMap, _seqTextColor[0]);
 
-		delay(endtime - _system->getMillis());
+		delay(_seqSubFrameEndTimeInternal - _system->getMillis());
 		_seqEndTime = 0;
 		break;
 
@@ -1157,7 +1157,7 @@ int KyraEngine_HoF::seq_finaleFheep(WSAMovie_v2 *wsaObj, int x, int y, int frm)
 }
 
 int KyraEngine_HoF::seq_finaleFarmer(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
-	uint32 endtime = 0;
+	_seqSubFrameEndTimeInternal = 0;
 	int chatX = 0;
 	int chatY = 0;
 	int chatW = 0;
@@ -1169,7 +1169,7 @@ int KyraEngine_HoF::seq_finaleFarmer(WSAMovie_v2 *wsaObj, int x, int y, int frm)
 		_screen->copyPage(2, 0);
 		_screen->updateScreen();
 		seq_sequenceCommand(9);
-		endtime = _system->getMillis() + 480 * _tickLength;
+		_seqSubFrameEndTimeInternal = _system->getMillis() + 480 * _tickLength;
 		seq_printCreditsString(45, 240, 40, _seqTextColorMap, 252);
 		seq_printCreditsString(46, 240, 50, _seqTextColorMap, _seqTextColor[0]);
 		seq_printCreditsString(47, 240, 60, _seqTextColorMap, _seqTextColor[0]);
@@ -1182,7 +1182,7 @@ int KyraEngine_HoF::seq_finaleFarmer(WSAMovie_v2 *wsaObj, int x, int y, int frm)
 		seq_printCreditsString(69, 240, 150, _seqTextColorMap, _seqTextColor[0]);
 		if (_flags.platform == Common::kPlatformFMTowns || _flags.platform == Common::kPlatformPC98)
 			seq_printCreditsString(104, 240, 160, _seqTextColorMap, _seqTextColor[0]);
-		delay(endtime - _system->getMillis());
+		delay(_seqSubFrameEndTimeInternal - _system->getMillis());
 		_seqEndTime = 0;
 		break;
 
@@ -1227,7 +1227,7 @@ int KyraEngine_HoF::seq_finaleFarmer(WSAMovie_v2 *wsaObj, int x, int y, int frm)
 }
 
 int KyraEngine_HoF::seq_finaleFuards(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
-	uint32 endtime = 0;
+	_seqSubFrameEndTimeInternal = 0;
 	int chatX = 0;
 	int chatY = 0;
 	int chatW = 0;
@@ -1240,7 +1240,7 @@ int KyraEngine_HoF::seq_finaleFuards(WSAMovie_v2 *wsaObj, int x, int y, int frm)
 	switch (frm) {
 	case -2:
 		seq_sequenceCommand(9);
-		endtime = _system->getMillis() + 480 * _tickLength;
+		_seqSubFrameEndTimeInternal = _system->getMillis() + 480 * _tickLength;
 		seq_printCreditsString(70, 240, 20, _seqTextColorMap, 252);
 		seq_printCreditsString(71, 240, 30, _seqTextColorMap, _seqTextColor[0]);
 		seq_printCreditsString(72, 240, 40, _seqTextColorMap, _seqTextColor[0]);
@@ -1255,7 +1255,7 @@ int KyraEngine_HoF::seq_finaleFuards(WSAMovie_v2 *wsaObj, int x, int y, int frm)
 		seq_printCreditsString(90, 240, 130, _seqTextColorMap, _seqTextColor[0]);
 		seq_printCreditsString(91, 240, 140, _seqTextColorMap, _seqTextColor[0]);
 		seq_printCreditsString(92, 240, 150, _seqTextColorMap, _seqTextColor[0]);
-		delay(endtime - _system->getMillis());
+		delay(_seqSubFrameEndTimeInternal - _system->getMillis());
 		_seqEndTime = 0;
 		break;
 
@@ -1327,7 +1327,7 @@ int KyraEngine_HoF::seq_finaleFuards(WSAMovie_v2 *wsaObj, int x, int y, int frm)
 }
 
 int KyraEngine_HoF::seq_finaleFirates(WSAMovie_v2 *wsaObj, int x, int y, int frm) {
-	uint32 endtime = 0;
+	_seqSubFrameEndTimeInternal = 0;
 	int chatX = 0;
 	int chatY = 0;
 	int chatW = 0;
@@ -1339,7 +1339,7 @@ int KyraEngine_HoF::seq_finaleFirates(WSAMovie_v2 *wsaObj, int x, int y, int frm
 		_screen->copyPage(2, 0);
 		_screen->updateScreen();
 		seq_sequenceCommand(9);
-		endtime = _system->getMillis() + 480 * _tickLength;
+		_seqSubFrameEndTimeInternal = _system->getMillis() + 480 * _tickLength;
 		seq_printCreditsString(76, 240, 40, _seqTextColorMap, 252);
 		seq_printCreditsString(77, 240, 50, _seqTextColorMap, 252);
 		seq_printCreditsString(78, 240, 60, _seqTextColorMap, _seqTextColor[0]);
@@ -1349,7 +1349,7 @@ int KyraEngine_HoF::seq_finaleFirates(WSAMovie_v2 *wsaObj, int x, int y, int frm
 		seq_printCreditsString(85, 240, 110, _seqTextColorMap, _seqTextColor[0]);
 		seq_printCreditsString(99, 240, 130, _seqTextColorMap, 252);
 		seq_printCreditsString(100, 240, 140, _seqTextColorMap, _seqTextColor[0]);
-		delay(endtime - _system->getMillis());
+		delay(_seqSubFrameEndTimeInternal - _system->getMillis());
 		_seqEndTime = 0;
 		break;
 
@@ -1811,7 +1811,7 @@ uint32 KyraEngine_HoF::seq_activeTextsTimeLeft() {
 }
 
 void KyraEngine_HoF::seq_processWSAs() {
-	for (int i = 0; i <  8; i++) {
+	for (int i = 0; i < 8; i++) {
 		if (_activeWSA[i].flags != -1) {
 			if (seq_processNextSubFrame(i))
 				seq_resetActiveWSA(i);
@@ -2334,13 +2334,16 @@ void KyraEngine_HoF::seq_playWsaSyncDialogue(uint16 strIndex, uint16 vocIndex, i
 	int dur = int(strlen(_sequenceStrings[strIndex])) * (_flags.isTalkie ? 7 : 15);
 	int entry = textEnabled() ? seq_setTextEntry(strIndex, x, y, dur, width) : strIndex;
 	_activeText[entry].textcolor = textColor;
-	uint32 chatTimeout = _system->getMillis() + dur * _tickLength;
+	_seqWsaChatTimeout = _system->getMillis() + dur * _tickLength;
 	int curframe = firstframe;
 
-	if (vocIndex && speechEnabled())
+	if (vocIndex && speechEnabled()) {
+		while (_sound->voiceIsPlaying() && !skipFlag())
+			delay(4);
 		seq_playTalkText(vocIndex);
+	}
 
-	while (_system->getMillis() < chatTimeout && !(_abortIntroFlag || skipFlag())) {
+	while (_system->getMillis() < _seqWsaChatTimeout && !(_abortIntroFlag || skipFlag())) {
 		if (lastframe < 0) {
 			int t = ABS(lastframe);
 			if (t < curframe)
@@ -2350,7 +2353,7 @@ void KyraEngine_HoF::seq_playWsaSyncDialogue(uint16 strIndex, uint16 vocIndex, i
 		if (ABS(lastframe) < curframe)
 			curframe = firstframe;
 
-		uint32 frameTimeout = _seqEndTime = _system->getMillis() + _seqFrameDelay * _tickLength;
+		_seqWsaChatFrameTimeout = _seqEndTime = _system->getMillis() + _seqFrameDelay * _tickLength;
 		if (wsa) {
 			wsa->setDrawPage(2);
 			wsa->setX(wsaXpos);
@@ -2363,8 +2366,8 @@ void KyraEngine_HoF::seq_playWsaSyncDialogue(uint16 strIndex, uint16 vocIndex, i
 		seq_processText();
 
 		uint32 tm = _system->getMillis();
-		if (frameTimeout > tm && chatTimeout > tm)
-			delay(MIN(frameTimeout - tm, chatTimeout - tm));
+		if (_seqWsaChatFrameTimeout > tm && _seqWsaChatTimeout > tm)
+			delay(MIN(_seqWsaChatFrameTimeout - tm, _seqWsaChatTimeout - tm));
 
 		if (speechEnabled() && !textEnabled() && !snd_voiceIsPlaying())
 			break;
@@ -2377,11 +2380,8 @@ void KyraEngine_HoF::seq_playWsaSyncDialogue(uint16 strIndex, uint16 vocIndex, i
 	if (_abortIntroFlag || skipFlag())
 		_sound->voiceStop();
 
-	if (lastframe < 0) {
-		int t = ABS(lastframe);
-		if (t < curframe)
-			curframe = t;
-	}
+	if (ABS(lastframe) < curframe)
+		curframe = ABS(lastframe);
 
 	if (curframe == firstframe)
 		curframe++;
@@ -2395,27 +2395,46 @@ void KyraEngine_HoF::seq_displayScrollText(uint8 *data, const ScreenDim *d, int
 	if (!data)
 		return;
 
-	static const char mark[] = { 5, 13, 0};
+	static const char mark[] = { 5, 13, 0 };
 
 	_screen->clearPage(tempPage1);
 	_screen->clearPage(tempPage2);
 	_screen->copyRegion(d->sx << 3, d->sy, d->sx << 3, d->sy, d->w << 3, d->h, 0, tempPage1);
 
-	uint8 *tmp = new uint8[397];
-	memset(tmp, 0, 397);
-	uint8 **tmpStringTable = new uint8*[35];
+	struct ScrollTextData {
+		int16	x;
+		int16	y;
+		uint8	*text;
+		byte	unk1;
+		byte	height;
+		byte	adjust;
+
+		ScrollTextData() {
+			x = 0;      // 0  11
+			y = 0;		// 2  13
+			text = 0;	// 4  15
+			unk1 = 0;   // 8  19
+			height = 0; // 9  20
+			adjust = 0; // 10 21
+		}
+	};
+
+	ScrollTextData *textData = new ScrollTextData[36];
 	uint8 *ptr = data;
-	int strTblIndex = 0;
 
 	bool loop = true;
 	int cnt = 0;
 
 	while (loop) {
-		uint32 endTime = _system->getMillis() + speed * _tickLength;
+		_seqSubFrameEndTimeInternal = _system->getMillis() + speed * _tickLength;
 
 		while (cnt < 35 && *ptr) {
-			int m = cnt * 11;
-			uint16 cH = cnt ? READ_LE_UINT16(&tmp[m + 2]) + tmp[m + 9] + (tmp[m + 9] >> 3) : d->h;
+			uint16 cH;
+
+			if (cnt)
+				cH = textData[cnt].y + textData[cnt].height + (textData[cnt].height >> 3);
+			else
+				cH = d->h;
 
 			char *str = (char*)ptr;
 
@@ -2423,12 +2442,15 @@ void KyraEngine_HoF::seq_displayScrollText(uint8 *data, const ScreenDim *d, int
 			if (!ptr)
 				ptr = (uint8*)strchr(str, 0);
 
-			tmp[m + 19] = *ptr;
+			textData[cnt + 1].unk1 = *ptr;
 			*ptr = 0;
-			if (tmp[m + 19])
+			if (textData[cnt + 1].unk1)
 				ptr++;
 
-			tmp[m + 21] = (*str == 3 || *str == 4) ? tmp[m + 21] = *str++ : 0;
+			if (*str == 3 || *str == 4)
+				textData[cnt + 1].adjust = *str++;
+			else
+				textData[cnt + 1].adjust = 0;
 
 			_screen->setFont(fid1);
 
@@ -2439,18 +2461,25 @@ void KyraEngine_HoF::seq_displayScrollText(uint8 *data, const ScreenDim *d, int
 				str++;
 			}
 
-			tmp[m + 20] = _screen->getFontHeight();
+			textData[cnt + 1].height = _screen->getFontHeight();
 
-			WRITE_LE_UINT16(&tmp[m + 11], (tmp[m + 21] == 3) ? 157 - _screen->getTextWidth(str) :
-				((tmp[m + 21] == 4) ? 161 : (((d->w << 3) - _screen->getTextWidth(str)) >> 1) + 1));
+			switch (textData[cnt + 1].adjust) {
+			case 3:
+				textData[cnt + 1].x = 157 - _screen->getTextWidth(str);
+				break;
+			case 4:
+				textData[cnt + 1].x = 161;
+				break;
+			default:
+				textData[cnt + 1].x = (((d->w << 3) - _screen->getTextWidth(str)) >> 1) + 1;
+				break;
+			}
 
-			if (tmp[m + 8] == 5)
-				cH -= (tmp[m + 9] + (tmp[m + 9] >> 3));
+			if (textData[cnt].unk1 == 5)
+				cH -= (textData[cnt].height + (textData[cnt].height >> 3));
 
-			WRITE_LE_UINT16(&tmp[m + 13], cH);
-			WRITE_LE_UINT32(&tmp[m + 15], strTblIndex);
-			tmpStringTable[strTblIndex] = (uint8*) str;
-			strTblIndex = (strTblIndex + 1) % 35;
+			textData[cnt + 1].y = cH;
+			textData[cnt + 1].text = (uint8*) str;
 			cnt++;
 		}
 
@@ -2460,11 +2489,10 @@ void KyraEngine_HoF::seq_displayScrollText(uint8 *data, const ScreenDim *d, int
 		bool palCycle = 0;
 
 		while (cnt2 < cnt) {
-			int m = cnt2 * 11;
-			const char *str = (const char*)tmpStringTable[READ_LE_UINT32(&tmp[m + 15])];
+			const char *str = (const char*)textData[cnt2 + 1].text;
 			const char *str2 = str;
-			uint16 cW = READ_LE_UINT16(&tmp[m + 11]) - 10;
-			uint16 cH = READ_LE_UINT16(&tmp[m + 13]);
+			int16 cW = textData[cnt2 + 1].x - 10;
+			int16 cH = textData[cnt2 + 1].y;
 			int x = (d->sx << 3) + cW;
 			int y = d->sy + cH;
 			int col1 = 255;
@@ -2472,7 +2500,7 @@ void KyraEngine_HoF::seq_displayScrollText(uint8 *data, const ScreenDim *d, int
 			if (cH < d->h) {
 				_screen->setCurPage(tempPage2);
 				_screen->setFont(fid1);
-				if (tmp[m + 20] != _screen->getFontHeight())
+				if (textData[cnt2 + 1].height != _screen->getFontHeight())
 					_screen->setFont(fid2);
 
 				if (specialData) {
@@ -2503,18 +2531,18 @@ void KyraEngine_HoF::seq_displayScrollText(uint8 *data, const ScreenDim *d, int
 				_screen->setCurPage(0);
 			}
 
-			WRITE_LE_UINT16(&tmp[m + 13], READ_LE_UINT16(&tmp[m + 13]) - step);
+			textData[cnt2 + 1].y -= step;
 			cnt2++;
 		}
 
 		_screen->copyRegion(d->sx << 3, d->sy, d->sx << 3, d->sy, d->w << 3, d->h, tempPage2, 0);
 		_screen->updateScreen();
 
-		if ((int16)READ_LE_UINT16(&tmp[13]) < -10) {
-			tmpStringTable[tmp[15]] += strlen((char*)tmpStringTable[tmp[15]]);
-			tmpStringTable[tmp[15]][0] = tmp[19];
+		if (textData[1].y < -10) {
+			textData[1].text += strlen((char*)textData[1].text);
+			textData[1].text[0] = textData[1].unk1;
 			cnt--;
-			memcpy(&tmp[11], &tmp[22], cnt * 11);
+			memcpy(&textData[1], &textData[2], cnt * sizeof(ScrollTextData));
 		}
 
 		if (palCycle) {
@@ -2524,9 +2552,9 @@ void KyraEngine_HoF::seq_displayScrollText(uint8 *data, const ScreenDim *d, int
 			_screen->setScreenPalette(_screen->_currentPalette);
 		}
 
-		delayUntil(endTime);
+		delayUntil(_seqSubFrameEndTimeInternal);
 
-		if ((cnt < 36) && ((d->sy + d->h) > (READ_LE_UINT16(&tmp[cnt * 11 + 2]) + tmp[cnt * 11 + 9])) && !skipFlag()) {
+		if ((cnt < 36) && ((d->sy + d->h) > (textData[cnt].y + textData[cnt].height)) && !skipFlag()) {
 			resetSkipFlag();
 			delay(_tickLength * 500);
 			cnt = 0;
@@ -2542,8 +2570,7 @@ void KyraEngine_HoF::seq_displayScrollText(uint8 *data, const ScreenDim *d, int
 	_abortIntroFlag= false;
 	resetSkipFlag();
 
-	delete[] tmp;
-	delete[] tmpStringTable;
+	delete[] textData;
 }
 
 void KyraEngine_HoF::seq_scrollPage() {
@@ -2594,20 +2621,20 @@ void KyraEngine_HoF::seq_showStarcraftLogo() {
 	_screen->copyPage(2, 0);
 	_screen->fadeFromBlack();
 	for (int i = 1; i < endframe; i++) {
-		uint32 endTime = _system->getMillis() + 50;
+		_seqEndTime = _system->getMillis() + 50;
 		if (skipFlag())
 			break;
 		ci->displayFrame(i, 0);
 		_screen->copyPage(2, 0);
 		_screen->updateScreen();
-		delay(endTime - _system->getMillis());
+		delay(_seqEndTime - _system->getMillis());
 	}
 	if(!skipFlag()) {
-		uint32 endTime = _system->getMillis() + 50;
+		_seqEndTime = _system->getMillis() + 50;
 		ci->displayFrame(0, 0);
 		_screen->copyPage(2, 0);
 		_screen->updateScreen();
-		delay(endTime - _system->getMillis());
+		delay(_seqEndTime - _system->getMillis());
 	}
 	_screen->fadeToBlack();
 	_screen->showMouse();
@@ -2624,6 +2651,8 @@ void KyraEngine_HoF::seq_init() {
 
 	_res->unloadAllPakFiles();
 	_res->loadPakFile(StaticResource::staticDataFilename());
+	if (_flags.useInstallerPackage)
+		_res->loadPakFile("WESTWOOD.001");
 	_res->loadFileList(_sequencePakList, _sequencePakListSize);
 
 	int numShp = -1;
@@ -2783,3 +2812,4 @@ void KyraEngine_HoF::seq_makeBookAppear() {
 
 } // end of namespace Kyra
 
+
diff --git a/engines/kyra/sound.cpp b/engines/kyra/sound.cpp
index a8566a7309..8f9077705e 100644
--- a/engines/kyra/sound.cpp
+++ b/engines/kyra/sound.cpp
@@ -66,17 +66,14 @@ bool Sound::voiceFileIsPresent(const char *file) {
 	return false;
 }
 
-bool Sound::voicePlay(const char *file, bool isSfx) {
-	uint32 fileSize = 0;
-	byte *fileData = 0;
-	bool found = false;
+int32 Sound::voicePlay(const char *file, bool isSfx) {
 	char filenamebuffer[25];
 
 	int h = 0;
 	while (_mixer->isSoundHandleActive(_soundChannels[h].channelHandle) && h < kNumChannelHandles)
 		h++;
 	if (h >= kNumChannelHandles)
-		return false;
+		return 0;
 
 	Audio::AudioStream *audioStream = 0;
 
@@ -88,29 +85,29 @@ bool Sound::voicePlay(const char *file, bool isSfx) {
 		if (!stream)
 			continue;
 		audioStream = _supportedCodes[i].streamFunc(stream, true, 0, 0, 1);
-		found = true;
 		break;
 	}
 
-	if (!found) {
+	if (!audioStream) {
 		strcpy(filenamebuffer, file);
 		strcat(filenamebuffer, ".VOC");
 
-		fileData = _vm->resource()->fileData(filenamebuffer, &fileSize);
+		uint32 fileSize = 0;
+		byte *fileData = _vm->resource()->fileData(filenamebuffer, &fileSize);
 		if (!fileData)
-			return false;
+			return 0;
 
 		Common::MemoryReadStream vocStream(fileData, fileSize);
 		audioStream = Audio::makeVOCStream(vocStream);
+
+		delete[] fileData;
+		fileSize = 0;
 	}
 
 	_soundChannels[h].file = file;
 	_mixer->playInputStream(isSfx ? Audio::Mixer::kSFXSoundType : Audio::Mixer::kSpeechSoundType, &_soundChannels[h].channelHandle, audioStream);
 
-	delete[] fileData;
-	fileSize = 0;
-
-	return true;
+	return audioStream->getTotalPlayTime();
 }
 
 void Sound::voiceStop(const char *file) {
@@ -143,6 +140,18 @@ bool Sound::voiceIsPlaying(const char *file) {
 	return res;
 }
 
+uint32 Sound::voicePlayedTime(const char *file) {
+	if (!file)
+		return 0;
+
+	for (int i = 0; i < kNumChannelHandles; ++i) {
+		if (_soundChannels[i].file == file)
+			return _mixer->getSoundElapsedTime(_soundChannels[i].channelHandle);
+	}
+
+	return 0;
+}
+
 #pragma mark -
 
 SoundMidiPC::SoundMidiPC(KyraEngine_v1 *vm, Audio::Mixer *mixer, MidiDriver *driver) : Sound(vm, mixer) {
@@ -529,12 +538,15 @@ void KyraEngine_v1::snd_playWanderScoreViaMap(int command, int restart) {
 
 void KyraEngine_v1::snd_stopVoice() {
 	debugC(9, kDebugLevelMain | kDebugLevelSound, "KyraEngine_v1::snd_stopVoice()");
-	_sound->voiceStop(_speechFile.empty() ? 0 : _speechFile.c_str());
+	if (!_speechFile.empty()) {
+		_sound->voiceStop(_speechFile.c_str());
+		_speechFile.clear();
+	}
 }
 
 bool KyraEngine_v1::snd_voiceIsPlaying() {
 	debugC(9, kDebugLevelMain | kDebugLevelSound, "KyraEngine_v1::snd_voiceIsPlaying()");
-	return _sound->voiceIsPlaying(_speechFile.empty() ? 0 : _speechFile.c_str());
+	return _speechFile.empty() ? false : _sound->voiceIsPlaying(_speechFile.c_str());
 }
 
 // static res
diff --git a/engines/kyra/sound.h b/engines/kyra/sound.h
index 595619c7e9..2427a6cdde 100644
--- a/engines/kyra/sound.h
+++ b/engines/kyra/sound.h
@@ -174,9 +174,9 @@ public:
 	 *
 	 * @param file	file to be played
 	 * @param isSfx marks file as sfx instead of voice
-	 * @return channel the voice file is played on
+	 * @return playtime of the voice file (-1 marks unknown playtime)
 	 */
-	virtual bool voicePlay(const char *file, bool isSfx = false);
+	virtual int32 voicePlay(const char *file, bool isSfx = false);
 
 	/**
 	 * Checks if a voice is being played.
@@ -186,6 +186,13 @@ public:
 	bool voiceIsPlaying(const char *file = 0);
 
 	/**
+	 * Checks how long a voice has been playing
+	 *
+	 * @return time in milliseconds
+	 */
+	uint32 voicePlayedTime(const char *file);
+
+	/**
 	 * Stops playback of the current voice.
 	 */
 	void voiceStop(const char *file = 0);
@@ -449,7 +456,7 @@ public:
 	void haltTrack();
 	void beginFadeOut();
 
-	bool voicePlay(const char *file, bool isSfx = false);
+	int32 voicePlay(const char *file, bool isSfx = false);
 	void playSoundEffect(uint8) {}
 
 private:
diff --git a/engines/kyra/sound_lok.cpp b/engines/kyra/sound_lok.cpp
index 728013cdaa..8a1d16a6b1 100644
--- a/engines/kyra/sound_lok.cpp
+++ b/engines/kyra/sound_lok.cpp
@@ -67,7 +67,7 @@ void KyraEngine_LoK::snd_playVoiceFile(int id) {
 	assert(id >= 0 && id < 9999);
 	sprintf(vocFile, "%03d", id);
 	_speechFile = vocFile;
-	_sound->voicePlay(vocFile);
+	_speechPlayTime = _sound->voicePlay(vocFile);
 }
 
 void KyraEngine_LoK::snd_voiceWaitForFinish(bool ingame) {
@@ -80,4 +80,11 @@ void KyraEngine_LoK::snd_voiceWaitForFinish(bool ingame) {
 	}
 }
 
+uint32 KyraEngine_LoK::snd_getVoicePlayTime() {
+	debugC(9, kDebugLevelMain | kDebugLevelSound, "KyraEngine_LoK::snd_getVoicePlayTime()");
+	if (!snd_voiceIsPlaying())
+		return 0;
+	return (_speechPlayTime != -1 ? _speechPlayTime : 0);
+}
+
 } // end of namespace Kyra
diff --git a/engines/kyra/sound_towns.cpp b/engines/kyra/sound_towns.cpp
index 513f523194..4265533507 100644
--- a/engines/kyra/sound_towns.cpp
+++ b/engines/kyra/sound_towns.cpp
@@ -1301,6 +1301,7 @@ bool SoundTowns::loadInstruments() {
 
 void SoundTowns::playEuphonyTrack(uint32 offset, int loop) {
 	uint8 * twm = _vm->resource()->fileData("twmusic.pak", 0);
+	Common::StackLock lock(_mutex);
 
 	if (!_parser) {
 		_parser = new MidiParser_EuD(_driver->queue());
@@ -1431,7 +1432,7 @@ void SoundTowns_v2::haltTrack() {
 	//_driver->reset();
 }
 
-bool SoundTowns_v2::voicePlay(const char *file, bool) {
+int32 SoundTowns_v2::voicePlay(const char *file, bool) {
 	static const uint16 rates[] =	{ 0x10E1, 0x0CA9, 0x0870, 0x0654, 0x0438, 0x032A, 0x021C, 0x0194 };
 
 	int h = 0;
@@ -1439,7 +1440,7 @@ bool SoundTowns_v2::voicePlay(const char *file, bool) {
 		while (_mixer->isSoundHandleActive(_soundChannels[h].channelHandle) && h < kNumChannelHandles)
 			h++;
 		if (h >= kNumChannelHandles)
-			return false;
+			return 0;
 	}
 
 	char filename [13];
@@ -1496,7 +1497,7 @@ bool SoundTowns_v2::voicePlay(const char *file, bool) {
 	_mixer->playInputStream(Audio::Mixer::kSFXSoundType, &_soundChannels[h].channelHandle, _currentSFX);
 
 	delete[] data;
-	return true;
+	return 1;
 }
 
 void SoundTowns_v2::beginFadeOut() {
diff --git a/engines/kyra/staticres.cpp b/engines/kyra/staticres.cpp
index 7ba19e9966..302b92ab07 100644
--- a/engines/kyra/staticres.cpp
+++ b/engines/kyra/staticres.cpp
@@ -40,11 +40,9 @@
 #include "kyra/gui_hof.h"
 #include "kyra/gui_mr.h"
 
-#include "gui/message.h"
-
 namespace Kyra {
 
-#define RESFILE_VERSION 27
+#define RESFILE_VERSION 28
 
 bool StaticResource::checkKyraDat() {
 	Common::File kyraDat;
@@ -293,18 +291,20 @@ bool StaticResource::init() {
 		error("unknown game ID");
 	}
 
+	char errorBuffer[100];
 	int tempSize = 0;
 	uint8 *temp = getFile("INDEX", tempSize);
 	if (!temp) {
-		warning("No matching INDEX file found ('%s')", getFilename("INDEX"));
-		outputError();
+		snprintf(errorBuffer, sizeof(errorBuffer), "is missing an '%s' entry", getFilename("INDEX"));
+		outputError(errorBuffer);
 		return false;
 	}
 
 	if (tempSize != 3*4) {
 		delete[] temp;
-		warning("'%s' has illegal filesize %d", getFilename("INDEX"), tempSize);
-		outputError();
+
+		snprintf(errorBuffer, sizeof(errorBuffer), "has incorrect header size for entry '%s'", getFilename("INDEX"));
+		outputError(errorBuffer);
 		return false;
 	}
 
@@ -316,28 +316,25 @@ bool StaticResource::init() {
 	temp = 0;
 
 	if (version != RESFILE_VERSION) {
-		warning("Invalid KYRA.DAT file version (%u, required %d)", version, RESFILE_VERSION);
-		outputError();
+		snprintf(errorBuffer, sizeof(errorBuffer), "has invalid version %d required, you got %d", RESFILE_VERSION, version);
+		outputError(errorBuffer);
 		return false;
 	}
 
 	if (gameID != _vm->game()) {
-		warning("Invalid game id (%u)", gameID);
-		outputError();
+		outputError("does not include support for your game");
 		return false;
 	}
 
 	uint32 gameFeatures = createFeatures(_vm->gameFlags());
 	if ((featuresValue & GAME_FLAGS) != gameFeatures) {
-		warning("Your data file has a different game flags (0x%.08X has the data and your version has 0x%.08X)", (featuresValue & GAME_FLAGS), gameFeatures);
-		outputError();
+		outputError("does not include support for your game version");
 		return false;
 	}
 
 	// load all tables for now
 	if (!prefetchId(-1)) {
-		warning("Couldn't load all needed resources from 'KYRA.DAT'");
-		outputError();
+		outputError("is lacking entries for your game version");
 		return false;
 	}
 	return true;
@@ -347,11 +344,10 @@ void StaticResource::deinit() {
 	unloadId(-1);
 }
 
-void StaticResource::outputError() {
-	Common::String errorMessage = "Your '" + StaticResource::staticDataFilename() + "' file is outdated, reget it from the ScummVM website";
-	::GUI::MessageDialog errorMsg(errorMessage);
-	errorMsg.runModal();
-	error(errorMessage.c_str());
+void StaticResource::outputError(const Common::String &error) {
+	Common::String errorMessage = "Your '" + StaticResource::staticDataFilename() + "' file " + error + ", reget a correct version from the ScummVM website";
+	_vm->GUIErrorMessage(errorMessage);
+	::error(errorMessage.c_str());
 }
 
 const char * const*StaticResource::loadStrings(int id, int &strings) {
@@ -1281,7 +1277,7 @@ void KyraEngine_HoF::initStaticResource() {
 		&KyraEngine_HoF::seq_introLibrary2, &KyraEngine_HoF::seq_introLibrary2,
 		&KyraEngine_HoF::seq_introMarco, &KyraEngine_HoF::seq_introHand1a,
 		&KyraEngine_HoF::seq_introHand1b, &KyraEngine_HoF::seq_introHand1c,
-		&KyraEngine_HoF::seq_introHand2,	&KyraEngine_HoF::seq_introHand3, 0
+		&KyraEngine_HoF::seq_introHand2, &KyraEngine_HoF::seq_introHand3, 0
 	};
 
 	static const SeqProc hofDemoSequenceCallbacks[] = {
@@ -1363,11 +1359,11 @@ const int8 KyraEngine_v1::_addYPosTable[] = {
 	 0, -2, -2, -2,  0,  2,  2,  2
 };
 
-const int8 KyraEngine_LoK::_charXPosTable[] = {
+const int8 KyraEngine_v1::_charAddXPosTable[] = {
 	 0,  4,  4,  4,  0, -4, -4, -4
 };
 
-const int8 KyraEngine_LoK::_charYPosTable[] = {
+const int8 KyraEngine_v1::_charAddYPosTable[] = {
 	-2, -2,  0,  2,  2,  2,  0, -2
 };
 
@@ -1534,14 +1530,6 @@ const int KyraEngine_LoK::_dosTrackMapSize = ARRAYSIZE(KyraEngine_LoK::_dosTrack
 
 // kyra engine v2 static data
 
-const int8 KyraEngine_v2::_updateCharPosXTable[] = {
-	0, 4, 4, 4, 0, -4, -4, -4
-};
-
-const int8 KyraEngine_v2::_updateCharPosYTable[] = {
-	-2, -2, 0, 2, 2, 2, 0, -2
-};
-
 const int GUI_v2::_sliderBarsPosition[] = {
 	0x92, 0x1F, 0x92, 0x30, 0x92, 0x41, 0x92, 0x52
 };
@@ -1554,16 +1542,16 @@ const char *KyraEngine_HoF::_languageExtension[] = {
 	"ENG",
 	"FRE",
 	"GER",/*,
-	"ITA",		Italian and Spanish was never included
+	"ITA",		Italian and Spanish were never included
 	"SPA"*/
-	"JPN"
+	"JPN",
 };
 
 const char *KyraEngine_HoF::_scriptLangExt[] = {
 	"EMC",
 	"FMC",
 	"GMC",/*,
-	"IMC",		Italian and Spanish was never included
+	"IMC",		Italian and Spanish were never included
 	"SMC"*/
 	"JMC"
 };
@@ -1956,7 +1944,7 @@ const char *KyraEngine_MR::_languageExtension[] = {
 	"TRE",
 	"TRF",
 	"TRG"/*,
-	"TRI",		Italian and Spanish was never included
+	"TRI",		Italian and Spanish were never included
 	"TRS"*/
 };
 
diff --git a/engines/kyra/text.cpp b/engines/kyra/text.cpp
index 931c5fe1c9..f8eb10a85e 100644
--- a/engines/kyra/text.cpp
+++ b/engines/kyra/text.cpp
@@ -210,7 +210,7 @@ void TextDisplayer::printTalkTextMessage(const char *text, int x, int y, uint8 c
 	calcWidestLineBounds(x1, x2, w, x);
 	_talkCoords.x = x1;
 	_talkCoords.w = w + 2;
-	_screen->copyRegion(_talkCoords.x, _talkMessageY, _talkCoords.x, _talkCoords.y, _talkCoords.w, _talkMessageH, srcPage, dstPage);
+	_screen->copyRegion(_talkCoords.x, _talkMessageY, _talkCoords.x, _talkCoords.y, _talkCoords.w, _talkMessageH, srcPage, dstPage, Screen::CR_NO_P_CHECK);
 	int curPage = _screen->_curPage;
 	_screen->_curPage = srcPage;
 	for (int i = 0; i < lineCount; ++i) {
diff --git a/engines/kyra/text_hof.cpp b/engines/kyra/text_hof.cpp
index 0d40827390..dd587c5112 100644
--- a/engines/kyra/text_hof.cpp
+++ b/engines/kyra/text_hof.cpp
@@ -107,8 +107,7 @@ char *TextDisplayer_HoF::preprocessString(const char *str) {
 	int textWidth = _screen->getTextWidth(p);
 	_screen->_charWidth = 0;
 
-	// longer text strings for German versions
-	int maxTextWidth = (_vm->language() == 2 ? 240 : 176);
+	int maxTextWidth = (_vm->language() == 0) ? 176 : 240;
 
 	if (textWidth > maxTextWidth) {
 		if (textWidth > (maxTextWidth*2)) {
diff --git a/engines/kyra/text_lok.cpp b/engines/kyra/text_lok.cpp
index ccca079e32..f6b0407a75 100644
--- a/engines/kyra/text_lok.cpp
+++ b/engines/kyra/text_lok.cpp
@@ -62,10 +62,8 @@ void KyraEngine_LoK::waitForChatToFinish(int vocFile, int16 chatDuration, const
 	if (chatDuration != -1)
 		chatDuration *= _tickLength;
 
-	if (vocFile != -1) {
-		snd_voiceWaitForFinish();
+	if (vocFile != -1)
 		snd_playVoiceFile(vocFile);
-	}
 
 	_timer->disable(14);
 	_timer->disable(18);
@@ -269,6 +267,8 @@ void KyraEngine_LoK::characterSays(int vocFile, const char *chatStr, int8 charNu
 	if (_currentCharacter->sceneId == 210)
 		return;
 
+	snd_voiceWaitForFinish(true);
+
 	convoInitialized = initCharacterChat(charNum);
 	chatPartnerNum = getChatPartnerNum();
 
diff --git a/engines/kyra/text_mr.cpp b/engines/kyra/text_mr.cpp
index 13b37fa77a..16c56da099 100644
--- a/engines/kyra/text_mr.cpp
+++ b/engines/kyra/text_mr.cpp
@@ -55,25 +55,26 @@ char *TextDisplayer_MR::preprocessString(const char *str) {
 		int count = 0, offs = 0;
 		if (textWidth > (3*maxTextWidth)) {
 			count = getCharLength(p, textWidth/4);
-			offs = dropCRIntoString(p, getCharLength(p, maxTextWidth), count);
+			offs = dropCRIntoString(p, count, getCharLength(p, maxTextWidth));
 			p += count + offs;
-		}
-
+			// No update of textWidth here
+		} 
+		
 		if (textWidth > (2*maxTextWidth)) {
 			count = getCharLength(p, textWidth/3);
-			offs = dropCRIntoString(p, getCharLength(p, maxTextWidth), count);
+			offs = dropCRIntoString(p, count, getCharLength(p, maxTextWidth));
 			p += count + offs;
 			textWidth = _screen->getTextWidth(p);
 		}
 
 		count = getCharLength(p, textWidth/2);
-		offs = dropCRIntoString(p, getCharLength(p, maxTextWidth), count);	
+		offs = dropCRIntoString(p, count, getCharLength(p, maxTextWidth));	
 		p += count + offs;
 		textWidth = _screen->getTextWidth(p);
 
 		if (textWidth > maxTextWidth) {
 			count = getCharLength(p, textWidth/2);
-			offs = dropCRIntoString(p, getCharLength(p, maxTextWidth), count);	
+			offs = dropCRIntoString(p, count, getCharLength(p, maxTextWidth));	
 		}
 	}
 
@@ -232,7 +233,7 @@ void KyraEngine_MR::objectChat(const char *str, int object, int vocHigh, int voc
 		"MTFR00S.EMC", "MTFR00Q.EMC", "MTFR00E.EMC", "MTFR00T.EMC",
 		 "MTL00S.EMC",  "MTL00Q.EMC",  "MTL00E.EMC",  "MTL00T.EMC",
 		 "MTR00S.EMC",  "MTR00Q.EMC",  "MTR00E.EMC",  "MTR00T.EMC",
-		 "MTA00S.EMC",  "MTA00Q.EMC",  "MTA00Q.EMC",  "MTA00T.EMC"
+		 "MTA00S.EMC",  "MTA00Q.EMC",  "MTA00E.EMC",  "MTA00T.EMC"
 	};
 
 	int chat = talkScriptTable[chatType + _mainCharacter.facing * 4];
diff --git a/engines/kyra/vqa.cpp b/engines/kyra/vqa.cpp
index cea52e911e..3d18f27c7e 100644
--- a/engines/kyra/vqa.cpp
+++ b/engines/kyra/vqa.cpp
@@ -362,9 +362,8 @@ void VQAMovie::close() {
 		delete[] _partialCodeBook;
 		delete[] _vectorPointers;
 
-		if (_vm->_mixer->isSoundHandleActive(_sound)) {
+		if (_vm->_mixer->isSoundHandleActive(_sound))
 			_vm->_mixer->stopHandle(_sound);
-		}
 
 		_frameInfo = NULL;
 		_frame = NULL;
@@ -655,11 +654,10 @@ void VQAMovie::play() {
 		while (1) {
 			uint32 elapsedTime;
 
-			if (_vm->_mixer->isSoundHandleActive(_sound)) {
+			if (_vm->_mixer->isSoundHandleActive(_sound))
 				elapsedTime = _vm->_mixer->getSoundElapsedTime(_sound);
-			} else {
+			else 
 				elapsedTime = _system->getMillis() - startTick;
-			}
 
 			if (elapsedTime >= (i * 1000) / _header.frameRate)
 				break;
diff --git a/engines/lure/game.cpp b/engines/lure/game.cpp
index c87f81618a..f9b31c21c5 100644
--- a/engines/lure/game.cpp
+++ b/engines/lure/game.cpp
@@ -167,6 +167,7 @@ void Game::execute() {
 			if (system.getMillis() > timerVal + GAME_FRAME_DELAY) {
 				timerVal = system.getMillis();
 				nextFrame();
+				res.delayList().tick();
 
 				Sound.musicInterface_ContinuePlaying();
 			}
@@ -177,8 +178,6 @@ void Game::execute() {
 				tickCheck();
 			}
 
-			res.delayList().tick();
-
 			while (events.pollEvent()) {
 				if (events.type() == Common::EVENT_KEYDOWN) {
 					uint16 roomNum = room.roomNumber();
diff --git a/engines/lure/lure.cpp b/engines/lure/lure.cpp
index de213b4f5a..06d3b1984e 100644
--- a/engines/lure/lure.cpp
+++ b/engines/lure/lure.cpp
@@ -154,6 +154,16 @@ int LureEngine::go() {
 	return 0;
 }
 
+void LureEngine::pauseEngineIntern(bool pause) {
+	Engine::pauseEngineIntern(pause);
+
+	if (pause) {
+		Sound.pause();
+	} else {
+		Sound.resume();
+	}
+}
+
 void LureEngine::quitGame() {
 	_system->quit();
 }
diff --git a/engines/lure/lure.h b/engines/lure/lure.h
index fa70abc1f0..d66f446247 100644
--- a/engines/lure/lure.h
+++ b/engines/lure/lure.h
@@ -69,6 +69,7 @@ public:
 
 	virtual int init();
 	virtual int go();
+	virtual void pauseEngineIntern(bool pause);
 	void quitGame();
 
 	Disk &disk() { return *_disk; }
diff --git a/engines/lure/res_struct.cpp b/engines/lure/res_struct.cpp
index 913505c8c9..de09f982d1 100644
--- a/engines/lure/res_struct.cpp
+++ b/engines/lure/res_struct.cpp
@@ -760,10 +760,8 @@ RoomExitCoordinateData &RoomExitCoordinates::getData(uint16 destRoomNumber) {
 // The following classes hold any sequence offsets that are being delayed
 
 SequenceDelayData::SequenceDelayData(uint16 delay, uint16 seqOffset, bool canClearFlag) {
-	OSystem &system = *g_system;
-
-	// The delay is in number of seconds
-	timeoutCtr = system.getMillis() + delay * 1000;
+	// The delay is in number of seconds - convert it to remaining milliseconds
+	timeoutCtr = delay * 1000;
 	sequenceOffset = seqOffset;
 	canClear = canClearFlag;
 }
@@ -784,21 +782,23 @@ void SequenceDelayList::add(uint16 delay, uint16 seqOffset, bool canClear) {
 }
 
 void SequenceDelayList::tick() {
-	uint32 currTime = g_system->getMillis();
 	SequenceDelayList::iterator i;
 
-	debugC(ERROR_DETAILED, kLureDebugScripts, "Delay List check start at time %d", currTime);
+	debugC(ERROR_DETAILED, kLureDebugScripts, "Delay List check start at time %d", 
+		g_system->getMillis());
 
 	for (i = begin(); i != end(); i++) {
 		SequenceDelayData *entry = (*i).get();
 		debugC(ERROR_DETAILED, kLureDebugScripts, "Delay List check %xh at time %d", entry->sequenceOffset, entry->timeoutCtr);
 
-		if (currTime >= entry->timeoutCtr) {
+		if (entry->timeoutCtr <= GAME_FRAME_DELAY) {
 			// Timeout reached - delete entry from list and execute the sequence
 			uint16 seqOffset = entry->sequenceOffset;
 			erase(i);
 			Script::execute(seqOffset);
 			return;
+		} else {
+			entry->timeoutCtr -= GAME_FRAME_DELAY;
 		}
 	}
 }
@@ -816,14 +816,12 @@ void SequenceDelayList::clear(bool forceClear) {
 }
 
 void SequenceDelayList::saveToStream(WriteStream *stream) {
-	uint32 currTime = g_system->getMillis();
 	SequenceDelayList::iterator i;
 
 	for (i = begin(); i != end(); ++i) {
 		SequenceDelayData *entry = (*i).get();
 		stream->writeUint16LE(entry->sequenceOffset);
-		stream->writeUint32LE((currTime > entry->timeoutCtr ) ? 0 :
-			entry->timeoutCtr - currTime);
+		stream->writeUint32LE(entry->timeoutCtr);
 		stream->writeByte(entry->canClear);
 	}
 
@@ -833,10 +831,9 @@ void SequenceDelayList::saveToStream(WriteStream *stream) {
 void SequenceDelayList::loadFromStream(ReadStream *stream) {
 	clear(true);
 	uint16 seqOffset;
-	uint32 currTime = g_system->getMillis();
 
 	while ((seqOffset = stream->readUint16LE()) != 0) {
-		uint32 delay = currTime + stream->readUint32LE();
+		uint32 delay = stream->readUint32LE();
 		bool canClear = stream->readByte() != 0;
 		push_back(SequenceDelayList::value_type(SequenceDelayData::load(delay, seqOffset, canClear)));
 	}
diff --git a/engines/m4/script.h b/engines/m4/script.h
index a59bf46e86..2a937040e9 100644
--- a/engines/m4/script.h
+++ b/engines/m4/script.h
@@ -300,7 +300,8 @@ public:
 	const T& toData(const ScriptValue &value) {
 		printf("ScriptInterpreter::toData() index = %d; type = %d; max = %d\n", value.value, _data[value.value]->type, _data.size());
 		assert((uint32)value.value < _data.size());
-		return *(_dataCache->load<T>(_scriptFile, _data[value.value]->offset));
+		T *result = _dataCache->load<T>(_scriptFile, _data[value.value]->offset);
+		return *result;
 	}
 
 	const char *getGlobalString(int index) const {
diff --git a/engines/made/database.h b/engines/made/database.h
index 50e37d6936..0924200374 100644
--- a/engines/made/database.h
+++ b/engines/made/database.h
@@ -95,6 +95,8 @@ public:
 			return NULL;
 	}
 
+	uint getObjectCount() const { return _objects.size(); }
+
 	int16 getMainCodeObjectIndex() const { return _mainCodeObjectIndex; }
 
 	int16 getVar(int16 index);
diff --git a/engines/made/detection.cpp b/engines/made/detection.cpp
index 7f12a85611..7d30873866 100644
--- a/engines/made/detection.cpp
+++ b/engines/made/detection.cpp
@@ -74,6 +74,10 @@ namespace Made {
 static const MadeGameDescription gameDescriptions[] = {
 
 	{
+		// NOTE: Return to Zork entries with *.dat are used to detect the game via rtzcd.dat,
+		// which is packed inside rtzcd.red. Entries with *.red refer to the packed file
+		// directly, which is the "official" way.
+
 		// Return to Zork - English CD version 1.0 9/15/93
 		// Patch #1953654 submitted by spookypeanut
 		{
@@ -109,8 +113,6 @@ static const MadeGameDescription gameDescriptions[] = {
 
 	{
 		// Return to Zork - English CD version 1.1 12/7/93
-		// NOTE: This detects the game via the rtzcd.dat which is inside rtzcd.red.
-		// The entry below detects via rtzcd.red directly, which is the "official" way.
 		{
 			"rtz",
 			"CD",
@@ -143,6 +145,23 @@ static const MadeGameDescription gameDescriptions[] = {
 
 	{
 		// Return to Zork - English CD version 1.2 9/29/94
+		// Supplied by Dark-Star in the ScummVM forums
+		{
+			"rtz",
+			"CD",
+			AD_ENTRY1("rtzcd.dat", "9d740378da2d16e83d0d0efff01bf83a"),
+			Common::EN_ANY,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		GID_RTZ,
+		0,
+		GF_CD,
+		0,
+	},
+
+	{
+		// Return to Zork - English CD version 1.2 9/29/94
 		{
 			"rtz",
 			"CD",
@@ -157,6 +176,41 @@ static const MadeGameDescription gameDescriptions[] = {
 		0,
 	},
 
+	{
+		// Return to Zork - German CD version 1.2 9/29/94
+		// (same as the English 1.2 version)
+		// Supplied by Dark-Star in the ScummVM forums
+		{
+			"rtz",
+			"CD",
+			AD_ENTRY1("rtzcd.dat", "9d740378da2d16e83d0d0efff01bf83a"),
+			Common::DE_DEU,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		GID_RTZ,
+		0,
+		GF_CD,
+		0,
+	},
+
+	{
+		// Return to Zork - German CD version 1.2 4/18/95
+		// (same as the English 1.2 version)
+		// Supplied by Dark-Star in the ScummVM forums
+		{
+			"rtz",
+			"CD",
+			AD_ENTRY1("rtzcd.red", "946997d8b0aa6cb4e848bad02a1fc3d2"),
+			Common::DE_DEU,
+			Common::kPlatformPC,
+			Common::ADGF_NO_FLAGS
+		},
+		GID_RTZ,
+		0,
+		GF_CD_COMPRESSED,
+		0,
+	},
 
 	{
 		// Return to Zork - English floppy version
@@ -302,7 +356,8 @@ const Common::ADGameDescription *MadeMetaEngine::fallbackDetect(const FSList *fs
 	Made::g_fallbackDesc.features = 0;
 	Made::g_fallbackDesc.version = 0;
 
-	return (const Common::ADGameDescription *)&Made::g_fallbackDesc;
+	//return (const Common::ADGameDescription *)&Made::g_fallbackDesc;
+	return NULL;
 }
 
 #if PLUGIN_ENABLED_DYNAMIC(MADE)
diff --git a/engines/made/graphics.cpp b/engines/made/graphics.cpp
index 081621ef18..ee702893a0 100644
--- a/engines/made/graphics.cpp
+++ b/engines/made/graphics.cpp
@@ -29,7 +29,24 @@
 
 namespace Made {
 
-void decompressImage(byte *source, Graphics::Surface &surface, uint16 cmdOffs, uint16 pixelOffs, uint16 maskOffs, uint16 lineSize, bool deltaFrame) {
+byte ValueReader::readPixel() {
+	byte value;
+	if (_nibbleMode) {
+		if (_nibbleSwitch) {
+			value = (_buffer[0] >> 4) & 0x0F;
+			_buffer++;
+		} else {
+			value = _buffer[0] & 0x0F;
+		}
+		_nibbleSwitch = !_nibbleSwitch;
+	} else {
+		value = _buffer[0];
+		_buffer++;
+	}
+	return value;
+}
+
+void decompressImage(byte *source, Graphics::Surface &surface, uint16 cmdOffs, uint16 pixelOffs, uint16 maskOffs, uint16 lineSize, byte cmdFlags, byte pixelFlags, byte maskFlags, bool deltaFrame) {
 
 	const int offsets[] = {
 		0, 1, 2, 3,
@@ -43,11 +60,10 @@ void decompressImage(byte *source, Graphics::Surface &surface, uint16 cmdOffs, u
 
 	byte *cmdBuffer = source + cmdOffs;
 	byte *maskBuffer = source + maskOffs;
-	byte *pixelBuffer = source + pixelOffs;
+	ValueReader pixelReader(source + pixelOffs, (pixelFlags & 2) != 0);
 
 	byte *destPtr = (byte*)surface.getBasePtr(0, 0);
 
-	//byte lineBuf[320 * 4];
 	byte lineBuf[640 * 4];
 	byte bitBuf[40];
 
@@ -85,14 +101,14 @@ void decompressImage(byte *source, Graphics::Surface &surface, uint16 cmdOffs, u
 				switch (cmd) {
 
 				case 0:
-					pixels[0] = *pixelBuffer++;
+					pixels[0] = pixelReader.readPixel();
 					for (int i = 0; i < 16; i++)
 						lineBuf[drawDestOfs + offsets[i]] = pixels[0];
 					break;
 
 				case 1:
-					pixels[0] = *pixelBuffer++;
-					pixels[1] = *pixelBuffer++;
+					pixels[0] = pixelReader.readPixel();
+					pixels[1] = pixelReader.readPixel();
 					mask = READ_LE_UINT16(maskBuffer);
 					maskBuffer += 2;
 					for (int i = 0; i < 16; i++) {
@@ -102,10 +118,10 @@ void decompressImage(byte *source, Graphics::Surface &surface, uint16 cmdOffs, u
 					break;
 
 				case 2:
-					pixels[0] = *pixelBuffer++;
-					pixels[1] = *pixelBuffer++;
-					pixels[2] = *pixelBuffer++;
-					pixels[3] = *pixelBuffer++;
+					pixels[0] = pixelReader.readPixel();
+					pixels[1] = pixelReader.readPixel();
+					pixels[2] = pixelReader.readPixel();
+					pixels[3] = pixelReader.readPixel();
 					mask = READ_LE_UINT32(maskBuffer);
 					maskBuffer += 4;
 					for (int i = 0; i < 16; i++) {
@@ -149,4 +165,112 @@ void decompressImage(byte *source, Graphics::Surface &surface, uint16 cmdOffs, u
 
 }
 
+void decompressMovieImage(byte *source, Graphics::Surface &surface, uint16 cmdOffs, uint16 pixelOffs, uint16 maskOffs, uint16 lineSize) {
+
+	uint16 width = surface.w;
+	uint16 height = surface.h;
+	uint16 bx = 0, by = 0, bw = ((width + 3) / 4) * 4;
+
+	byte *cmdBuffer = source + cmdOffs;
+	byte *maskBuffer = source + maskOffs;
+	byte *pixelBuffer = source + pixelOffs;
+
+	byte *destPtr = (byte*)surface.getBasePtr(0, 0);
+
+	byte bitBuf[40];
+
+	int bitBufLastOfs = (((lineSize + 1) >> 1) << 1) - 2;
+	int bitBufLastCount = ((width + 3) >> 2) & 7;
+	if (bitBufLastCount == 0)
+		bitBufLastCount = 8;
+		
+	debug(1, "width = %d; bw = %d", width, bw);
+
+	while (height > 0) {
+
+		memcpy(bitBuf, cmdBuffer, lineSize);
+		cmdBuffer += lineSize;
+
+		for (uint16 bitBufOfs = 0; bitBufOfs < lineSize; bitBufOfs += 2) {
+
+			uint16 bits = READ_LE_UINT16(&bitBuf[bitBufOfs]);
+
+			int bitCount;
+			if (bitBufOfs == bitBufLastOfs)
+				bitCount = bitBufLastCount;
+			else
+				bitCount = 8;
+
+			for (int curCmd = 0; curCmd < bitCount; curCmd++) {
+				uint cmd = bits & 3;
+				bits >>= 2;
+
+				byte pixels[4], block[16];
+				uint32 mask;
+
+				switch (cmd) {
+
+				case 0:
+					pixels[0] = *pixelBuffer++;
+					for (int i = 0; i < 16; i++)
+						block[i] = pixels[0];
+					break;
+
+				case 1:
+					pixels[0] = *pixelBuffer++;
+					pixels[1] = *pixelBuffer++;
+					mask = READ_LE_UINT16(maskBuffer);
+					maskBuffer += 2;
+					for (int i = 0; i < 16; i++) {
+						block[i] = pixels[mask & 1];
+						mask >>= 1;
+					}
+					break;
+
+				case 2:
+					pixels[0] = *pixelBuffer++;
+					pixels[1] = *pixelBuffer++;
+					pixels[2] = *pixelBuffer++;
+					pixels[3] = *pixelBuffer++;
+					mask = READ_LE_UINT32(maskBuffer);
+					maskBuffer += 4;
+					for (int i = 0; i < 16; i++) {
+						block[i] = pixels[mask & 3];
+						mask >>= 2;
+					}
+					break;
+
+				case 3:
+					break;
+
+				}
+
+				if (cmd != 3) {
+					uint16 blockPos = 0;
+					uint32 maxW = MIN(4, surface.w - bx);
+					uint32 maxH = (MIN(4, surface.h - by) + by) * width;
+					for (uint32 yc = by * width; yc < maxH; yc += width) {
+						for (uint32 xc = 0; xc < maxW; xc++) {
+							destPtr[(bx + xc) + yc] = block[xc + blockPos];
+						}
+						blockPos += 4;
+					}
+				}
+
+				bx += 4;
+				if (bx >= bw) {
+					bx = 0;
+					by += 4;
+				}
+
+			}
+
+		}
+
+		height -= 4;
+
+	}
+
+}
+
 } // End of namespace Made
diff --git a/engines/made/graphics.h b/engines/made/graphics.h
index 3c56bb4231..1a5cf72677 100644
--- a/engines/made/graphics.h
+++ b/engines/made/graphics.h
@@ -33,7 +33,18 @@
 
 namespace Made {
 
-void decompressImage(byte *source, Graphics::Surface &surface, uint16 cmdOffs, uint16 pixelOffs, uint16 maskOffs, uint16 lineSize, bool deltaFrame = false);
+class ValueReader {
+public:
+	ValueReader(byte *source, bool nibbleMode) : _buffer(source), _nibbleBuf(0), _nibbleMode(nibbleMode), _nibbleSwitch(false) {}
+	byte readPixel();
+protected:
+	byte _nibbleBuf;
+	bool _nibbleMode, _nibbleSwitch;
+	byte *_buffer;
+};
+
+void decompressImage(byte *source, Graphics::Surface &surface, uint16 cmdOffs, uint16 pixelOffs, uint16 maskOffs, uint16 lineSize, byte cmdFlags, byte pixelFlags, byte maskFlags, bool deltaFrame = false);
+void decompressMovieImage(byte *source, Graphics::Surface &surface, uint16 cmdOffs, uint16 pixelOffs, uint16 maskOffs, uint16 lineSize);
 
 } // End of namespace Made
 
diff --git a/engines/made/made.cpp b/engines/made/made.cpp
index 4ec857547b..92efb881e2 100644
--- a/engines/made/made.cpp
+++ b/engines/made/made.cpp
@@ -109,7 +109,13 @@ MadeEngine::MadeEngine(OSystem *syst, const MadeGameDescription *gameDesc) : Eng
 	
 	_quit = false;
 
-	_soundRate = 8000;
+	// Set default sound frequency
+	// Return to Zork sets it itself via a script funtion
+	if (getGameID() == GID_MANHOLE) {
+		_soundRate = 11025;
+	} else {
+		_soundRate = 8000;
+	}
 
 }
 
@@ -171,6 +177,62 @@ Common::String MadeEngine::getSavegameFilename(int16 saveNum) {
 	return filename;
 }
 
+void MadeEngine::handleEvents() {
+
+	Common::Event event;
+	Common::EventManager *eventMan = _system->getEventManager();
+
+	// NOTE: Don't reset _eventNum to 0 here or no events will get through to the scripts.
+
+	while (eventMan->pollEvent(event)) {
+		switch (event.type) {
+
+		case Common::EVENT_MOUSEMOVE:
+			_eventMouseX = event.mouse.x;
+			_eventMouseY = event.mouse.y;
+			break;
+
+		case Common::EVENT_LBUTTONDOWN:
+			_eventNum = 1;
+			break;
+
+		/*
+		case Common::EVENT_LBUTTONUP:
+			_eventNum = 2; // TODO: Is this correct?
+			break;
+		*/
+
+		case Common::EVENT_RBUTTONDOWN:
+			_eventNum = 3;
+			break;
+
+		/*
+		case Common::EVENT_RBUTTONUP:
+			eventNum = 4; // TODO: Is this correct?
+			break;
+		*/
+
+		case Common::EVENT_KEYDOWN:
+			_eventKey = event.kbd.ascii;
+			// For unknown reasons, the game accepts ASCII code
+			// 9 as backspace
+			if (_eventKey == Common::KEYCODE_BACKSPACE)
+				_eventKey = 9;
+			_eventNum = 5;
+			break;
+
+		case Common::EVENT_QUIT:
+			_quit = true;
+			break;
+
+		default:
+			break;
+
+		}
+	}
+
+}
+
 int MadeEngine::go() {
 
 	for (int i = 0; i < ARRAYSIZE(_timers); i++)
@@ -205,8 +267,19 @@ int MadeEngine::go() {
 		error ("Unknown MADE game");
 	}
 
-	_eventKey = _eventMouseX = _eventMouseY = 0;
+	// FIXME: This should make things a little faster until proper dirty rectangles
+	//        are implemented.
+	// NOTE: Disabled again since it causes major graphics errors.
+	//_system->setFeatureState(OSystem::kFeatureAutoComputeDirtyRects, true);
+
+	_eventNum = _eventKey = _eventMouseX = _eventMouseY = 0;
+	
+#ifdef DUMP_SCRIPTS
+	_script->dumpAllScripts();
+#else
+	_screen->setDefaultMouseCursor();
 	_script->runScript(_dat->getMainCodeObjectIndex());
+#endif
 
 	return 0;
 }
diff --git a/engines/made/made.h b/engines/made/made.h
index 5491e8132f..5ee3828557 100644
--- a/engines/made/made.h
+++ b/engines/made/made.h
@@ -93,7 +93,6 @@ public:
 	uint32 getFeatures() const;
 	uint16 getVersion() const;
 	Common::Platform getPlatform() const;
-	void update_events();
 
 private:
 public:
@@ -106,6 +105,7 @@ public:
 
 	bool _quit;
 
+	uint16 _eventNum;
 	int _eventMouseX, _eventMouseY;
 	uint16 _eventKey;
 	int _soundRate;
@@ -124,7 +124,9 @@ public:
 
 	const Common::String getTargetName() { return _targetName; }
 	Common::String getSavegameFilename(int16 saveNum);
-	
+
+	void handleEvents();
+
 };
 
 } // End of namespace Made
diff --git a/engines/made/pmvplayer.cpp b/engines/made/pmvplayer.cpp
index db56235a67..1a8ca9c50a 100644
--- a/engines/made/pmvplayer.cpp
+++ b/engines/made/pmvplayer.cpp
@@ -48,12 +48,15 @@ void PmvPlayer::play(const char *filename) {
 	readChunk(chunkType, chunkSize);	// "MHED"
 
 	// TODO: Evaluate header
-	//_fd->skip(0x3A);
 
 	uint frameDelay = _fd->readUint16LE();
 	_fd->skip(10);
 	uint soundFreq = _fd->readUint16LE();
-	// FIXME: weird frequencies... (11127 or 22254)
+	// Note: There seem to be weird sound frequencies in PMV videos.
+	// Not sure why, but leaving those original frequencies intact
+	// 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;
 
@@ -74,7 +77,7 @@ void PmvPlayer::play(const char *filename) {
 	uint32 frameCount = 0;
 	uint16 chunkCount = 0;
 	uint32 soundSize = 0;
-	uint32 palChunkOfs = 0;
+	uint32 soundChunkOfs = 0, palChunkOfs = 0;
 	uint32 palSize = 0;
 	byte *frameData, *audioData, *soundData, *palData, *imageData;
 	bool firstTime = true;
@@ -100,23 +103,29 @@ void PmvPlayer::play(const char *filename) {
 
 		frameData = new byte[chunkSize];
 		_fd->read(frameData, chunkSize);
+		
+		soundChunkOfs = READ_LE_UINT32(frameData + 8);
+		palChunkOfs = READ_LE_UINT32(frameData + 16);
 
 		// Handle audio
-		audioData = frameData + READ_LE_UINT32(frameData + 8) - 8;
-		chunkSize = READ_LE_UINT16(audioData + 4);
-		chunkCount = READ_LE_UINT16(audioData + 6);
+		if (soundChunkOfs) {
+
+			audioData = frameData + soundChunkOfs - 8;
+			chunkSize = READ_LE_UINT16(audioData + 4);
+			chunkCount = READ_LE_UINT16(audioData + 6);
 
-		if (chunkCount > 50) break;	// FIXME: this is a hack
+			debug(1, "chunkCount = %d; chunkSize = %d; total = %d\n", chunkCount, chunkSize, chunkCount * chunkSize);
 
-		debug(1, "chunkCount = %d; chunkSize = %d; total = %d\n", chunkCount, chunkSize, chunkCount * chunkSize);
+			if (chunkCount > 50) break;	// FIXME: this is a hack
 
-		soundSize = chunkCount * chunkSize;
-		soundData = new byte[soundSize];
-		decompressSound(audioData + 8, soundData, chunkSize, chunkCount);
-		_audioStream->queueBuffer(soundData, soundSize);
+			soundSize = chunkCount * chunkSize;
+			soundData = new byte[soundSize];
+			decompressSound(audioData + 8, soundData, chunkSize, chunkCount);
+			_audioStream->queueBuffer(soundData, soundSize);
+
+		}
 
 		// Handle palette
-		palChunkOfs = READ_LE_UINT32(frameData + 16);
 		if (palChunkOfs) {
 			palData = frameData + palChunkOfs - 8;
 			palSize = READ_LE_UINT32(palData + 4);
@@ -143,7 +152,7 @@ void PmvPlayer::play(const char *filename) {
 			_surface->create(width, height, 1);
 		}
 
-		decompressImage(imageData, *_surface, cmdOffs, pixelOffs, maskOffs, lineSize, frameNum > 0);
+		decompressMovieImage(imageData, *_surface, cmdOffs, pixelOffs, maskOffs, lineSize);
 	
 		if (firstTime) {
 			_mixer->playInputStream(Audio::Mixer::kPlainSoundType, &_audioStreamHandle, _audioStream);
diff --git a/engines/made/resource.cpp b/engines/made/resource.cpp
index 8c9125127a..2cae8b276c 100644
--- a/engines/made/resource.cpp
+++ b/engines/made/resource.cpp
@@ -59,9 +59,9 @@ void PictureResource::load(byte *source, int size) {
 	Common::MemoryReadStream *sourceS = new Common::MemoryReadStream(source, size);
 	
 	_hasPalette = (sourceS->readByte() != 0);
-	sourceS->readByte();
-	sourceS->readByte();
-	sourceS->readByte();
+	byte cmdFlags = sourceS->readByte();
+	byte pixelFlags = sourceS->readByte();
+	byte maskFlags = sourceS->readByte();
 	uint16 cmdOffs = sourceS->readUint16LE();
 	uint16 pixelOffs = sourceS->readUint16LE();
 	uint16 maskOffs = sourceS->readUint16LE();
@@ -69,7 +69,11 @@ void PictureResource::load(byte *source, int size) {
 	/*uint16 u = */sourceS->readUint16LE();
 	uint16 width = sourceS->readUint16LE();
 	uint16 height = sourceS->readUint16LE();
-	
+
+	if (cmdFlags || pixelFlags || maskFlags) {
+		warning("PictureResource::load() Graphic has flags set");
+	}
+
 	_paletteColorCount = (cmdOffs - 18) / 3; // 18 = sizeof header
 
 	debug(2, "width = %d; height = %d\n", width, height);
@@ -82,7 +86,7 @@ void PictureResource::load(byte *source, int size) {
 	_picture = new Graphics::Surface();
 	_picture->create(width, height, 1);
 
-	decompressImage(source, *_picture, cmdOffs, pixelOffs, maskOffs, lineSize);
+	decompressImage(source, *_picture, cmdOffs, pixelOffs, maskOffs, lineSize, cmdFlags, pixelFlags, maskFlags);
 
 	delete sourceS;
 
@@ -94,7 +98,8 @@ AnimationResource::AnimationResource() {
 }
 
 AnimationResource::~AnimationResource() {
-	// TODO: Free anim frames
+	for (uint i = 0; i < _frames.size(); i++)
+		delete _frames[i];
 }
 
 void AnimationResource::load(byte *source, int size) {
@@ -136,7 +141,7 @@ void AnimationResource::load(byte *source, int size) {
 		Graphics::Surface *frame = new Graphics::Surface();
 		frame->create(frameWidth, frameHeight, 1);
 
-		decompressImage(source + frameOffs, *frame, cmdOffs, pixelOffs, maskOffs, lineSize, _flags & 1);
+		decompressImage(source + frameOffs, *frame, cmdOffs, pixelOffs, maskOffs, lineSize, 0, 0, 0, _flags & 1);
 
 		_frames.push_back(frame);
 
diff --git a/engines/made/screen.cpp b/engines/made/screen.cpp
index 563e059309..754a45016c 100644
--- a/engines/made/screen.cpp
+++ b/engines/made/screen.cpp
@@ -45,11 +45,13 @@ Screen::Screen(MadeEngine *vm) : _vm(vm) {
 	_workScreenDrawCtx.destSurface = _workScreen;
 	_clipArea.destSurface = _workScreen;
 
-	// FIXME: Screen mask is only needed in v2 games
-	_screenMask = new Graphics::Surface();
-	_screenMask->create(320, 200, 1);
-	_maskDrawCtx.clipRect = Common::Rect(320, 200);
-	_maskDrawCtx.destSurface = _screenMask;
+	// Screen mask is only needed in v2 games
+	if (_vm->getGameID() != GID_RTZ) {
+		_screenMask = new Graphics::Surface();
+		_screenMask->create(320, 200, 1);
+		_maskDrawCtx.clipRect = Common::Rect(320, 200);
+		_maskDrawCtx.destSurface = _screenMask;
+	}
 
 	for (int i = 0; i <= 3; i++)
 		_excludeClipAreaEnabled[i] = false;
@@ -90,14 +92,16 @@ Screen::Screen(MadeEngine *vm) : _vm(vm) {
 Screen::~Screen() {
 	delete _backgroundScreen;
 	delete _workScreen;
-	delete _screenMask;
+	if (_vm->getGameID() != GID_RTZ)
+		delete _screenMask;
 	delete _fx;
 }
 
 void Screen::clearScreen() {
 	_backgroundScreen->fillRect(Common::Rect(0, 0, 320, 200), 0);
 	_workScreen->fillRect(Common::Rect(0, 0, 320, 200), 0);
-	_screenMask->fillRect(Common::Rect(0, 0, 320, 200), 0);
+	if (_vm->getGameID() != GID_RTZ)
+		_screenMask->fillRect(Common::Rect(0, 0, 320, 200), 0);
 	_mask = 0;
 	_needPalette = true;
 }
@@ -139,7 +143,7 @@ void Screen::setExcludeArea(uint16 x1, uint16 y1, uint16 x2, uint16 y2) {
 
 void Screen::drawSurface(Graphics::Surface *sourceSurface, int x, int y, int16 flipX, int16 flipY, int16 mask, const ClipInfo &clipInfo) {
 
-	byte *source, *dest, *maskp;
+	byte *source, *dest, *maskp = 0;
 	int startX = 0;
 	int startY = 0;
 	int clipWidth = sourceSurface->w;
@@ -167,7 +171,8 @@ void Screen::drawSurface(Graphics::Surface *sourceSurface, int x, int y, int16 f
 
 	source = (byte*)sourceSurface->getBasePtr(startX, startY);
 	dest = (byte*)clipInfo.destSurface->getBasePtr(x, y);
-	maskp = (byte*)_maskDrawCtx.destSurface->getBasePtr(x, y);
+	if (_vm->getGameID() != GID_RTZ)
+		maskp = (byte*)_maskDrawCtx.destSurface->getBasePtr(x, y);
 
 	int32 sourcePitch, linePtrAdd;
 	byte *linePtr;
@@ -192,7 +197,7 @@ void Screen::drawSurface(Graphics::Surface *sourceSurface, int x, int y, int16 f
 			linePtr = source;
 		}
 		for (int16 xc = 0; xc < clipWidth; xc++) {
-			if (*linePtr && (mask == 0 || maskp[xc] == 0)) {
+			if (*linePtr && (_vm->getGameID() == GID_RTZ || (mask == 0 || maskp[xc] == 0))) {
 				if (*linePtr)
 					dest[xc] = *linePtr;
 			}
@@ -200,7 +205,8 @@ void Screen::drawSurface(Graphics::Surface *sourceSurface, int x, int y, int16 f
 		}
 		source += sourcePitch;
 		dest += clipInfo.destSurface->pitch;
-		maskp += _maskDrawCtx.destSurface->pitch;
+		if (_vm->getGameID() != GID_RTZ)
+			maskp += _maskDrawCtx.destSurface->pitch;
 	}
 
 }
@@ -260,7 +266,6 @@ uint16 Screen::setChannelLocation(uint16 channelIndex, int16 x, int16 y) {
 uint16 Screen::setChannelContent(uint16 channelIndex, uint16 index) {
 	if (channelIndex < 1 || channelIndex >= 100 || _channels[channelIndex - 1].type == 0)
 		return 0;
-	//debug(2, "setChannelContent(%d, %04X)\n", channelIndex, index); fflush(stdout); g_system->delayMillis(5000);
 	_channels[channelIndex - 1].index = index;
 	return updateChannel(channelIndex - 1) + 1;
 }
@@ -271,20 +276,6 @@ void Screen::setChannelUseMask(uint16 channelIndex) {
 	_channels[channelIndex - 1].mask = _mask;
 }
 
-void Screen::setChannelOffsets(uint16 channelIndex, int16 xofs, int16 yofs) {
-	if (channelIndex < 1 || channelIndex >= 100)
-		return;
-	_channels[channelIndex - 1].xofs = xofs;
-	_channels[channelIndex - 1].yofs = yofs;
-}
-
-void Screen::getChannelOffsets(uint16 channelIndex, int16 &xofs, int16 &yofs) {
-	if (channelIndex < 1 || channelIndex >= 100)
-		return;
-	xofs = _channels[channelIndex - 1].xofs;
-	yofs = _channels[channelIndex - 1].yofs;
-}
-
 void Screen::drawSpriteChannels(const ClipInfo &clipInfo, int16 includeStateMask, int16 excludeStateMask) {
 
 	for (int i = 0; i <= 3; i++)
@@ -361,6 +352,8 @@ void Screen::updateSprites() {
 
 	_vm->_system->copyRectToScreen((const byte*)_workScreen->pixels, _workScreen->pitch, 0, 0, _workScreen->w, _workScreen->h);
 	
+	_vm->_system->updateScreen();
+	
 }
 
 void Screen::clearChannels() {
@@ -475,8 +468,6 @@ uint16 Screen::placeSprite(uint16 channelIndex, uint16 flexIndex, int16 x, int16
 		_channels[channelIndex].x2 = x2;
 		_channels[channelIndex].y2 = y2;
 		_channels[channelIndex].area = (x2 - x1) * (y2 - y1);
-		_channels[channelIndex].xofs = 0;
-		_channels[channelIndex].yofs = 0;
 
 		if (_channelsUsedCount <= channelIndex)
 			_channelsUsedCount = channelIndex + 1;
@@ -818,4 +809,25 @@ void Screen::updateScreenAndWait(int delay) {
 	_vm->_system->delayMillis(delay);
 }
 
+int16 Screen::addToSpriteList(int16 index, int16 xofs, int16 yofs) {
+	SpriteListItem item;
+	item.index = index;
+	item.xofs = xofs;
+	item.yofs = yofs;
+	_spriteList.push_back(item);
+	return _spriteList.size();
+}
+
+SpriteListItem Screen::getFromSpriteList(int16 index) {
+	return _spriteList[index - 1];
+}
+
+void Screen::clearSpriteList() {
+	_spriteList.clear();
+}
+
+void Screen::setDefaultMouseCursor() {
+	CursorMan.replaceCursor(defaultMouseCursor, 16, 16, 9, 2, 0);
+}
+
 } // End of namespace Made
diff --git a/engines/made/screen.h b/engines/made/screen.h
index 910096cacd..20085bebdc 100644
--- a/engines/made/screen.h
+++ b/engines/made/screen.h
@@ -31,6 +31,7 @@
 #include "common/rect.h"
 
 #include "graphics/surface.h"
+#include "graphics/cursorman.h"
 
 #include "made/resource.h"
 #include "made/screenfx.h"
@@ -42,7 +43,7 @@ struct SpriteChannel {
 	int16 state;
 	int16 needRefresh;
 	uint16 index;
-	int16 x, y, xofs, yofs;
+	int16 x, y;
 	int16 x1, y1, x2, y2;
 	uint32 area;
 	uint16 fontNum;
@@ -56,8 +57,31 @@ struct ClipInfo {
 	Graphics::Surface *destSurface;
 };
 
+struct SpriteListItem {
+	int16 index, xofs, yofs;
+};
+
 class MadeEngine;
 
+static const byte defaultMouseCursor[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,  1,  1,  0,  0,  0,  0,  0,  0,
+	0,  0,  0,  0,  0,  0,  0,  1, 15, 15,  1,  0,  0,  0,  0,  0,
+	0,  0,  0,  0,  0,  0,  0,  1, 15, 15,  1,  0,  0,  0,  0,  0,
+	0,  0,  0,  0,  0,  0,  0,  1, 15, 15,  1,  0,  0,  0,  0,  0,
+	0,  1,  1,  1,  1,  1,  1,  1, 15, 15,  1,  0,  0,  0,  0,  0,
+	1,  1, 15,  1, 15,  1, 15,  1, 15, 15,  1,  0,  0,  0,  0,  0,
+	1, 15, 15,  1, 15,  1, 15,  1, 15, 15,  1,  0,  0,  0,  0,  0,
+	1, 15, 15, 15, 15, 15, 15, 15, 15, 15,  1,  0,  1,  1,  1,  0,
+	1, 15, 15, 15, 15, 15, 15, 15, 15, 15,  1,  1, 15, 15, 15,  1,
+	1, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  1,  1,  1,
+	1, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  1,  1,  0,  0,
+	1,  1, 15, 15, 15, 15, 15, 15, 15, 15, 15,  1,  1,  0,  0,  0,
+	0,  1,  1, 15, 15, 15, 15, 15, 15, 15,  1,  1,  0,  0,  0,  0,
+	0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,
+	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
+};
+
 class Screen {
 public:
 	Screen(MadeEngine *vm);
@@ -120,8 +144,6 @@ public:
 	uint16 setChannelLocation(uint16 channelIndex, int16 x, int16 y);
 	uint16 setChannelContent(uint16 channelIndex, uint16 index);
 	void setChannelUseMask(uint16 channelIndex);
-	void setChannelOffsets(uint16 channelIndex, int16 xofs, int16 yofs);
-	void getChannelOffsets(uint16 channelIndex, int16 &xofs, int16 &yofs);
 	void drawSpriteChannels(const ClipInfo &clipInfo, int16 includeStateMask, int16 excludeStateMask);
 	void updateSprites();
 	void clearChannels();
@@ -161,6 +183,12 @@ public:
 	void showWorkScreen();
 	void updateScreenAndWait(int delay);
 
+	int16 addToSpriteList(int16 index, int16 xofs, int16 yofs);
+	SpriteListItem getFromSpriteList(int16 index);
+	void clearSpriteList();
+	
+	void setDefaultMouseCursor();
+
 protected:
 	MadeEngine *_vm;
 	ScreenEffects *_fx;
@@ -194,6 +222,8 @@ protected:
 	uint16 _channelsUsedCount;
 	SpriteChannel _channels[100];
 	
+	Common::Array<SpriteListItem> _spriteList;
+	
 };
 
 } // End of namespace Made
diff --git a/engines/made/screenfx.cpp b/engines/made/screenfx.cpp
index feea365615..b65c3db60c 100644
--- a/engines/made/screenfx.cpp
+++ b/engines/made/screenfx.cpp
@@ -60,19 +60,35 @@ void ScreenEffects::run(int16 effectNum, Graphics::Surface *surface, byte *palet
 
 	switch (effectNum) {
 
-	case 0:
+	case 0:		// No effect
 		vfx00(surface, palette, newPalette, colorCount);
 		break;
 
-	case 9:
+	case 2:
+		vfx02(surface, palette, newPalette, colorCount);
+		break;
+
+	case 9:		// "Checkerboard" effect
 		vfx09(surface, palette, newPalette, colorCount);
 		break;
 
-	case 14:
+	case 10:	// "Screen wipe in", left to right
+		vfx10(surface, palette, newPalette, colorCount);
+		break;
+
+	case 12:	// "Screen wipe in", top to bottom
+		vfx12(surface, palette, newPalette, colorCount);
+		break;
+
+	case 14:	// "Screen open" effect
 		vfx14(surface, palette, newPalette, colorCount);
 		break;
 
-	case 17:
+	case 15:
+		vfx15(surface, palette, newPalette, colorCount);
+		break;
+
+	case 17:	// Palette fadeout/fadein
 		vfx17(surface, palette, newPalette, colorCount);
 		break;
 
@@ -108,12 +124,12 @@ void ScreenEffects::setBlendedPalette(byte *palette, byte *newPalette, int color
 	if (!_screen->isPaletteLocked()) {
 		int32 mulValue = (value * 64) / maxValue;
 		for (int i = 0; i < colorCount * 3; i++)
-			_fxPalette[i] = newPalette[i] - (newPalette[i] - palette[i]) * mulValue / 64;
+			_fxPalette[i] = CLIP(newPalette[i] - (newPalette[i] - palette[i]) * mulValue / 64, 0, 255);
 		_screen->setRGBPalette(_fxPalette, 0, 256);
 	}
 }
 
-void ScreenEffects::copyRect(Graphics::Surface *surface, int16 x1, int16 y1, int16 x2, int16 y2) {
+void ScreenEffects::copyFxRect(Graphics::Surface *surface, int16 x1, int16 y1, int16 x2, int16 y2) {
 
 	// TODO: Clean up
 
@@ -189,26 +205,72 @@ void ScreenEffects::copyRect(Graphics::Surface *surface, int16 x1, int16 y1, int
 
 }
 
+void ScreenEffects::copyRect(Graphics::Surface *surface, int16 x1, int16 y1, int16 x2, int16 y2) {
+	Graphics::Surface *vgaScreen = _screen->lockScreen();
+	byte *source = (byte*)surface->getBasePtr(x1, y1);
+	byte *dest = (byte*)vgaScreen->getBasePtr(x1, y1);
+	for (int y = 0; y < y2 - y1; y++) {
+		memcpy(dest, source, x2 - x1);
+		dest += 320;
+		source += 320;
+	}
+	_screen->unlockScreen();
+}
+
+// No effect
 void ScreenEffects::vfx00(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
 	setPalette(palette);
 	_screen->showWorkScreen();
+	// FIXME: For Manhole; causes sluggish mouse
+	_screen->updateScreenAndWait(100);
+}
+
+void ScreenEffects::vfx02(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
+	for (int x = 312; x >= 0; x -= 8) {
+		copyRect(surface, x, 0, x + 8, 200);
+		setBlendedPalette(palette, newPalette, colorCount, 312 - x, 312);
+		_screen->updateScreenAndWait(25);
+	}
+ 	setPalette(palette);
 }
 
+// "Checkerboard" effect
 void ScreenEffects::vfx09(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
 	for (int i = 0; i < 8; i++) {
-		copyRect(surface, 0, 0, 320, 200);
+		copyFxRect(surface, 0, 0, 320, 200);
 		for (int j = 0; j < 4; j++) {
-			setBlendedPalette(palette, newPalette, colorCount, i * 4 + j, 32);
+			setBlendedPalette(palette, newPalette, colorCount, i * 4 + j, 36/*FIX?*/);
 			_screen->updateScreenAndWait(25);
 		}
 	}
 	setPalette(palette);
 }
 
+// "Screen wipe in", left to right
+void ScreenEffects::vfx10(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
+	for (int x = -56; x < 312; x += 8) {
+		copyFxRect(surface, x, 0, x + 64, 200);
+		setBlendedPalette(palette, newPalette, colorCount, x + 56, 368);
+		_screen->updateScreenAndWait(25);
+	}
+	setPalette(palette);
+}
+
+// "Screen wipe in", top to bottom
+void ScreenEffects::vfx12(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
+	for (int y = -70; y < 312; y += 10) {
+		copyFxRect(surface, 0, y, 320, y + 80);
+		setBlendedPalette(palette, newPalette, colorCount, y + 70, 260);
+		_screen->updateScreenAndWait(25);
+	}
+	setPalette(palette);
+}
+
+// "Screen open" effect
 void ScreenEffects::vfx14(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
 	int16 x = 8, y = 5;
 	for (int i = 0; i < 27; i++) {
-		copyRect(surface, 160 - x, 100 - y, 160 + x, 100 + y);
+		copyFxRect(surface, 160 - x, 100 - y, 160 + x, 100 + y);
 		x += 8;
 		y += 5;
 		setBlendedPalette(palette, newPalette, colorCount, i, 27);
@@ -217,6 +279,18 @@ void ScreenEffects::vfx14(Graphics::Surface *surface, byte *palette, byte *newPa
  	setPalette(palette);
 }
 
+void ScreenEffects::vfx15(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
+	int16 x = 8;
+	for (int i = 0; i < 27; i++) {
+		copyFxRect(surface, 160 - x, 0, 160 + x, 200);
+		x += 8;
+		setBlendedPalette(palette, newPalette, colorCount, i, 27);
+		_screen->updateScreenAndWait(25);
+	}
+ 	setPalette(palette);
+}
+
+// Palette fadeout/fadein
 void ScreenEffects::vfx17(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount) {
 
 	byte tempPalette[768];
diff --git a/engines/made/screenfx.h b/engines/made/screenfx.h
index e1f877b42e..1c36b3e1f1 100644
--- a/engines/made/screenfx.h
+++ b/engines/made/screenfx.h
@@ -51,10 +51,15 @@ private:
 	int16 vfxX1, vfxY1, vfxWidth, vfxHeight;
 	void setPalette(byte *palette);
 	void setBlendedPalette(byte *palette, byte *newPalette, int colorCount, int16 value, int16 maxValue);
+	void copyFxRect(Graphics::Surface *surface, int16 x1, int16 y1, int16 x2, int16 y2);
 	void copyRect(Graphics::Surface *surface, int16 x1, int16 y1, int16 x2, int16 y2);
 	void vfx00(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount);
+	void vfx02(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount);
 	void vfx09(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount);
+	void vfx10(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount);
+	void vfx12(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount);
 	void vfx14(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount);
+	void vfx15(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount);
 	void vfx17(Graphics::Surface *surface, byte *palette, byte *newPalette, int colorCount);
 };
 
diff --git a/engines/made/script.cpp b/engines/made/script.cpp
index 8b5a48cdd7..4bda35dcc3 100644
--- a/engines/made/script.cpp
+++ b/engines/made/script.cpp
@@ -91,83 +91,87 @@ int16 *ScriptStack::getStackPtr() {
 /* ScriptInterpreter */
 
 ScriptInterpreter::ScriptInterpreter(MadeEngine *vm) : _vm(vm) {
-#define COMMAND(x) { &ScriptInterpreter::x, #x }
+#ifdef DUMP_SCRIPTS
+#define COMMAND(x, sig) { &ScriptInterpreter::x, #x, sig }
+#else
+#define COMMAND(x, sig) { &ScriptInterpreter::x, #x}
+#endif
 	static CommandEntry commandProcs[] = {
 		/* 01 */
-		COMMAND(cmd_branchTrue),
-		COMMAND(cmd_branchFalse),
-		COMMAND(cmd_branch),
-		COMMAND(cmd_true),
+		COMMAND(cmd_branchTrue, "W"),
+		COMMAND(cmd_branchFalse, "W"),
+		COMMAND(cmd_branch, "W"),
+		COMMAND(cmd_true, ""),
 		/* 05 */
-		COMMAND(cmd_false),
-		COMMAND(cmd_push),
-		COMMAND(cmd_not),
-		COMMAND(cmd_add),
+		COMMAND(cmd_false, ""),
+		COMMAND(cmd_push, ""),
+		COMMAND(cmd_not, ""),
+		COMMAND(cmd_add, ""),
 		/* 09 */
-		COMMAND(cmd_sub),
-		COMMAND(cmd_mul),
-		COMMAND(cmd_div),
-		COMMAND(cmd_mod),
+		COMMAND(cmd_sub, ""),
+		COMMAND(cmd_mul, ""),
+		COMMAND(cmd_div, ""),
+		COMMAND(cmd_mod, ""),
 		/* 13 */
-		COMMAND(cmd_band),
-		COMMAND(cmd_bor),
-		COMMAND(cmd_bnot),
-		COMMAND(cmd_lt),
+		COMMAND(cmd_band, ""),
+		COMMAND(cmd_bor, ""),
+		COMMAND(cmd_bnot, ""),
+		COMMAND(cmd_lt, ""),
 		/* 17 */
-		COMMAND(cmd_eq),
-		COMMAND(cmd_gt),
-		COMMAND(cmd_loadConstant),
-		COMMAND(cmd_loadVariable),
+		COMMAND(cmd_eq, ""),
+		COMMAND(cmd_gt, ""),
+		COMMAND(cmd_loadConstant, "w"),
+		COMMAND(cmd_loadVariable, "w"),
 		/* 21 */
-		COMMAND(cmd_getObjectProperty),
-		COMMAND(cmd_setObjectProperty),
-		COMMAND(cmd_set),
-		COMMAND(cmd_print),
+		COMMAND(cmd_getObjectProperty, ""),
+		COMMAND(cmd_setObjectProperty, ""),
+		COMMAND(cmd_set, "w"),
+		COMMAND(cmd_print, ""),
 		/* 25 */
-		COMMAND(cmd_terpri),
-		COMMAND(cmd_printNumber),
-		COMMAND(cmd_vref),
-		COMMAND(cmd_vset),
+		COMMAND(cmd_terpri, ""),
+		COMMAND(cmd_printNumber, ""),
+		COMMAND(cmd_vref, ""),
+		COMMAND(cmd_vset, ""),
 		/* 29 */
-		COMMAND(cmd_vsize),
-		COMMAND(cmd_exit),
-		COMMAND(cmd_return),
-		COMMAND(cmd_call),
+		COMMAND(cmd_vsize, ""),
+		COMMAND(cmd_exit, ""),
+		COMMAND(cmd_return, ""),
+		COMMAND(cmd_call, "b"),
 		/* 33 */
-		COMMAND(cmd_svar),
-		COMMAND(cmd_sset),
-		COMMAND(cmd_split),
-		COMMAND(cmd_snlit),
+		COMMAND(cmd_svar, ""),
+		COMMAND(cmd_sset, ""),
+		COMMAND(cmd_split, ""),
+		COMMAND(cmd_snlit, ""),
 		/* 37 */
-		COMMAND(cmd_yorn),
-		COMMAND(cmd_save),
-		COMMAND(cmd_restore),
-		COMMAND(cmd_arg),
+		COMMAND(cmd_yorn, ""),
+		COMMAND(cmd_save, ""),
+		COMMAND(cmd_restore, ""),
+		COMMAND(cmd_arg, "b"),
 		/* 41 */
-		COMMAND(cmd_aset),
-		COMMAND(cmd_tmp),
-		COMMAND(cmd_tset),
-		COMMAND(cmd_tspace),
+		COMMAND(cmd_aset, "b"),
+		COMMAND(cmd_tmp, "b"),
+		COMMAND(cmd_tset, "b"),
+		COMMAND(cmd_tspace, "b"),
 		/* 45 */
-		COMMAND(cmd_class),
-		COMMAND(cmd_objectp),
-		COMMAND(cmd_vectorp),
-		COMMAND(cmd_restart),
+		COMMAND(cmd_class, ""),
+		COMMAND(cmd_objectp, ""),
+		COMMAND(cmd_vectorp, ""),
+		COMMAND(cmd_restart, ""),
 		/* 49 */
-		COMMAND(cmd_rand),
-		COMMAND(cmd_randomize),
-		COMMAND(cmd_send),
-		COMMAND(cmd_extend),
+		COMMAND(cmd_rand, ""),
+		COMMAND(cmd_randomize, ""),
+		COMMAND(cmd_send, "b"),
+		COMMAND(cmd_extend, "Eb"),
 		/* 53 */
-		COMMAND(cmd_catch),
-		COMMAND(cmd_cdone),
-		COMMAND(cmd_throw),
-		COMMAND(cmd_functionp),
+		COMMAND(cmd_catch, ""),
+		COMMAND(cmd_cdone, ""),
+		COMMAND(cmd_throw, ""),
+		COMMAND(cmd_functionp, ""),
 		/* 57 */
-		COMMAND(cmd_le),
-		COMMAND(cmd_ge),
-		COMMAND(cmd_varx),
-		COMMAND(cmd_setx)
+		COMMAND(cmd_le, ""),
+		COMMAND(cmd_ge, ""),
+		COMMAND(cmd_varx, ""),
+		COMMAND(cmd_setx, "")
 	};
 	_commands = commandProcs;
 	_commandsMax = ARRAYSIZE(commandProcs) + 1;
@@ -183,7 +187,6 @@ ScriptInterpreter::~ScriptInterpreter() {
 }
 
 void ScriptInterpreter::runScript(int16 scriptObjectIndex) {
-
 	_vm->_quit = false;
 	_runningScriptObjectIndex = scriptObjectIndex;
 
@@ -193,15 +196,18 @@ void ScriptInterpreter::runScript(int16 scriptObjectIndex) {
 	_codeIp = _codeBase;
 	
 	while (!_vm->_quit) {
+
+		_vm->handleEvents();
+
 		byte opcode = readByte();
 		if (opcode >= 1 && opcode <= _commandsMax) {
-			debug(4, "[%04X:%04X] opcode = %s", _runningScriptObjectIndex, (uint) (_codeIp - _codeBase), _commands[opcode - 1].desc);
+			debug(4, "[%04X:%04X] %s", _runningScriptObjectIndex, (uint) (_codeIp - _codeBase), _commands[opcode - 1].desc);
 			(this->*_commands[opcode - 1].proc)();
 		} else {
 			warning("ScriptInterpreter::runScript(%d) Unknown opcode %02X", _runningScriptObjectIndex, opcode);
 		}
+		
 	}
-
 }
 
 byte ScriptInterpreter::readByte() {
@@ -436,6 +442,7 @@ void ScriptInterpreter::cmd_return() {
 void ScriptInterpreter::cmd_call() {
 	debug(4, "\nENTER: stackPtr = %d; _localStackPos = %d", _stack.getStackPos(), _localStackPos);
 	byte argc = readByte();
+
 	_stack.push(argc);
 	_stack.push(_codeIp - _codeBase);
 	_stack.push(_runningScriptObjectIndex);
@@ -448,22 +455,27 @@ void ScriptInterpreter::cmd_call() {
 }
 
 void ScriptInterpreter::cmd_svar() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_svar");
 }
 
 void ScriptInterpreter::cmd_sset() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_sset");
 }
 
 void ScriptInterpreter::cmd_split() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_split");
 }
 
 void ScriptInterpreter::cmd_snlit() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_snlit");
 }
 
 void ScriptInterpreter::cmd_yorn() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_yorn");
 }
 
@@ -514,6 +526,7 @@ void ScriptInterpreter::cmd_tspace() {
 }
 
 void ScriptInterpreter::cmd_class() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_class");
 }
 
@@ -526,10 +539,12 @@ void ScriptInterpreter::cmd_objectp() {
 }
 
 void ScriptInterpreter::cmd_vectorp() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_vectorp");
 }
 
 void ScriptInterpreter::cmd_restart() {
+	// TODO: Used in RTZ
 	warning("Unimplemented command: cmd_restart");
 }
 
@@ -592,8 +607,7 @@ void ScriptInterpreter::cmd_extend() {
 	byte argc = readByte();
 	int16 *argv = _stack.getStackPtr();
 
-	//debug(4, "func = %d (%s); argc = %d", func, extendFuncNames[func], argc);
-	debug(2, "func = %d; argc = %d", func, argc);
+	debug(4, "func = %d (%s); argc = %d", func, _functions->getFuncName(func), argc);
 	for (int i = 0; i < argc; i++)
 		debug(2, "argv[%02d] = %04X (%d)", i, argv[i], argv[i]);
 
@@ -607,18 +621,22 @@ void ScriptInterpreter::cmd_extend() {
 }
 
 void ScriptInterpreter::cmd_catch() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_catch");
 }
 
 void ScriptInterpreter::cmd_cdone() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_cdone");
 }
 
 void ScriptInterpreter::cmd_throw() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_throw");
 }
 
 void ScriptInterpreter::cmd_functionp() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_functionp");
 }
 
@@ -639,11 +657,131 @@ void ScriptInterpreter::cmd_ge() {
 }
 
 void ScriptInterpreter::cmd_varx() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_varx");
 }
 
 void ScriptInterpreter::cmd_setx() {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented command: cmd_setx");
 }
 
+#ifdef DUMP_SCRIPTS
+void ScriptInterpreter::dumpScript(int16 objectIndex, int *opcodeStats, int *externStats) {
+
+	debug(1, "Dumping code for object %04X", objectIndex);
+
+	Object *obj = _vm->_dat->getObject(objectIndex);
+	byte *code = obj->getData(), *codeEnd = code + obj->getSize();
+	
+	while (code < codeEnd) {
+		byte opcode = *code++;
+		if (opcode >= 1 && opcode <= _commandsMax) {
+			Common::String codeLine;
+			const char *desc = _commands[opcode - 1].desc;
+			const char *sig = _commands[opcode - 1].sig;
+			int valueType; /* 0: dec; 1: hex; 2: extended function */
+			int16 value;
+			char tempStr[32];
+			opcodeStats[opcode - 1]++;
+			codeLine += desc;
+			for (; *sig != '\0'; sig++) {
+				codeLine += " ";
+				switch (*sig) {
+				case 'b':
+					valueType = 0;
+	 				value = *code++;
+					break;
+				case 'B':
+	 				valueType = 1;
+	 				value = *code++;
+					break;
+				case 'w':
+					valueType = 0;
+	 				value = READ_LE_UINT16(code);
+	 				code += 2;
+					break;
+				case 'W':
+	 				valueType = 1;
+	 				value = READ_LE_UINT16(code);
+	 				code += 2;
+					break;
+				case 'E':
+	 				valueType = 2;
+	 				value = *code++;
+					break;
+				}
+				switch (valueType) {
+				case 0:
+					snprintf(tempStr, 32, "%d", value);
+					break;
+				case 1:
+					snprintf(tempStr, 32, "0x%X", value);
+					break;
+				case 2:
+					if (value < _functions->getCount()) {
+						snprintf(tempStr, 32, "%s", _functions->getFuncName(value));
+						externStats[value]++;
+					} else {
+						snprintf(tempStr, 32, "invalid: %d", value);
+	 				}
+					break;
+				}
+				codeLine += tempStr;
+			}
+			debug(1, "%s", codeLine.c_str());
+		} else {
+			error("ScriptInterpreter::dumpScript(%d) Unknown opcode %02X", objectIndex, opcode);
+		}
+	}
+	debug(1, "-------------------------------------------");
+}
+
+void ScriptInterpreter::dumpAllScripts() {
+	int *opcodeStats = new int[_commandsMax - 1];
+	int *externStats = new int[_functions->getCount()];
+
+	for (int i = 0; i < _commandsMax; i++)
+		opcodeStats[i] = 0;
+	for (int i = 0; i < _functions->getCount(); i++)
+		externStats[i] = 0;
+
+	for (uint objectIndex = 1; objectIndex <= _vm->_dat->getObjectCount(); objectIndex++) {
+		Object *obj = _vm->_dat->getObject(objectIndex);
+		// Check if it's a byte array which might contain code
+		if (obj->getClass() != 0x7FFF)
+			continue;
+		// Code objects aren't excplicitly marked as such, we need to check if
+		// the last byte is a cmd_return opcode.
+		byte *retByte = obj->getData() + obj->getSize() - 1;
+		if (*retByte == 0x1F) {
+			dumpScript(objectIndex, opcodeStats, externStats);
+		}
+	}
+
+	debug(1, "OPCODE statistics:");
+	for (int i = 0; i < _commandsMax - 1; i++)
+		if (opcodeStats[i] > 0)
+			debug(1, "%-30s: %d", _commands[i].desc, opcodeStats[i]);
+	debug(1, "UNUSED OPCODE statistics:");
+	for (int i = 0; i < _commandsMax - 1; i++)
+		if (opcodeStats[i] == 0)
+			debug(1, "%-30s: %d", _commands[i].desc, opcodeStats[i]);
+	debug(1, ".");
+
+	debug(1, "EXTERN statistics (%d):", _functions->getCount());
+	for (int i = 0; i < _functions->getCount(); i++)
+		if (externStats[i] > 0)
+			debug(1, "%-30s: %d", _functions->getFuncName(i), externStats[i]);
+	debug(1, "UNUSED EXTERN statistics (%d):", _functions->getCount());
+	for (int i = 0; i < _functions->getCount(); i++)
+		if (externStats[i] == 0)
+			debug(1, "%-30s: %d", _functions->getFuncName(i), externStats[i]);
+	debug(1, ".");
+
+	delete[] opcodeStats;
+	delete[] externStats;
+}
+#endif
+
 } // End of namespace Made
diff --git a/engines/made/script.h b/engines/made/script.h
index 6c031f8708..459a088cb8 100644
--- a/engines/made/script.h
+++ b/engines/made/script.h
@@ -32,6 +32,11 @@
 
 namespace Made {
 
+// Define this to dump all game scripts and a usage statistic of all
+// opcodes/extended functions instead of running the actual game.
+// Then run ScummVM with debuglevel 1.
+//#define DUMP_SCRIPTS
+
 class MadeEngine;
 class ScriptFunctions;
 
@@ -63,6 +68,8 @@ public:
 	ScriptInterpreter(MadeEngine *vm);
 	~ScriptInterpreter();
 	void runScript(int16 scriptObjectIndex);
+	void dumpScript(int16 objectIndex, int *opcodeStats, int *externStats);
+	void dumpAllScripts();
 protected:
 	MadeEngine *_vm;
 
@@ -81,6 +88,9 @@ protected:
 	struct CommandEntry {
 		CommandProc proc;
 		const char *desc;
+#ifdef DUMP_SCRIPTS
+		const char *sig;
+#endif
 	};
 
 	const CommandEntry *_commands;
diff --git a/engines/made/scriptfuncs.cpp b/engines/made/scriptfuncs.cpp
index 2819f127ef..f67b7c89c6 100644
--- a/engines/made/scriptfuncs.cpp
+++ b/engines/made/scriptfuncs.cpp
@@ -188,67 +188,18 @@ int16 ScriptFunctions::sfClearScreen(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfShowPage(int16 argc, int16 *argv) {
-	_vm->_mixer->stopHandle(_audioStreamHandle);
+ 	if (_vm->getGameID() != GID_RTZ)
+		_vm->_mixer->stopHandle(_audioStreamHandle);
 	_vm->_screen->show();
 	return 0;
 }
 
 int16 ScriptFunctions::sfPollEvent(int16 argc, int16 *argv) {
 
-	Common::Event event;
-	Common::EventManager *eventMan = g_system->getEventManager();
-
-	int16 eventNum = 0;
-
-	if (eventMan->pollEvent(event)) {
-		switch (event.type) {
-
-		case Common::EVENT_MOUSEMOVE:
-			_vm->_eventMouseX = event.mouse.x;
-			_vm->_eventMouseY = event.mouse.y;
-			break;
-			
-		case Common::EVENT_LBUTTONDOWN:
-			eventNum = 1;
-			break;
-
-		/*
-		case Common::EVENT_LBUTTONUP:
-			eventNum = 2; // TODO: Is this correct?
-			break;
-		*/
-
-		case Common::EVENT_RBUTTONDOWN:
-			eventNum = 3;
-			break;
-
-		/*
-		case Common::EVENT_RBUTTONUP:
-			eventNum = 4; // TODO: Is this correct?
-			break;
-		*/
-
-		case Common::EVENT_KEYDOWN:
-			_vm->_eventKey = event.kbd.ascii;
-			// For unknown reasons, the game accepts ASCII code
-			// 9 as backspace
-			if (_vm->_eventKey == Common::KEYCODE_BACKSPACE)
-				_vm->_eventKey = 9;
-			eventNum = 5;
-			break;
-
-		case Common::EVENT_QUIT:
-			_vm->_quit = true;
-			break;
-
-		default:
-			break;
-
-		}
-	}
-
 	_vm->_system->updateScreen();
 
+	int16 eventNum = _vm->_eventNum;
+	_vm->_eventNum = 0;
 	return eventNum;
 }
 
@@ -318,6 +269,7 @@ int16 ScriptFunctions::sfIsMusicPlaying(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfSetTextPos(int16 argc, int16 *argv) {
+	// TODO: Used in Manhole:NE
 	warning("Unimplemented opcode: sfSetTextPos");
 	// This seems to be some kind of low-level opcode.
 	// The original engine calls int 10h to set the VGA cursor position.
@@ -330,21 +282,25 @@ int16 ScriptFunctions::sfFlashScreen(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfPlayNote(int16 argc, int16 *argv) {
+	// TODO: Used in Manhole:NE
 	warning("Unimplemented opcode: sfPlayNote");
 	return 0;
 }
 
 int16 ScriptFunctions::sfStopNote(int16 argc, int16 *argv) {
+	// TODO: Used in Manhole:NE
 	warning("Unimplemented opcode: sfStopNote");
 	return 0;
 }
 
 int16 ScriptFunctions::sfPlayTele(int16 argc, int16 *argv) {
+	// TODO: Used in Manhole:NE
 	warning("Unimplemented opcode: sfPlayTele");
 	return 0;
 }
 
 int16 ScriptFunctions::sfStopTele(int16 argc, int16 *argv) {
+	// TODO: Used in Manhole:NE
 	warning("Unimplemented opcode: sfStopTele");
 	return 0;
 }
@@ -373,10 +329,10 @@ int16 ScriptFunctions::sfSetScreenLock(int16 argc, int16 *argv) {
 
 int16 ScriptFunctions::sfAddSprite(int16 argc, int16 *argv) {
 	if (_vm->getGameID() == GID_RTZ) {
-		warning("Unimplemented opcode: sfAddSprite");
+		// Unused in RTZ
 		return 0;
 	} if (_vm->getGameID() == GID_LGOP2 || _vm->getGameID() == GID_MANHOLE) {
-		return argv[2];
+		return _vm->_screen->addToSpriteList(argv[2], argv[1], argv[0]);
 	} else {
 		return 0;
 	}
@@ -384,6 +340,9 @@ int16 ScriptFunctions::sfAddSprite(int16 argc, int16 *argv) {
 
 int16 ScriptFunctions::sfFreeAnim(int16 argc, int16 *argv) {
 	_vm->_screen->clearChannels();
+	if (_vm->getGameID() == GID_LGOP2 || _vm->getGameID() == GID_MANHOLE) {
+		_vm->_screen->clearSpriteList();
+	}
 	return 0;
 }
 
@@ -391,8 +350,9 @@ int16 ScriptFunctions::sfDrawSprite(int16 argc, int16 *argv) {
 	if (_vm->getGameID() == GID_RTZ) {
 		return _vm->_screen->drawSprite(argv[2], argv[1], argv[0]);
 	} if (_vm->getGameID() == GID_LGOP2 || _vm->getGameID() == GID_MANHOLE) {
-		int16 channel = _vm->_screen->drawSprite(argv[2], argv[1], argv[0]);
-		_vm->_screen->setChannelUseMask(channel);
+		SpriteListItem item = _vm->_screen->getFromSpriteList(argv[2]);
+		int16 channelIndex = _vm->_screen->drawSprite(item.index, argv[1] - item.xofs, argv[0] - item.yofs);
+		_vm->_screen->setChannelUseMask(channelIndex);
 		return 0;
 	} else {
 		return 0;
@@ -482,6 +442,7 @@ int16 ScriptFunctions::sfDrawText(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfHomeText(int16 argc, int16 *argv) {
+	// TODO: Used in LGOP2
 	warning("Unimplemented opcode: sfHomeText");
 	return 0;
 }
@@ -529,7 +490,6 @@ int16 ScriptFunctions::sfLoadMouseCursor(int16 argc, int16 *argv) {
 	if (flex) {
 		Graphics::Surface *surf = flex->getPicture();
 		CursorMan.replaceCursor((const byte *)surf->pixels, surf->w, surf->h, argv[1], argv[0], 0);
-		CursorMan.showMouse(true);
 		_vm->_res->freeResource(flex);
 	}
 	return 0;
@@ -541,6 +501,7 @@ int16 ScriptFunctions::sfSetSpriteGround(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfLoadResText(int16 argc, int16 *argv) {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented opcode: sfLoadResText");
 	return 0;
 }
@@ -610,6 +571,7 @@ int16 ScriptFunctions::sfGetCdTime(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfPlayCdSegment(int16 argc, int16 *argv) {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented opcode: sfPlayCdSegment");
 	return 0;
 }
@@ -622,6 +584,7 @@ int16 ScriptFunctions::sfPrintf(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfClearMono(int16 argc, int16 *argv) {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented opcode: sfClearMono");
 	return 0;
 }
@@ -636,11 +599,13 @@ int16 ScriptFunctions::sfGetSoundEnergy(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfClearText(int16 argc, int16 *argv) {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented opcode: sfClearText");
 	return 1;
 }
 
 int16 ScriptFunctions::sfAnimText(int16 argc, int16 *argv) {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented opcode: sfAnimText");
 	return 0;
 }
@@ -691,11 +656,13 @@ int16 ScriptFunctions::sfLoadPicture(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfSetMusicVolume(int16 argc, int16 *argv) {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented opcode: sfSetMusicVolume");
 	return 0;
 }
 
 int16 ScriptFunctions::sfRestartEvents(int16 argc, int16 *argv) {
+	// TODO: Used in RTZ
 	warning("Unimplemented opcode: sfRestartEvents");
 	return 0;
 }
@@ -723,11 +690,13 @@ int16 ScriptFunctions::sfSetChannelState(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfSetChannelLocation(int16 argc, int16 *argv) {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented opcode: sfSetChannelLocation");
 	return 0;
 }
 
 int16 ScriptFunctions::sfSetChannelContent(int16 argc, int16 *argv) {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented opcode: sfSetChannelContent");
 	return 0;
 }
@@ -795,6 +764,7 @@ int16 ScriptFunctions::sfSetSoundRate(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfDrawAnimPic(int16 argc, int16 *argv) {
+	// TODO: Used in RTZ
 	warning("Unimplemented opcode: sfDrawAnimPic");
 	return 0;
 }
@@ -809,6 +779,7 @@ int16 ScriptFunctions::sfLoadAnim(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfReadText(int16 argc, int16 *argv) {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented opcode: sfReadText");
 	return 0;
 }
@@ -912,11 +883,13 @@ int16 ScriptFunctions::sfGetGameDescription(int16 argc, int16 *argv) {
 }
 
 int16 ScriptFunctions::sfShakeScreen(int16 argc, int16 *argv) {
+	// TODO: Used in RTZ
 	warning("Unimplemented opcode: sfShakeScreen");
 	return 0;
 }
 
 int16 ScriptFunctions::sfPlaceMenu(int16 argc, int16 *argv) {
+	// Never used in LGOP2, RTZ, Manhole:NE
 	warning("Unimplemented opcode: sfPlaceMenu");
 	return 0;
 }
diff --git a/engines/made/scriptfuncs.h b/engines/made/scriptfuncs.h
index 052856065e..9879556c3f 100644
--- a/engines/made/scriptfuncs.h
+++ b/engines/made/scriptfuncs.h
@@ -53,6 +53,8 @@ public:
 		return (*_externalFuncs[index])(argc, argv);
 	}
 	void setupExternalsTable();
+	const char* getFuncName(int index) { return _externalFuncNames[index]; }
+	int getCount() const { return _externalFuncs.size(); }
 protected:
 	MadeEngine *_vm;
 	Audio::SoundHandle _audioStreamHandle;
diff --git a/engines/metaengine.h b/engines/metaengine.h
index c5fb006faa..aef860e0f9 100644
--- a/engines/metaengine.h
+++ b/engines/metaengine.h
@@ -108,7 +108,7 @@ private:
 public:
 	GameDescriptor findGame(const Common::String &gameName, const EnginePlugin **plugin = NULL) const;
 	GameList detectGames(const FSList &fslist) const;
-	const EnginePlugin::list &getPlugins() const;
+	const EnginePlugin::List &getPlugins() const;
 };
 
 /** Convenience shortcut for accessing the engine manager. */
diff --git a/engines/parallaction/callables_ns.cpp b/engines/parallaction/callables_ns.cpp
index 402f69c99d..68e6a70ffb 100644
--- a/engines/parallaction/callables_ns.cpp
+++ b/engines/parallaction/callables_ns.cpp
@@ -468,7 +468,6 @@ void Parallaction_ns::_c_endIntro(void *parm) {
 
 	debugC(1, kDebugExec, "endIntro()");
 
-	uint32 event;
 	uint id[2];
 	for (uint16 _si = 0; _si < 6; _si++) {
 		id[0] = _gfx->createLabel(_menuFont, _credits[_si]._role, 1);
@@ -479,14 +478,7 @@ void Parallaction_ns::_c_endIntro(void *parm) {
 
 		_gfx->updateScreen();
 
-		for (uint16 v2 = 0; v2 < 100; v2++) {
-			_input->readInput();
-			event = _input->getLastButtonEvent();
-			if (event == kMouseLeftUp)
-				break;
-
-			waitTime( 1 );
-		}
+		_input->waitForButtonEvent(kMouseLeftUp, 5500);
 
 		_gfx->freeLabels();
 	}
diff --git a/engines/parallaction/gui_ns.cpp b/engines/parallaction/gui_ns.cpp
index 91cc77e823..1d4d44fa46 100644
--- a/engines/parallaction/gui_ns.cpp
+++ b/engines/parallaction/gui_ns.cpp
@@ -213,11 +213,7 @@ int Parallaction_ns::guiNewGame() {
 
 	_input->waitForButtonEvent(kMouseLeftUp | kMouseRightUp);
 	uint32 event = _input->getLastButtonEvent();
-/*
-	do {
-		_input->readInput();
-	} while (_mouseButtons != kMouseLeftUp && _mouseButtons != kMouseRightUp);
-*/
+
 	_input->showCursor(true);
 
 	_gfx->freeLabels();
diff --git a/engines/parallaction/input.cpp b/engines/parallaction/input.cpp
index dc26debba7..28d0ad888d 100644
--- a/engines/parallaction/input.cpp
+++ b/engines/parallaction/input.cpp
@@ -83,7 +83,7 @@ uint16 Input::readInput() {
 			// TODO: don't quit() here, just have caller routines to check
 			// on kEngineQuit and exit gracefully to allow the engine to shut down
 			_engineFlags |= kEngineQuit;
-			g_system->quit();
+			_vm->_system->quit();
 			break;
 
 		default:
@@ -101,17 +101,26 @@ uint16 Input::readInput() {
 }
 
 // FIXME: see comment for readInput()
-void Input::waitForButtonEvent(uint32 buttonEventMask) {
+void Input::waitForButtonEvent(uint32 buttonEventMask, int32 timeout) {
 
 	if (buttonEventMask == kMouseNone) {
 		_mouseButtons = kMouseNone;	// don't wait on nothing
 		return;
 	}
 
-	do {
-		readInput();
-		g_system->delayMillis(30);
-	} while ((_mouseButtons & buttonEventMask) == 0);
+	const int32 LOOP_RESOLUTION = 30;
+	if (timeout <= 0) {
+		do {
+			readInput();
+			_vm->_system->delayMillis(LOOP_RESOLUTION);
+		} while ((_mouseButtons & buttonEventMask) == 0);
+	} else {
+		do {
+			readInput();
+			_vm->_system->delayMillis(LOOP_RESOLUTION);
+			timeout -= LOOP_RESOLUTION;
+		} while ((timeout > 0) && (_mouseButtons & buttonEventMask) == 0);
+	}
 
 }
 
@@ -121,38 +130,12 @@ void Input::waitUntilLeftClick() {
 	do {
 		readInput();
 		_vm->_gfx->updateScreen();
-		g_system->delayMillis(30);
+		_vm->_system->delayMillis(30);
 	} while (_mouseButtons != kMouseLeftUp);
 
 	return;
 }
 
-void Parallaction::runGame() {
-
-	InputData *data = _input->updateInput();
-	if (data->_event != kEvNone) {
-		processInput(data);
-	}
-
-	runPendingZones();
-
-	if (_engineFlags & kEngineChangeLocation) {
-		changeLocation(_location._name);
-	}
-
-
-	_gfx->beginFrame();
-
-	if (_input->_inputMode == Input::kInputModeGame) {
-		runScripts();
-		walk();
-		drawAnimations();
-	}
-
-	// change this to endFrame?
-	updateView();
-
-}
 
 void Input::updateGameInput() {
 
diff --git a/engines/parallaction/input.h b/engines/parallaction/input.h
index 3d072384a2..46dbb08c4e 100644
--- a/engines/parallaction/input.h
+++ b/engines/parallaction/input.h
@@ -68,6 +68,7 @@ class Input {
 	uint16	_mouseButtons;
 
 	bool		_mouseHidden;
+	ZonePtr			_hoverZone;
 
 public:
 	enum {
@@ -94,13 +95,12 @@ public:
 	}
 
 	int				_inputMode;
-	ZonePtr			_hoverZone;
 	InventoryItem	_activeItem;
 
 	uint16	readInput();
 	InputData* 	updateInput();
 	void 	waitUntilLeftClick();
-	void	waitForButtonEvent(uint32 buttonEventMask);
+	void	waitForButtonEvent(uint32 buttonEventMask, int32 timeout = -1);
 	uint32	getLastButtonEvent() { return _mouseButtons; }
 
 	void stopHovering() {
diff --git a/engines/parallaction/parallaction.cpp b/engines/parallaction/parallaction.cpp
index eb766661c3..d66b1af1f1 100644
--- a/engines/parallaction/parallaction.cpp
+++ b/engines/parallaction/parallaction.cpp
@@ -153,29 +153,6 @@ void Parallaction::updateView() {
 }
 
 
-uint32 Parallaction::getElapsedTime() {
-	return g_system->getMillis() - _baseTime;
-}
-
-void Parallaction::resetTimer() {
-	_baseTime = g_system->getMillis();
-	return;
-}
-
-
-void Parallaction::waitTime(uint32 t) {
-
-	uint32 v4 = 0;
-
-	while (v4 < t * (1000 / 18.2)) {
-		v4 = getElapsedTime();
-	}
-
-	resetTimer();
-
-	return;
-}
-
 
 void Parallaction::freeCharacter() {
 	debugC(1, kDebugExec, "freeCharacter()");
@@ -370,6 +347,33 @@ void Parallaction::processInput(InputData *data) {
 	return;
 }
 
+void Parallaction::runGame() {
+
+	InputData *data = _input->updateInput();
+	if (data->_event != kEvNone) {
+		processInput(data);
+	}
+
+	runPendingZones();
+
+	if (_engineFlags & kEngineChangeLocation) {
+		changeLocation(_location._name);
+	}
+
+
+	_gfx->beginFrame();
+
+	if (_input->_inputMode == Input::kInputModeGame) {
+		runScripts();
+		walk();
+		drawAnimations();
+	}
+
+	// change this to endFrame?
+	updateView();
+
+}
+
 
 
 
@@ -409,8 +413,8 @@ void Parallaction::doLocationEnterTransition() {
 	for (uint16 _si = 0; _si<6; _si++) {
 		pal.fadeTo(_gfx->_palette, 4);
 		_gfx->setPalette(pal);
-		waitTime( 1 );
 		_gfx->updateScreen();
+		g_system->delayMillis(20);
 	}
 
 	_gfx->setPalette(_gfx->_palette);
diff --git a/engines/parallaction/parallaction.h b/engines/parallaction/parallaction.h
index 4a14201164..f639185580 100644
--- a/engines/parallaction/parallaction.h
+++ b/engines/parallaction/parallaction.h
@@ -259,8 +259,6 @@ public:
 
 	Input	*_input;
 
-	void		waitTime(uint32 t);
-
 	OpcodeSet	_commandOpcodes;
 
 	struct ParallactionStruct1 {
@@ -368,8 +366,6 @@ protected:		// members
 	void		initGlobals();
 	void		runGame();
 	void		updateView();
-	uint32		getElapsedTime();
-	void		resetTimer();
 
 	void		scheduleLocationSwitch(const char *location);
 	void		doLocationEnterTransition();
diff --git a/engines/parallaction/parallaction_ns.cpp b/engines/parallaction/parallaction_ns.cpp
index 81141454b6..8e0f83d46d 100644
--- a/engines/parallaction/parallaction_ns.cpp
+++ b/engines/parallaction/parallaction_ns.cpp
@@ -299,7 +299,7 @@ void Parallaction_ns::changeLocation(char *location) {
 	_gfx->setFloatingLabel(0);
 	_gfx->freeLabels();
 
-	_input->_hoverZone = nullZonePtr;
+	_input->stopHovering();
 	if (_engineFlags & kEngineBlockInput) {
 		setArrowCursor();
 	}
diff --git a/engines/saga/actor.cpp b/engines/saga/actor.cpp
index 52b921d000..96d901fbba 100644
--- a/engines/saga/actor.cpp
+++ b/engines/saga/actor.cpp
@@ -31,7 +31,6 @@
 #include "saga/events.h"
 #include "saga/isomap.h"
 #include "saga/objectmap.h"
-#include "saga/sagaresnames.h"
 #include "saga/rscfile.h"
 #include "saga/script.h"
 #include "saga/sndres.h"
@@ -997,7 +996,7 @@ void Actor::createDrawOrderList() {
 }
 
 bool Actor::getSpriteParams(CommonObjectData *commonObjectData, int &frameNumber, SpriteList *&spriteList) {
-	if (_vm->_scene->currentSceneResourceId() == RID_ITE_OVERMAP_SCENE) {
+	if (_vm->_scene->currentSceneResourceId() == ITE_SCENE_OVERMAP) {
 		if (!(commonObjectData->_flags & kProtagonist)){
 //			warning("not protagonist");
 			return false;
diff --git a/engines/saga/actor_walk.cpp b/engines/saga/actor_walk.cpp
index 0c573c0c40..d62c1c61d7 100644
--- a/engines/saga/actor_walk.cpp
+++ b/engines/saga/actor_walk.cpp
@@ -30,7 +30,6 @@
 #include "saga/events.h"
 #include "saga/isomap.h"
 #include "saga/objectmap.h"
-#include "saga/sagaresnames.h"
 #include "saga/script.h"
 #include "saga/sound.h"
 #include "saga/scene.h"
@@ -209,7 +208,7 @@ void Actor::updateActorsScene(int actorsEntrance) {
 				actor->_finalTarget = actor->_location;
 				_centerActor = _protagonist = actor;
 			} else if (_vm->getGameType() == GType_ITE &&
-					   _vm->_scene->currentSceneResourceId() == RID_ITE_OVERMAP_SCENE) {
+					   _vm->_scene->currentSceneResourceId() == ITE_SCENE_OVERMAP) {
 				continue;
 			}
 
@@ -416,7 +415,7 @@ void Actor::handleActions(int msec, bool setup) {
 					speed = 4;
 				}
 
-				if (_vm->_scene->currentSceneResourceId() == RID_ITE_OVERMAP_SCENE) {
+				if (_vm->_scene->currentSceneResourceId() == ITE_SCENE_OVERMAP) {
 					speed = 2;
 				}
 
diff --git a/engines/saga/detection.cpp b/engines/saga/detection.cpp
index b7d2a3aa39..7fd1024405 100644
--- a/engines/saga/detection.cpp
+++ b/engines/saga/detection.cpp
@@ -36,7 +36,6 @@
 #include "saga/rscfile.h"
 #include "saga/interface.h"
 #include "saga/scene.h"
-#include "saga/sagaresnames.h"
 
 namespace Saga {
 struct SAGAGameDescription {
@@ -63,10 +62,7 @@ const GameSoundInfo *SagaEngine::getSfxInfo() const { return _gameDescription->s
 const GameSoundInfo *SagaEngine::getMusicInfo() const {
 	static GameSoundInfo musicInfo;
 	musicInfo.resourceType = kSoundPCM;
-	musicInfo.frequency = 11025;
 	musicInfo.sampleBits = 16;
-	// The digital music in the ITE Mac demo version is not stereo
-	musicInfo.stereo = _gameDescription->gameType == GID_ITE_MACDEMO2 ? false : true;
 	musicInfo.isBigEndian = false;
 	musicInfo.isSigned = true;
 
diff --git a/engines/saga/detection_tables.h b/engines/saga/detection_tables.h
index 0017f34957..cbc3152f70 100644
--- a/engines/saga/detection_tables.h
+++ b/engines/saga/detection_tables.h
@@ -28,71 +28,81 @@
 namespace Saga {
 
 static const GameResourceDescription ITE_Resources = {
-	RID_ITE_SCENE_LUT,  // Scene lookup table RN
-	RID_ITE_SCRIPT_LUT, // Script lookup table RN
-	RID_ITE_MAIN_PANEL,
-	RID_ITE_CONVERSE_PANEL,
-	RID_ITE_OPTION_PANEL,
-	0,					// Warning panel (IHNM only)
-	0,					// Warning panel sprites (IHNM only)
-	RID_ITE_MAIN_SPRITES,
-	RID_ITE_MAIN_PANEL_SPRITES,
-	0,					// Option panel sprites (IHNM only)
-	RID_ITE_DEFAULT_PORTRAITS,
-	0,					// Psychic profile background (IHNM only)
-	RID_ITE_MAIN_STRINGS,
-	RID_ITE_ACTOR_NAMES
+	1806,	// Scene lookup table RN
+	216,	// Script lookup table RN
+	3,		// Main panel
+	4,		// Converse panel
+	5,		// Option panel
+	6,		// Main sprites
+	7,		// Main panel sprites
+	35,		// Main strings
+	// ITE specific resources
+	36,		// Actor names
+	125,	// Default portraits
+	// IHNM specific resources
+	0,		// Option panel sprites
+	0,		// Warning panel
+	0,		// Warning panel sprites
+	0		// Psychic profile background
 };
 
+// FIXME: Option panel should be 4 but it is an empty resource.
+// Proper fix would be to not load the options panel when the demo is running
 static const GameResourceDescription ITEDemo_Resources = {
-	RID_ITEDEMO_SCENE_LUT,  // Scene lookup table RN
-	RID_ITEDEMO_SCRIPT_LUT, // Script lookup table RN
-	RID_ITEDEMO_MAIN_PANEL,
-	RID_ITEDEMO_CONVERSE_PANEL,
-	RID_ITEDEMO_OPTION_PANEL,
-	0,						// Warning panel (IHNM only)
-	0,						// Warning panel sprites (IHNM only)
-	RID_ITEDEMO_MAIN_SPRITES,
-	RID_ITEDEMO_MAIN_PANEL_SPRITES,
-	0,						// Option panel sprites (IHNM only)
-	RID_ITEDEMO_DEFAULT_PORTRAITS,
-	0,						// Psychic profile background (IHNM only)
-	RID_ITEDEMO_MAIN_STRINGS,
-	RID_ITEDEMO_ACTOR_NAMES
+	318,	// Scene lookup table RN
+	146,	// Script lookup table RN
+	2,		// Main panel
+	3,		// Converse panel
+	3,		// Option panel
+	5,		// Main sprites
+	6,		// Main panel sprites
+	8,		// Main strings
+	// ITE specific resources
+	9,		// Actor names
+	80,		// Default portraits
+	// IHNM specific resources
+	0,		// Option panel sprites
+	0,		// Warning panel
+	0,		// Warning panel sprites
+	0		// Psychic profile background
 };
 
 static const GameResourceDescription IHNM_Resources = {
-	RID_IHNM_SCENE_LUT,  // Scene lookup table RN
-	RID_IHNM_SCRIPT_LUT, // Script lookup table RN
-	RID_IHNM_MAIN_PANEL,
-	RID_IHNM_CONVERSE_PANEL,
-	RID_IHNM_OPTION_PANEL,
-	RID_IHNM_WARNING_PANEL,
-	RID_IHNM_WARNING_PANEL_SPRITES,
-	RID_IHNM_MAIN_SPRITES,
-	RID_IHNM_MAIN_PANEL_SPRITES,
-	RID_IHNM_OPTION_PANEL_SPRITES,
-	0,					// Default portraits (ITE only)
-	RID_IHNM_PROFILE_BG,
-	RID_IHNM_MAIN_STRINGS,
-	0					// Actors strings (ITE only)
+	1272,	// Scene lookup table RN
+	29,		// Script lookup table RN
+	9,		// Main panel
+	10,		// Converse panel
+	15,		// Option panel
+	12,		// Main sprites
+	12,		// Main panel sprites
+	21,		// Main strings
+	// ITE specific resources
+	0,		// Actor names
+	0,		// Default portraits
+	// IHNM specific resources
+	16,		// Option panel sprites
+	17,		// Warning panel
+	18,		// Warning panel sprites
+	20		// Psychic profile background
 };
 
 static const GameResourceDescription IHNMDEMO_Resources = {
-	RID_IHNMDEMO_SCENE_LUT,  // Scene lookup table RN
-	RID_IHNMDEMO_SCRIPT_LUT, // Script lookup table RN
-	RID_IHNMDEMO_MAIN_PANEL,
-	RID_IHNMDEMO_CONVERSE_PANEL,
-	RID_IHNMDEMO_OPTION_PANEL,
-	RID_IHNMDEMO_WARNING_PANEL,
-	RID_IHNMDEMO_WARNING_PANEL_SPRITES,
-	RID_IHNMDEMO_MAIN_SPRITES,
-	RID_IHNMDEMO_MAIN_PANEL_SPRITES,
-	RID_IHNMDEMO_OPTION_PANEL_SPRITES,
-	0,					// Default portraits (ITE only)
-	RID_IHNMDEMO_PROFILE_BG,
-	RID_IHNMDEMO_MAIN_STRINGS,
-	0					// Actors strings (ITE only)
+	286,	// Scene lookup table RN
+	18,		// Script lookup table RN
+	5,		// Main panel
+	6,		// Converse panel
+	10,		// Option panel
+	7,		// Main sprites
+	7,		// Main panel sprites
+	16,		// Main strings
+	// ITE specific resources
+	0,		// Actor names
+	0,		// Default portraits
+	// IHNM specific resources
+	11,		// Option panel sprites
+	12,		// Warning panel
+	13,		// Warning panel sprites
+	15		// Psychic profile background
 };
 
 static const GameFontDescription ITEDEMO_GameFonts[]    = { {0}, {1} };
@@ -102,14 +112,14 @@ static const GameFontDescription IHNMDEMO_GameFonts[]   = { {2}, {3}, {4} };
 // Font 6 is kIHNMFont8, font 8 is kIHNMMainFont
 static const GameFontDescription IHNMCD_GameFonts[]     = { {2}, {3}, {4}, {5}, {6}, {7}, {8} };
 
-//                                                             frequency, sampleBits, stereo, isBigEndian, isSigned
-static const GameSoundInfo ITEPC_GameSound       = { kSoundPCM,    22050,         16,  false,       false,     true };
-static const GameSoundInfo ITEWINDEMO1_GameSound = { kSoundPCM,    22050,          8,  false,       false,    false };
-static const GameSoundInfo ITEMACCD_G_GameSound  = { kSoundMacPCM, 22050,          8,  false,       false,    false };
-static const GameSoundInfo ITEDISK_GameSound     = { kSoundVOC,       -1,         -1,  false,       false,     true };
-static const GameSoundInfo ITEDEMO_GameVoice     = { kSoundVOX,    22050,         16,  false,       false,     true };
-static const GameSoundInfo IHNM_GameSound        = { kSoundWAV,       -1,         -1,  false,       false,     true };
-static const GameSoundInfo MAC_GameSound         = { kSoundPCM,    22050,         16,  false,        true,     true };
+//                                                         sampleBits, isBigEndian, isSigned
+static const GameSoundInfo ITEPC_GameSound       = { kSoundPCM,    16,  false,     true };
+static const GameSoundInfo ITEWINDEMO1_GameSound = { kSoundPCM,     8,  false,    false };
+static const GameSoundInfo ITEMACCD_G_GameSound  = { kSoundMacPCM,  8,  false,    false };
+static const GameSoundInfo ITEDISK_GameSound     = { kSoundVOC,    -1,  false,     true };
+static const GameSoundInfo ITEDEMO_GameVoice     = { kSoundVOX,    16,  false,     true };
+static const GameSoundInfo IHNM_GameSound        = { kSoundWAV,    -1,  false,     true };
+static const GameSoundInfo MAC_GameSound         = { kSoundPCM,    16,   true,     true };
 
 // Patch files. Files not found will be ignored
 static const GamePatchDescription ITEPatch_Files[] = {
diff --git a/engines/saga/gfx.cpp b/engines/saga/gfx.cpp
index d1f592e38b..85416991db 100644
--- a/engines/saga/gfx.cpp
+++ b/engines/saga/gfx.cpp
@@ -28,7 +28,6 @@
 #include "saga/saga.h"
 #include "saga/gfx.h"
 #include "saga/interface.h"
-#include "saga/sagaresnames.h"
 #include "saga/rscfile.h"
 #include "saga/scene.h"
 
@@ -37,6 +36,9 @@
 
 namespace Saga {
 
+#define RID_IHNM_DEFAULT_PALETTE 1
+#define RID_IHNM_HOURGLASS_CURSOR 11 // not in demo
+
 Gfx::Gfx(SagaEngine *vm, OSystem *system, int width, int height) : _vm(vm), _system(system) {
 	_system->beginGFXTransaction();
 		_vm->initCommonGFX(width > 320);
diff --git a/engines/saga/interface.cpp b/engines/saga/interface.cpp
index ef31b85156..fe1ee0eefc 100644
--- a/engines/saga/interface.cpp
+++ b/engines/saga/interface.cpp
@@ -43,7 +43,6 @@
 #include "saga/sound.h"
 #include "saga/sprite.h"
 #include "saga/rscfile.h"
-#include "saga/sagaresnames.h"
 
 #include "saga/interface.h"
 
@@ -477,9 +476,9 @@ void Interface::setMode(int mode) {
 
 bool Interface::processAscii(Common::KeyState keystate) {
 	// TODO: Checking for Esc and Enter below is a bit hackish, and
-	// and probably only works with the English version. Maybe we should
-	// add a flag to the button so it can indicate if it's the default or
-	// cancel button?
+	// probably only works with the English version. Maybe we should
+	// add a flag to the button so it can indicate if it's the default
+	// or cancel button?
 	uint16 ascii = keystate.ascii;
 	int i;
 	PanelButton *panelButton;
@@ -2755,7 +2754,7 @@ void Interface::mapPanelDrawCrossHair() {
 
 	if (screen.contains(mapPosition)) {
 		_vm->_sprite->draw(backBuffer, _vm->getDisplayClip(), _vm->_sprite->_mainSprites,
-						   _mapPanelCrossHairState? RID_ITE_SPR_XHAIR1 : RID_ITE_SPR_XHAIR2,
+						   _mapPanelCrossHairState? RID_ITE_SPR_CROSSHAIR : RID_ITE_SPR_CROSSHAIR + 1,
 						   mapPosition, 256);
 	}
 }
diff --git a/engines/saga/interface.h b/engines/saga/interface.h
index af59fe64d2..74cf5ace44 100644
--- a/engines/saga/interface.h
+++ b/engines/saga/interface.h
@@ -56,6 +56,10 @@ enum InterfaceUpdateFlags {
 #define STATUS_TEXT_LEN 128
 #define STATUS_TEXT_INPUT_MAX 256
 
+#define RID_IHNM_BOSS_SCREEN 19		// not in demo
+#define RID_ITE_TYCHO_MAP 1686
+#define RID_ITE_SPR_CROSSHAIR (73 + 9)
+
 // Converse-specific stuff
 
 enum PanelModes {
diff --git a/engines/saga/ihnm_introproc.cpp b/engines/saga/introproc_ihnm.cpp
index 5f1d0157d5..5f1d0157d5 100644
--- a/engines/saga/ihnm_introproc.cpp
+++ b/engines/saga/introproc_ihnm.cpp
diff --git a/engines/saga/ite_introproc.cpp b/engines/saga/introproc_ite.cpp
index 2aa263b097..a33a55c375 100644
--- a/engines/saga/ite_introproc.cpp
+++ b/engines/saga/introproc_ite.cpp
@@ -36,7 +36,6 @@
 #include "saga/music.h"
 
 #include "saga/scene.h"
-#include "saga/sagaresnames.h"
 #include "saga/rscfile.h"
 
 namespace Saga {
@@ -46,6 +45,21 @@ using Common::EN_ANY;
 using Common::DE_DEU;
 using Common::IT_ITA;
 
+// Intro scenes
+#define RID_ITE_INTRO_ANIM_SCENE 1538
+#define RID_ITE_CAVE_SCENE_1 1542
+#define RID_ITE_CAVE_SCENE_2 1545
+#define RID_ITE_CAVE_SCENE_3 1548
+#define RID_ITE_CAVE_SCENE_4 1551
+#define RID_ITE_VALLEY_SCENE 1556
+#define RID_ITE_TREEHOUSE_SCENE 1560
+#define RID_ITE_FAIREPATH_SCENE 1564
+#define RID_ITE_FAIRETENT_SCENE 1567
+
+// ITE intro music
+#define MUSIC_1 9
+#define MUSIC_2 10
+
 LoadSceneParams ITE_IntroList[] = {
 	{RID_ITE_INTRO_ANIM_SCENE, kLoadByResourceId, NULL, Scene::SC_ITEIntroAnimProc, false, kTransitionNoFade, 0, NO_CHAPTER_CHANGE},
 	{RID_ITE_CAVE_SCENE_1, kLoadByResourceId, NULL, Scene::SC_ITEIntroCave1Proc, false, kTransitionFade, 0, NO_CHAPTER_CHANGE},
@@ -380,63 +394,65 @@ int Scene::ITEIntroCave1Proc(int param) {
 
 	static const IntroDialogue dialogue[][4] = {
 		{ { // English
-			RID_CAVE_VOICE_0,
+			0,		// cave voice 0
 			"We see the sky, we see the land, we see the water, "
 			"and we wonder: Are we the only ones?"
 		},
 		{
-			RID_CAVE_VOICE_1,
+			1,		// cave voice 1
 			"Long before we came to exist, the humans ruled the "
 			"Earth."
 		},
 		{
-			RID_CAVE_VOICE_2,
+			2,		// cave voice 2
 			"They made marvelous things, and moved whole "
 			"mountains."
 		},
 		{
-			RID_CAVE_VOICE_3,
+			3,		// cave voice 3
 			"They knew the Secret of Flight, the Secret of "
 			"Happiness, and other secrets beyond our imagining."
 		} },
+		// -----------------------------------------------------
 		{ { // German
-			RID_CAVE_VOICE_0,
+			0,		// cave voice 0
 			"Um uns sind der Himmel, das Land und die Seen; und "
 			"wir fragen uns - sind wir die einzigen?"
 		},
 		{
-			RID_CAVE_VOICE_1,
+			1,		// cave voice 1
 			"Lange vor unserer Zeit herrschten die Menschen "
 			"\201ber die Erde."
 		},
 		{
-			RID_CAVE_VOICE_2,
+			2,		// cave voice 2
 			"Sie taten wundersame Dinge und versetzten ganze "
 			"Berge."
 		},
 		{
-			RID_CAVE_VOICE_3,
+			3,		// cave voice 3
 			"Sie kannten das Geheimnis des Fluges, das Geheimnis "
 			"der Fr\224hlichkeit und andere Geheimnisse, die "
 			"unsere Vorstellungskraft \201bersteigen."
 		} },
+		// -----------------------------------------------------
 		{ { // Italian fan translation
-			RID_CAVE_VOICE_0,
+			0,		// cave voice 0
 			"Guardiamo il cielo, guardiamo la terra, guardiamo "
 			"l'acqua, e ci chiediamo: Siamo forse soli?"
 		},
 		{
-			RID_CAVE_VOICE_1,
+			1,		// cave voice 1
 			"Molto tempo prima che noi esistessimo, gli Umani "
 			"dominavano la terra."
 		},
 		{
-			RID_CAVE_VOICE_2,
+			2,		// cave voice 2
 			"Fecero cose meravigliose, e mossero intere "
 			"montagne."
 		},
 		{
-			RID_CAVE_VOICE_3,
+			3,		// cave voice 3
 			"Conoscevano il Segreto del Volo, il Segreto della "
 			"Felicit\224, ed altri segreti oltre ogni nostra "
 			"immaginazione."
@@ -493,47 +509,49 @@ int Scene::ITEIntroCave2Proc(int param) {
 
 	static const IntroDialogue dialogue[][3] = {
 		{ { // English
-			RID_CAVE_VOICE_4,
+			4,		// cave voice 4
 			"The humans also knew the Secret of Life, and they "
 			"used it to give us the Four Great Gifts:"
 		},
 		{
-			RID_CAVE_VOICE_5,
+			5,		// cave voice 5
 			"Thinking minds, feeling hearts, speaking mouths, and "
 			"reaching hands."
 		},
 		{
-			RID_CAVE_VOICE_6,
+			6,		// cave voice 6
 			"We are their children."
 		} },
+		// -----------------------------------------------------
 		{ { // German
-			RID_CAVE_VOICE_4,
+			4,		// cave voice 4
 			"Au$erdem kannten die Menschen das Geheimnis des "
 			"Lebens. Und sie nutzten es, um uns die vier gro$en "
 			"Geschenke zu geben -"
 		},
 		{
-			RID_CAVE_VOICE_5,
+			5,		// cave voice 5
 			"den denkenden Geist, das f\201hlende Herz, den "
 			"sprechenden Mund und die greifende Hand."
 		},
 		{
-			RID_CAVE_VOICE_6,
+			6,		// cave voice 6
 			"Wir sind ihre Kinder."
 		} },
+		// -----------------------------------------------------
 		{ { // Italian fan translation
-			RID_CAVE_VOICE_4,
+			4,		// cave voice 4
 			"Gli Umani conoscevano anche il Segreto della Vita, "
 			"e lo usarono per darci i Quattro Grandi Doni:"
 
 		},
 		{
-			RID_CAVE_VOICE_5,
+			5,		// cave voice 5
 			"Il pensiero, le emozioni, la parola e la manualit\224."
 
 		},
 		{
-			RID_CAVE_VOICE_6,
+			6,		// cave voice 6
 			"Siamo i loro figli."
 		} }
 	};
@@ -595,46 +613,48 @@ int Scene::ITEIntroCave3Proc(int param) {
 
 	static const IntroDialogue dialogue[][3] = {
 		{ { // English
-			RID_CAVE_VOICE_7,
+			7,		// cave voice 7
 			"They taught us how to use our hands, and how to "
 			"speak."
 		},
 		{
-			RID_CAVE_VOICE_8,
+			8,		// cave voice 8
 			"They showed us the joy of using our minds."
 		},
 		{
-			RID_CAVE_VOICE_9,
+			9,		// cave voice 9
 			"They loved us, and when we were ready, they surely "
 			"would have given us the Secret of Happiness."
 		} },
+		// -----------------------------------------------------
 		{ { // German
-			RID_CAVE_VOICE_7,
+			7,		// cave voice 7
 			"Sie lehrten uns zu sprechen und unsere H\204nde zu "
 			"benutzen."
 		},
 		{
-			RID_CAVE_VOICE_8,
+			8,		// cave voice 8
 			"Sie zeigten uns die Freude am Denken."
 		},
 		{
-			RID_CAVE_VOICE_9,
+			9,		// cave voice 9
 			"Sie liebten uns, und w\204ren wir bereit gewesen, "
 			"h\204tten sie uns sicherlich das Geheimnis der "
 			"Fr\224hlichkeit offenbart."
 		} },
+		// -----------------------------------------------------
 		{ { // Italian fan translation
-			RID_CAVE_VOICE_7,
+			7,		// cave voice 7
 			"Ci insegnarono come usare le mani e come parlare. "
 
 		},
 		{
-			RID_CAVE_VOICE_8,
+			8,		// cave voice 8
 			"Ci mostrarono le gioie che l'uso della mente "
 			"pu\242 dare. "
 		},
 		{
-			RID_CAVE_VOICE_9,
+			9,		// cave voice 9
 			"Ci amarono, ed una volta pronti, ci avrebbero "
 			"sicuramente svelato il Segreto della Felicit\224."
 
@@ -698,60 +718,62 @@ int Scene::ITEIntroCave4Proc(int param) {
 
 	static const IntroDialogue dialogue[][4] = {
 		{ { // English
-			RID_CAVE_VOICE_10,
+			10,		// cave voice 10
 			"And now we see the sky, the land, and the water that "
 			"we are heirs to, and we wonder: why did they leave?"
 		},
 		{
-			RID_CAVE_VOICE_11,
+			11,		// cave voice 11
 			"Do they live still, in the stars? In the oceans "
 			"depths? In the wind?"
 		},
 		{
-			RID_CAVE_VOICE_12,
+			12,		// cave voice 12
 			"We wonder, was their fate good or evil?"
 		},
 		{
-			RID_CAVE_VOICE_13,
+			13,		// cave voice 13
 			"And will we also share the same fate one day?"
 		} },
+		// -----------------------------------------------------
 		{ { // German
-			RID_CAVE_VOICE_10,
+			10,		// cave voice 10
 			"Und nun sehen wir den Himmel, das Land und die "
 			"Seen - unser Erbe. Und wir fragen uns - warum "
 			"verschwanden sie?"
 		},
 		{
-			RID_CAVE_VOICE_11,
+			11,		// cave voice 11
 			"Leben sie noch in den Sternen? In den Tiefen des "
 			"Ozeans? Im Wind?"
 		},
 		{
-			RID_CAVE_VOICE_12,
+			12,		// cave voice 12
 			"Wir fragen uns - war ihr Schicksal gut oder b\224se?"
 		},
 		{
-			RID_CAVE_VOICE_13,
+			13,		// cave voice 13
 			"Und wird uns eines Tages das gleiche Schicksal "
 			"ereilen?"
 		} },
+		// -----------------------------------------------------
 		{ { // Italian fan translation
-			RID_CAVE_VOICE_10,
+			10,		// cave voice 10
 			"Ed ora che guardiamo il cielo, la terra e l'acqua "
 			"che abbiamo ereditato, pensiamo: Perch\233 partirono?"
 
 		},
 		{
-			RID_CAVE_VOICE_11,
+			11,		// cave voice 11
 			"Vivono ancora, nelle stelle? Nelle profondit\224 "
 			"dell'oceano? Nel vento?"
 		},
 		{
-			RID_CAVE_VOICE_12,
+			12,		// cave voice 12
 			"Ci domandiamo, il loro destino fu felice o nefasto?"
 		},
 		{
-			RID_CAVE_VOICE_13,
+			13,		// cave voice 13
 			"E un giorno, condivideremo anche noi lo stesso "
 			"destino?"
 		} }
diff --git a/engines/saga/isomap.cpp b/engines/saga/isomap.cpp
index 7a6d6a4398..e607adb4cb 100644
--- a/engines/saga/isomap.cpp
+++ b/engines/saga/isomap.cpp
@@ -27,7 +27,6 @@
 
 #include "saga/saga.h"
 #include "saga/gfx.h"
-#include "saga/sagaresnames.h"
 #include "saga/scene.h"
 #include "saga/isomap.h"
 
@@ -285,7 +284,7 @@ void IsoMap::adjustScroll(bool jump) {
 
 	tileCoordsToScreenPoint(_vm->_actor->_centerActor->_location, playerPoint);
 
-	if (_vm->_scene->currentSceneResourceId() == RID_ITE_OVERMAP_SCENE) {
+	if (_vm->_scene->currentSceneResourceId() == ITE_SCENE_OVERMAP) {
 		_mapPosition.x = (playerPoint.x + _viewScroll.x) * 30 / 100 - (381);
 		_mapPosition.y = (playerPoint.y + _viewScroll.y) * 30 / 100 - (342);
 	}
@@ -322,7 +321,7 @@ void IsoMap::adjustScroll(bool jump) {
 		_viewScroll.x = smoothSlide( _viewScroll.x, minScrollPos.x, maxScrollPos.x );
 	}
 
-	if (_vm->_scene->currentSceneResourceId() == RID_ITE_OVERMAP_SCENE) {
+	if (_vm->_scene->currentSceneResourceId() == ITE_SCENE_OVERMAP) {
 		ObjectData *obj;
 		uint16 objectId;
 		objectId = _vm->_actor->objIndexToId(ITE_OBJ_MAP);
@@ -1510,7 +1509,7 @@ void IsoMap::findTilePath(ActorData* actor, const Location &start, const Locatio
 	memset( &_searchArray, 0, sizeof(_searchArray));
 
 	if (!(actor->_actorFlags & kActorNoCollide) &&
-		(_vm->_scene->currentSceneResourceId() != RID_ITE_OVERMAP_SCENE)) {
+		(_vm->_scene->currentSceneResourceId() != ITE_SCENE_OVERMAP)) {
 			for (i = 0; i < _vm->_actor->_actorsCount; i++) {
 				other = _vm->_actor->_actors[i];
 				if (!other->_inScene) continue;
@@ -1664,7 +1663,7 @@ void IsoMap::screenPointToTileCoords(const Point &position, Location &location)
 	Point mPos(position);
 	int x,y;
 
-	if (_vm->_scene->currentSceneResourceId() == RID_ITE_OVERMAP_SCENE){
+	if (_vm->_scene->currentSceneResourceId() == ITE_SCENE_OVERMAP){
 		if (mPos.y < 16) {
 			mPos.y = 16;
 		}
diff --git a/engines/saga/isomap.h b/engines/saga/isomap.h
index c79ae7cd0a..eb548ce5dc 100644
--- a/engines/saga/isomap.h
+++ b/engines/saga/isomap.h
@@ -32,6 +32,8 @@
 
 namespace Saga {
 
+#define ITE_OBJ_MAP 14
+
 #define SAGA_ISOTILEDATA_LEN 8
 #define SAGA_ISOTILE_WIDTH 32
 #define SAGA_ISOTILE_BASEHEIGHT 15
diff --git a/engines/saga/itedata.cpp b/engines/saga/itedata.cpp
index 1274f72b45..43c3d21012 100644
--- a/engines/saga/itedata.cpp
+++ b/engines/saga/itedata.cpp
@@ -26,7 +26,6 @@
 // Actor and Object data tables
 #include "saga/saga.h"
 #include "saga/itedata.h"
-#include "saga/sagaresnames.h"
 #include "saga/sndres.h"
 
 namespace Saga {
@@ -245,7 +244,7 @@ ObjectTableData ITE_ObjectTable[ITE_OBJECTCOUNT] = {
 	{ 23,   0,  480,  480,  0, 24, 23, 0           }, // Silver Medallion
 	{ 24,   0,  480,  480,  0, 25, 24, 0           }, // Mud in Fur
 	{ 25,   0,  480,  480,  0, 26, 25, 0           }, // Gold Ring
-	{ 27,  13, 1036,  572,  40, 47, 14, kObjUseWith }, // Screwdriver
+	{ 27,  13, 1036,  572, 40, 47, 14, kObjUseWith }, // Screwdriver
 	{ 28,   0,  480,  480,  0, 29, 26, 0           }, // Apple Token
 	{ 29,   0,  480,  480,  0, 30, 22, kObjUseWith }, // Letter from Elara
 	{ 30,   0,  164,  440,  0, 31, 16, kObjUseWith }, // Spoon
@@ -258,82 +257,86 @@ ObjectTableData ITE_ObjectTable[ITE_OBJECTCOUNT] = {
 	{ 40, 269,  644,  416,  0, 41, 39, kObjNotFlat }, // Electrical Cable
 	{ 41,  12,  280,  516,  0, 43, 17, kObjUseWith }, // Piece of flint
 	{ 42,   5,  876,  332, 32, 65, 18, 0           }, // Rat Cloak
-	{ 43,  52,  556, 1612,  0, 49, 28, kObjUseWith | kObjNotFlat }, // Bucket
+	{ 43,  52,  556, 1612,  0, 49, 28, kObjUseWith | 
+									   kObjNotFlat }, // Bucket
 	{ 48,  52,  732,  948,  0, 50, 27, kObjUseWith }, // Cup
 	{ 49,  52,  520, 1872,  0, 53, 29, 0           }, // Fertilizer
 	{ 50,  52, 1012, 1268,  0, 52, 30, 0           }, // Feeder
-	{ 51, 252,  -20,  -20,  0, 71, 32, kObjUseWith | kObjNotFlat }, // Bowl in jail cell
+	{ 51, 252,  -20,  -20,  0, 71, 32, kObjUseWith |
+									   kObjNotFlat }, // Bowl in jail cell
 	{ 53, 252, 1148,  388,  0, 70, 33, 0           }, // Loose stone block in jail cell
 	{ 26,  12,  496,  368,  0, 76, 31, 0           }, // Coil of Rope from Quarry
 	{ 54, 281,  620,  352,  0, 80, 46, 0           }  // Orb of Storms in Dam Lab
 };
 
 FxTable ITE_SfxTable[ITE_SFXCOUNT] = {
-	{ FX_DOOR_OPEN,    127 },
-	{ FX_DOOR_CLOSE,   127 },
-	{ FX_RUSH_WATER,    63 }, // Floppy volume: 127
-	{ FX_RUSH_WATER,    26 }, // Floppy volume: 40
-	{ FX_CRICKET,       64 },
-	{ FX_PORTICULLIS,   84 }, // Floppy volume: 127
-	{ FX_CLOCK_1,       64 },
-	{ FX_CLOCK_2,       64 },
-	{ FX_DAM_MACHINE,   64 },
-	{ FX_DAM_MACHINE,   40 },
-	{ FX_HUM1,          64 },
-	{ FX_HUM2,          64 },
-	{ FX_HUM3,          64 },
-	{ FX_HUM4,          64 },
-	{ FX_WATER_LOOP_S,  32 }, // Floppy volume: 64
-	{ FX_SURF,          42 }, // Floppy volume: 127
-	{ FX_SURF,          32 }, // Floppy volume: 64
-	{ FX_FIRELOOP,      64 }, // Floppy volume: 96
-	{ FX_SCRAPING,      84 }, // Floppy volume: 127
-	{ FX_BEE_SWARM,     64 }, // Floppy volume: 96
-	{ FX_BEE_SWARM,     26 }, // Floppy volume: 40
-	{ FX_SQUEAKBOARD,   64 },
-	{ FX_KNOCK,        127 },
-	{ FX_COINS,         32 }, // Floppy volume: 48
-	{ FX_STORM,         84 }, // Floppy volume: 127
-	{ FX_DOOR_CLOSE_2,  84 }, // Floppy volume: 127
-	{ FX_ARCWELD,       84 }, // Floppy volume: 127
-	{ FX_RETRACT_ORB,  127 },
-	{ FX_DRAGON,       127 },
-	{ FX_SNORES,       127 },
-	{ FX_SPLASH,       127 },
-	{ FX_LOBBY_DOOR,   127 },
-	{ FX_CHIRP_LOOP,    26 }, // Floppy volume: 40
-	{ FX_DOOR_CREAK,    96 },
-	{ FX_SPOON_DIG,     64 },
-	{ FX_CROW,          96 },
-	{ FX_COLDWIND,      42 }, // Floppy volume: 64
-	{ FX_TOOL_SND_1,    96 },
-	{ FX_TOOL_SND_2,   127 },
-	{ FX_TOOL_SND_3,    64 },
-	{ FX_DOOR_METAL,    96 },
-	{ FX_WATER_LOOP_S,  32 },
-	{ FX_WATER_LOOP_L,  32 }, // Floppy volume: 64
-	{ FX_DOOR_OPEN_2,  127 },
-	{ FX_JAIL_DOOR,     64 },
-	{ FX_KILN_FIRE,     53 }, // Floppy volume: 80
-
-	// Only in the CD version
-	{ FX_CROWD_01,      64 },
-	{ FX_CROWD_02,      64 },
-	{ FX_CROWD_03,      64 },
-	{ FX_CROWD_04,      64 },
-	{ FX_CROWD_05,      64 },
-	{ FX_CROWD_06,      64 },
-	{ FX_CROWD_07,      64 },
-	{ FX_CROWD_08,      64 },
-	{ FX_CROWD_09,      64 },
-	{ FX_CROWD_10,      64 },
-	{ FX_CROWD_11,      64 },
-	{ FX_CROWD_12,      64 },
-	{ FX_CROWD_13,      64 },
-	{ FX_CROWD_14,      64 },
-	{ FX_CROWD_15,      64 },
-	{ FX_CROWD_16,      64 },
-	{ FX_CROWD_17,      64 }
+	{ 14,	127 },	// Door open
+	{ 15,   127 },	// Door close
+	{ 16,    63 },	// Rush water (floppy volume: 127)
+	{ 16,    26 },	// Rush water (floppy volume: 40)
+	{ 17,    64 },	// Cricket
+	{ 18,    84 },	// Porticullis (floppy volume: 127)
+	{ 19,    64 },	// Clock 1
+	{ 20,    64 },	// Clock 2
+	{ 21,    64 },	// Dam machine
+	{ 21,    40 },	// Dam machine
+	{ 22,    64 },	// Hum 1
+	{ 23,    64 },	// Hum 2
+	{ 24,    64 },	// Hum 3
+	{ 25,    64 },	// Hum 4
+	// Note: the following effect was set to 51 for
+	// some unknown reason
+	{ 26,	 32 },	// Stream
+	{ 27,    42 },	// Surf (floppy volume: 127)
+	{ 27,    32 },	// Surf (floppy volume: 64)
+	{ 28,    64 },	// Fire loop (floppy volume: 96)
+	{ 29,    84 },	// Scraping (floppy volume: 127)
+	{ 30,    64 },	// Bee swarm (floppy volume: 96)
+	{ 30,    26 },	// Bee swarm (floppy volume: 40)
+	{ 31,    64 },	// Squeaky board
+	{ 32,   127 },	// Knock
+	{ 33,    32 },	// Coins (floppy volume: 48)
+	{ 34,    84 },	// Storm (floppy volume: 127)
+	{ 35,	 84 },	// Door close 2 (floppy volume: 127)
+	{ 36,    84 },  // Arcweld (floppy volume: 127)
+	{ 37,	127 },	// Retract orb
+	{ 38,   127 },	// Dragon
+	{ 39,   127 },	// Snores
+	{ 40,   127 },	// Splash
+	{ 41,   127 },	// Lobby door
+	{ 42,    26 },	// Chirp loop (floppy volume: 40)
+	{ 43,    96 },	// Door creak
+	{ 44,    64 },	// Spoon dig
+	{ 45,    96 },	// Crow
+	{ 46,    42 },	// Cold wind (floppy volume: 64)
+	{ 47,    96 },	// Tool sound 1
+	{ 48,   127 },	// Tool sound 2
+	{ 49,    64 },	// Tool sound 3
+	{ 50,    96 },	// Metal door
+	{ 51,	 32 },	// Water loop S
+	{ 52,	 32 },	// Water loop L (floppy volume: 64)
+	{ 53,	127 },	// Door open 2
+	{ 54,	 64 },	// Jail door
+	{ 55,	 53 },	// Killing fire (floppy volume: 80)
+  //{ 56,	  0 },	// Dummy FX
+	// Crowd effects, which exist only in the CD version
+	{ 57,	 64 },
+	{ 58,    64 },
+	{ 59,    64 },
+	{ 60,    64 },
+	{ 61,    64 },
+	{ 62,    64 },
+	{ 63,    64 },
+	{ 64,    64 },
+	{ 65,    64 },
+	{ 66,    64 },
+	{ 67,    64 },
+	{ 68,    64 },
+	{ 69,    64 },
+	{ 70,    64 },
+	{ 71,    64 },
+	{ 72,    64 },
+	{ 73,    64 }
 };
 
 const char *ITEinterfaceTextStrings[][52] = {
@@ -493,14 +496,6 @@ const char *solicitStr[][NUM_SOLICIT_REPLIES] = {
 	}
 };
 
-const char portraitList[] = {
-	RID_ITE_JFERRET_SERIOUS,
-	RID_ITE_JFERRET_GOOFY,
-	RID_ITE_JFERRET_SERIOUS,
-	RID_ITE_JFERRET_GOOFY,
-	RID_ITE_JFERRET_ALOOF
-};
-
 const char *sakkaStr[][NUM_SAKKA] = {
 	{ "Hey, you're not supposed to help the applicants!",
 	"Guys! This is supposed to be a test!",
diff --git a/engines/saga/module.mk b/engines/saga/module.mk
index 76783a17ae..b1929361a2 100644
--- a/engines/saga/module.mk
+++ b/engines/saga/module.mk
@@ -11,11 +11,11 @@ MODULE_OBJS := \
 	font.o \
 	font_map.o \
 	gfx.o \
-	ihnm_introproc.o \
 	image.o \
 	interface.o \
+	introproc_ihnm.o \
+	introproc_ite.o \
 	isomap.o \
-	ite_introproc.o \
 	itedata.o \
 	objectmap.o \
 	puzzle.o \
diff --git a/engines/saga/music.cpp b/engines/saga/music.cpp
index 1cbc38dfb5..732bd0b50c 100644
--- a/engines/saga/music.cpp
+++ b/engines/saga/music.cpp
@@ -28,7 +28,6 @@
 #include "saga/saga.h"
 
 #include "saga/rscfile.h"
-#include "saga/sagaresnames.h"
 #include "saga/music.h"
 
 #include "sound/audiostream.h"
@@ -40,6 +39,7 @@
 namespace Saga {
 
 #define BUFFER_SIZE 4096
+#define MUSIC_SUNSPOT 26
 
 class DigitalMusicInputStream : public Audio::AudioStream {
 private:
@@ -58,6 +58,7 @@ private:
 	const int16 *_pos;
 	const GameSoundInfo *_musicInfo;
 	MemoryReadStream *_memoryStream;
+	SagaEngine *_vm;
 
 	void refill();
 	bool eosIntern() const {
@@ -73,18 +74,21 @@ public:
 	int readBuffer(int16 *buffer, const int numSamples);
 
 	bool endOfData() const	{ return eosIntern(); }
-	bool isStereo() const	{ return _musicInfo->stereo; }
-	int getRate() const	{ return _musicInfo->frequency; }
+	bool isStereo() const	{
+		// The digital music in the ITE Mac demo version is not stereo
+		return _vm->getGameId() == GID_ITE_MACDEMO2 ? false : true;
+	}
+	int getRate() const	{ return 11025; }
 };
 
 DigitalMusicInputStream::DigitalMusicInputStream(SagaEngine *vm, ResourceContext *context, uint32 resourceId, bool looping, uint32 loopStart)
-	: _context(context), _finished(false), _looping(looping), _bufferEnd(_buf + BUFFER_SIZE) {
+	: _vm(vm), _context(context), _finished(false), _looping(looping), _bufferEnd(_buf + BUFFER_SIZE) {
 
 	byte compressedHeader[10];
 
-	resourceData = vm->_resource->getResourceData(context, resourceId);
+	resourceData = _vm->_resource->getResourceData(context, resourceId);
 	_file = context->getFile(resourceData);
-	_musicInfo = vm->getMusicInfo();
+	_musicInfo = _vm->getMusicInfo();
 
 	if (_musicInfo == NULL) {
 		error("DigitalMusicInputStream() wrong musicInfo");
@@ -480,7 +484,7 @@ void Music::play(uint32 resourceId, MusicFlags flags) {
 			if (_digitalMusicContext != NULL) {
 				//TODO: check resource size
 				loopStart = 0;
-				// fix ITE sunstatm score
+				// fix ITE sunstatm/sunspot score
 				if ((_vm->getGameType() == GType_ITE) && (resourceId == MUSIC_SUNSPOT)) {
 					loopStart = 4 * 18727;
 				}
@@ -557,7 +561,7 @@ void Music::play(uint32 resourceId, MusicFlags flags) {
 		musicFile.read(resourceData, resourceSize);
 		musicFile.close();
 
-		// TODO: The Mac music format is unknown (probably TFMX?)
+		// TODO: The Mac music format is unsupported (QuickTime MIDI)
 		// so stop here
 		return;
 	} else {
diff --git a/engines/saga/palanim.cpp b/engines/saga/palanim.cpp
index c5129fcf06..319946f2d5 100644
--- a/engines/saga/palanim.cpp
+++ b/engines/saga/palanim.cpp
@@ -66,12 +66,7 @@ int PalAnim::loadPalAnim(const byte *resdata, size_t resdata_len) {
 
 	debug(3, "PalAnim::loadPalAnim(): Loading %d PALANIM entries.", _entryCount);
 
-	test_p = calloc(_entryCount, sizeof(PalanimEntry));
-	if (test_p == NULL) {
-		warning("PalAnim::loadPalAnim(): Allocation failure");
-		return MEM;
-	}
-
+	test_p = malloc(_entryCount * sizeof(PalanimEntry));
 	_entries = (PalanimEntry *)test_p;
 
 	for (i = 0; i < _entryCount; i++) {
@@ -87,22 +82,12 @@ int PalAnim::loadPalAnim(const byte *resdata, size_t resdata_len) {
 
 		debug(2, "PalAnim::loadPalAnim(): Entry %d: Loading %d palette indices.\n", i, pal_count);
 
-		test_p = calloc(1, sizeof(char) * pal_count);
-		if (test_p == NULL) {
-			warning("PalAnim::loadPalAnim(): Allocation failure");
-			return MEM;
-		}
-
+		test_p = malloc(sizeof(char) * pal_count);
 		_entries[i].pal_index = (byte *)test_p;
 
 		debug(2, "PalAnim::loadPalAnim(): Entry %d: Loading %d SAGA_COLOR structures.", i, color_count);
 
-		test_p = calloc(1, sizeof(Color) * color_count);
-		if (test_p == NULL) {
-			warning("PalAnim::loadPalAnim(): Allocation failure");
-			return MEM;
-		}
-
+		test_p = malloc(sizeof(Color) * color_count);
 		_entries[i].colors = (Color *)test_p;
 
 		for (p = 0; p < pal_count; p++) {
diff --git a/engines/saga/puzzle.cpp b/engines/saga/puzzle.cpp
index 23eaa42531..2835775320 100644
--- a/engines/saga/puzzle.cpp
+++ b/engines/saga/puzzle.cpp
@@ -31,13 +31,14 @@
 #include "saga/sprite.h"
 #include "saga/puzzle.h"
 #include "saga/render.h"
-#include "saga/sagaresnames.h"
 
 #include "common/system.h"
 #include "common/timer.h"
 
 namespace Saga {
 
+#define ITE_ACTOR_PUZZLE 176
+
 #define PUZZLE_X_OFFSET		72
 #define PUZZLE_Y_OFFSET		46
 
@@ -45,6 +46,21 @@ namespace Saga {
 #define PUZZLE_MOVED		0x04   // 1 when somewhere in the box
 #define PUZZLE_ALL_SET		PUZZLE_FIT | PUZZLE_MOVED
 
+// Puzzle portraits
+#define RID_ITE_SAKKA_APPRAISING	6
+#define RID_ITE_SAKKA_DENIAL		7
+#define RID_ITE_SAKKA_EXCITED		8
+#define RID_ITE_JFERRET_SERIOUS		9
+#define RID_ITE_JFERRET_GOOFY		10
+#define RID_ITE_JFERRET_ALOOF		11
+
+const char portraitList[] = {
+	RID_ITE_JFERRET_SERIOUS,
+	RID_ITE_JFERRET_GOOFY,
+	RID_ITE_JFERRET_SERIOUS,
+	RID_ITE_JFERRET_GOOFY,
+	RID_ITE_JFERRET_ALOOF
+};
 
 enum rifOptions {
 	kROLater = 0,
@@ -54,7 +70,12 @@ enum rifOptions {
 };
 
 Puzzle::Puzzle(SagaEngine *vm) : _vm(vm), _solved(false), _active(false) {
-	_lang = (_vm->getLanguage() == Common::DE_DEU) ? 1 : 0;
+	_lang = 0;
+
+	if (_vm->getLanguage() == Common::DE_DEU)
+		_lang = 1;
+	else if (_vm->getLanguage() == Common::IT_ITA)
+		_lang = 2;
 
 	_hintRqState = kRQNoHint;
 	_hintOffer = 0;
diff --git a/engines/saga/rscfile.cpp b/engines/saga/rscfile.cpp
index bd5bfdfa1d..b7d4f4f1bd 100644
--- a/engines/saga/rscfile.cpp
+++ b/engines/saga/rscfile.cpp
@@ -658,12 +658,8 @@ static int metaResourceTable[] = { 0, 326, 517, 677, 805, 968, 1165, 0, 1271 };
 static int metaResourceTableDemo[] = { 0, 0, 0, 0, 0, 0, 0, 285, 0 };
 
 void Resource::loadGlobalResources(int chapter, int actorsEntrance) {
-	if (chapter < 0) {
-		if (_vm->getGameId() != GID_IHNM_DEMO)
-			chapter = 8;
-		else
-			chapter = 7;
-	}
+	if (chapter < 0)
+		chapter = (_vm->getGameId() != GID_IHNM_DEMO) ? 8 : 7;
 
 	// TODO
 	//if (module.voiceLUT)
diff --git a/engines/saga/saga.cpp b/engines/saga/saga.cpp
index 8200526ecf..40eb32b276 100644
--- a/engines/saga/saga.cpp
+++ b/engines/saga/saga.cpp
@@ -53,7 +53,6 @@
 #include "saga/music.h"
 #include "saga/palanim.h"
 #include "saga/objectmap.h"
-#include "saga/sagaresnames.h"
 
 namespace Saga {
 
@@ -251,7 +250,7 @@ int SagaEngine::go() {
 		_scene->changeScene(ConfMan.getInt("start_scene"), 0, kTransitionNoFade);
 	} else if (ConfMan.hasKey("boot_param")) {
 		if (getGameType() == GType_ITE)
-			_interface->addToInventory(_actor->objIndexToId(ITE_OBJ_MAGIC_HAT));
+			_interface->addToInventory(_actor->objIndexToId(0));	// Magic hat
 		_scene->changeScene(ConfMan.getInt("boot_param"), 0, kTransitionNoFade);
 	} else if (ConfMan.hasKey("save_slot")) {
 		// First scene sets up palette
@@ -421,25 +420,25 @@ const char *SagaEngine::getTextString(int textStringId) {
 void SagaEngine::getExcuseInfo(int verb, const char *&textString, int &soundResourceId) {
 	textString = NULL;
 
-	if (verb == _script->getVerbType(kVerbPickUp)) {
-		textString = getTextString(kTextICantPickup);
-		soundResourceId = RID_BOAR_VOICE_007;
-	} else
-		if (verb == _script->getVerbType(kVerbLookAt)) {
-		textString = getTextString(kTextNothingSpecial);
-		soundResourceId = RID_BOAR_VOICE_006;
-		}
-		if (verb == _script->getVerbType(kVerbOpen)) {
+	if (verb == _script->getVerbType(kVerbOpen)) {
 		textString = getTextString(kTextNoPlaceToOpen);
-		soundResourceId = RID_BOAR_VOICE_000;
-		}
-		if (verb == _script->getVerbType(kVerbClose)) {
+		soundResourceId = 239;		// Boar voice 0
+	}
+	if (verb == _script->getVerbType(kVerbClose)) {
 		textString = getTextString(kTextNoOpening);
-		soundResourceId = RID_BOAR_VOICE_002;
-		}
-		if (verb == _script->getVerbType(kVerbUse)) {
+		soundResourceId = 241;		// Boar voice 2
+	}
+	if (verb == _script->getVerbType(kVerbUse)) {
 		textString = getTextString(kTextDontKnow);
-		soundResourceId = RID_BOAR_VOICE_005;
+		soundResourceId = 244;		// Boar voice 5
+	}
+	if (verb == _script->getVerbType(kVerbLookAt)) {
+		textString = getTextString(kTextNothingSpecial);
+		soundResourceId = 245;		// Boar voice 6
+	}
+	if (verb == _script->getVerbType(kVerbPickUp)) {
+		textString = getTextString(kTextICantPickup);
+		soundResourceId = 246;		// Boar voice 7
 	}
 }
 
diff --git a/engines/saga/saga.h b/engines/saga/saga.h
index 35c3736b31..4fd789cb4e 100644
--- a/engines/saga/saga.h
+++ b/engines/saga/saga.h
@@ -82,11 +82,11 @@ using Common::MemoryReadStreamEndian;
 #define OBJECT_TYPE_MASK ((1 << OBJECT_TYPE_SHIFT) - 1)
 
 #define OBJ_SPRITE_BASE 9
+#define IHNM_OBJ_PROFILE 0x4000
 
 #define memoryError(Place) error("%s Memory allocation error.", Place)
 
 enum ERRORCODE {
-	MEM = -2,//todo: remove
 	FAILURE = -1,
 	SUCCESS = 0
 };
@@ -303,15 +303,17 @@ struct GameResourceDescription {
 	uint32 mainPanelResourceId;
 	uint32 conversePanelResourceId;
 	uint32 optionPanelResourceId;
-	uint32 warningPanelResourceId;
-	uint32 warningPanelSpritesResourceId;
 	uint32 mainSpritesResourceId;
 	uint32 mainPanelSpritesResourceId;
-	uint32 optionPanelSpritesResourceId;
-	uint32 defaultPortraitsResourceId;
-	uint32 psychicProfileResourceId;
 	uint32 mainStringsResourceId;
+	// ITE specific resources
 	uint32 actorsStringsResourceId;
+	uint32 defaultPortraitsResourceId;
+	// IHNM specific resources
+	uint32 optionPanelSpritesResourceId;
+	uint32 warningPanelResourceId;
+	uint32 warningPanelSpritesResourceId;
+	uint32 psychicProfileResourceId;
 };
 
 struct GameFontDescription {
@@ -322,9 +324,7 @@ struct GameDisplayInfo;
 
 struct GameSoundInfo {
 	GameSoundTypes resourceType;
-	long frequency;
 	int sampleBits;
-	bool stereo;
 	bool isBigEndian;
 	bool isSigned;
 };
diff --git a/engines/saga/sagaresnames.h b/engines/saga/sagaresnames.h
deleted file mode 100644
index 5bce483c3e..0000000000
--- a/engines/saga/sagaresnames.h
+++ /dev/null
@@ -1,274 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-// Descriptive names for game resource numbers
-
-#ifndef SAGA_RESOURCENAMES_H
-#define SAGA_RESOURCENAMES_H
-
-namespace Saga {
-
-// Prefix RID_ means Resource Id
-
-// Lookup tables
-#define RID_ITE_SCENE_LUT  1806
-#define RID_ITE_SCRIPT_LUT 216
-
-#define RID_ITEDEMO_SCENE_LUT  318
-#define RID_ITEDEMO_SCRIPT_LUT 146
-
-#define RID_IHNM_SCENE_LUT  1272
-#define RID_IHNM_SCRIPT_LUT 29
-#define RID_IHNM_SFX_LUT 265
-
-#define RID_IHNMDEMO_SCENE_LUT  286
-#define RID_IHNMDEMO_SCRIPT_LUT 18
-#define RID_IHNMDEMO_SFX_LUT 222
-
-// Object names
-#define ITE_OBJ_MAP 14
-#define ITE_OBJ_MAGIC_HAT 0
-
-#define IHNM_OBJ_PROFILE 0x4000
-
-#define RID_IHNM_DEFAULT_PALETTE 1
-
-// Actor names
-#define ITE_ACTOR_PUZZLE 176
-
-// Scenes
-#define ITE_SCENE_INV -1
-#define ITE_SCENE_PUZZLE 26
-#define ITE_SCENE_LODGE 21
-#define ITE_SCENE_ENDCREDIT1 295
-
-#define ITE_DEFAULT_SCENE 32
-#define IHNM_DEFAULT_SCENE 151
-
-#define ITEDEMO_DEFAULT_SCENE 68
-#define IHNMDEMO_DEFAULT_SCENE 144
-
-// Fonts
-#define RID_MEDIUM_FONT 0
-#define RID_BIG_FONT 1
-#define RID_SMALL_FONT 2
-
-// Interface images
-#define RID_ITE_MAIN_PANEL 3
-#define RID_ITE_CONVERSE_PANEL 4
-#define RID_ITE_OPTION_PANEL 5
-#define RID_ITE_MAIN_SPRITES 6
-#define RID_ITE_MAIN_PANEL_SPRITES 7
-#define RID_ITE_MAIN_STRINGS 35 //main strings
-#define RID_ITE_ACTOR_NAMES 36 //actors names
-#define RID_ITE_DEFAULT_PORTRAITS 125
-
-#define RID_ITEDEMO_MAIN_PANEL 2
-#define RID_ITEDEMO_CONVERSE_PANEL 3
-#define RID_ITEDEMO_OPTION_PANEL 3 // FIXME: should be 4 but it is an empty resource.
-#define RID_ITEDEMO_MAIN_SPRITES 5 // Proper fix would be not load options panel when demo is running
-#define RID_ITEDEMO_MAIN_PANEL_SPRITES 6
-#define RID_ITEDEMO_MAIN_STRINGS 8 //main strings
-#define RID_ITEDEMO_ACTOR_NAMES 9 //actors names
-#define RID_ITEDEMO_DEFAULT_PORTRAITS 80
-
-#define RID_ITE_TYCHO_MAP 1686
-#define RID_ITE_SPR_XHAIR1 (73 + 9)
-#define RID_ITE_SPR_XHAIR2 (74 + 9)
-
-#define RID_IHNM_MAIN_PANEL 9
-#define RID_IHNM_CONVERSE_PANEL 10
-#define RID_IHNM_HOURGLASS_CURSOR 11
-#define RID_IHNM_MAIN_SPRITES 12
-#define RID_IHNM_MAIN_PANEL_SPRITES 12
-#define RID_IHNM_ARROW_SPRITES 13
-#define RID_IHNM_SAVEREMINDER_SPRITES 14
-#define RID_IHNM_OPTION_PANEL 15
-#define RID_IHNM_OPTION_PANEL_SPRITES 16
-#define RID_IHNM_WARNING_PANEL 17
-#define RID_IHNM_WARNING_PANEL_SPRITES 18
-#define RID_IHNM_BOSS_SCREEN 19
-#define RID_IHNM_PROFILE_BG 20
-#define RID_IHNM_MAIN_STRINGS 21
-
-#define RID_IHNMDEMO_MAIN_PANEL 5
-#define RID_IHNMDEMO_CONVERSE_PANEL 6
-#define RID_IHNMDEMO_HOURGLASS_CURSOR 6			// Does not exist in the demo
-#define RID_IHNMDEMO_MAIN_SPRITES 7
-#define RID_IHNMDEMO_MAIN_PANEL_SPRITES 7
-#define RID_IHNMDEMO_ARROW_SPRITES 8
-#define RID_IHNMDEMO_SAVEREMINDER_SPRITES 9
-#define RID_IHNMDEMO_OPTION_PANEL 10
-#define RID_IHNMDEMO_OPTION_PANEL_SPRITES 11
-#define RID_IHNMDEMO_WARNING_PANEL 12
-#define RID_IHNMDEMO_WARNING_PANEL_SPRITES 13
-#define RID_IHNMDEMO_BOSS_SCREEN 14				// Does not exist in the demo
-#define RID_IHNMDEMO_PROFILE_BG 15
-#define RID_IHNMDEMO_MAIN_STRINGS 16
-
-// Puzzle portraits
-#define RID_ITE_SAKKA_APPRAISING	6
-#define RID_ITE_SAKKA_DENIAL		7
-#define RID_ITE_SAKKA_EXCITED		8
-#define RID_ITE_JFERRET_SERIOUS		9
-#define RID_ITE_JFERRET_GOOFY		10
-#define RID_ITE_JFERRET_ALOOF		11
-
-// ITE Scene resource numbers
-#define RID_ITE_OVERMAP_SCENE 226
-#define RID_ITE_INTRO_ANIM_SCENE 1538
-#define RID_ITE_CAVE_SCENE_1 1542
-#define RID_ITE_CAVE_SCENE_2 1545
-#define RID_ITE_CAVE_SCENE_3 1548
-#define RID_ITE_CAVE_SCENE_4 1551
-
-#define RID_ITE_VALLEY_SCENE 1556
-#define RID_ITE_TREEHOUSE_SCENE 1560
-#define RID_ITE_FAIREPATH_SCENE 1564
-#define RID_ITE_FAIRETENT_SCENE 1567
-
-#define RID_ITE_INTRO_ANIM_STARTFRAME 1529
-
-#define RID_ITE_INTRO_ANIM_1 1530
-#define RID_ITE_INTRO_ANIM_2 1531
-#define RID_ITE_INTRO_ANIM_3 1532
-#define RID_ITE_INTRO_ANIM_4 1533
-#define RID_ITE_INTRO_ANIM_5 1534
-#define RID_ITE_INTRO_ANIM_6 1535
-#define RID_ITE_INTRO_ANIM_7 1536
-
-#define RID_ITE_CAVE_IMG_1 1540
-#define RID_ITE_CAVE_IMG_2 1543
-#define RID_ITE_CAVE_IMG_3 1546
-#define RID_ITE_CAVE_IMG_4 1549
-
-#define RID_ITE_INTRO_IMG_1 1552
-#define RID_ITE_INTRO_IMG_2 1557
-#define RID_ITE_INTRO_IMG_3 1561
-#define RID_ITE_INTRO_IMG_4 1565
-
-// ITE voices
-#define RID_CAVE_VOICE_0 0
-#define RID_CAVE_VOICE_1 1
-#define RID_CAVE_VOICE_2 2
-#define RID_CAVE_VOICE_3 3
-#define RID_CAVE_VOICE_4 4
-#define RID_CAVE_VOICE_5 5
-#define RID_CAVE_VOICE_6 6
-#define RID_CAVE_VOICE_7 7
-#define RID_CAVE_VOICE_8 8
-#define RID_CAVE_VOICE_9 9
-#define RID_CAVE_VOICE_10 10
-#define RID_CAVE_VOICE_11 11
-#define RID_CAVE_VOICE_12 12
-#define RID_CAVE_VOICE_13 13
-
-#define RID_SCENE1_VOICE_009 57
-//TODO: fill it
-#define RID_SCENE1_VOICE_138 186
-
-#define RID_BOAR_VOICE_000 239
-#define RID_BOAR_VOICE_002 241
-#define RID_BOAR_VOICE_005 244
-#define RID_BOAR_VOICE_006 245
-#define RID_BOAR_VOICE_007 246
-
-// Music
-#define MUSIC_1 9
-#define MUSIC_2 10
-#define MUSIC_SUNSPOT 26
-
-// TODO: If the sound effects are numbered sequentially, we don't really need
-//       these constants. But for now they might be useful for debugging.
-
-// Sound effects
-
-#define FX_DOOR_OPEN 14
-#define FX_DOOR_CLOSE 15
-#define FX_RUSH_WATER 16
-#define FX_CRICKET 17
-#define FX_PORTICULLIS 18
-#define FX_CLOCK_1 19
-#define FX_CLOCK_2 20
-#define FX_DAM_MACHINE 21
-#define FX_HUM1 22
-#define FX_HUM2 23
-#define FX_HUM3 24
-#define FX_HUM4 25
-#define FX_STREAM 26
-#define FX_SURF 27
-#define FX_FIRELOOP 28
-#define FX_SCRAPING 29
-#define FX_BEE_SWARM 30
-#define FX_SQUEAKBOARD 31
-#define FX_KNOCK 32
-#define FX_COINS 33
-#define FX_STORM 34
-#define FX_DOOR_CLOSE_2 35
-#define FX_ARCWELD 36
-#define FX_RETRACT_ORB 37
-#define FX_DRAGON 38
-#define FX_SNORES 39
-#define FX_SPLASH 40
-#define FX_LOBBY_DOOR 41
-#define FX_CHIRP_LOOP 42
-#define FX_DOOR_CREAK 43
-#define FX_SPOON_DIG 44
-#define FX_CROW 45
-#define FX_COLDWIND 46
-#define FX_TOOL_SND_1 47
-#define FX_TOOL_SND_2 48
-#define FX_TOOL_SND_3 49
-#define FX_DOOR_METAL 50
-#define FX_WATER_LOOP_S 51
-#define FX_WATER_LOOP_L 52
-#define FX_DOOR_OPEN_2 53
-#define FX_JAIL_DOOR 54
-#define FX_KILN_FIRE 55
-#define FX_DUMMY 56
-
-// These are only in the CD version
-
-#define FX_CROWD_01 57
-#define FX_CROWD_02 58
-#define FX_CROWD_03 59
-#define FX_CROWD_04 60
-#define FX_CROWD_05 61
-#define FX_CROWD_06 62
-#define FX_CROWD_07 63
-#define FX_CROWD_08 64
-#define FX_CROWD_09 65
-#define FX_CROWD_10 66
-#define FX_CROWD_11 67
-#define FX_CROWD_12 68
-#define FX_CROWD_13 69
-#define FX_CROWD_14 70
-#define FX_CROWD_15 71
-#define FX_CROWD_16 72
-#define FX_CROWD_17 73
-
-} // End of namespace Saga
-
-#endif
diff --git a/engines/saga/saveload.cpp b/engines/saga/saveload.cpp
index 53290cbc5d..8d00f9d2d0 100644
--- a/engines/saga/saveload.cpp
+++ b/engines/saga/saveload.cpp
@@ -37,7 +37,6 @@
 #include "saga/isomap.h"
 #include "saga/music.h"
 #include "saga/render.h"
-#include "saga/sagaresnames.h"
 #include "saga/scene.h"
 #include "saga/script.h"
 
diff --git a/engines/saga/scene.cpp b/engines/saga/scene.cpp
index 4520c3f406..c3c1587822 100644
--- a/engines/saga/scene.cpp
+++ b/engines/saga/scene.cpp
@@ -43,7 +43,6 @@
 #include "saga/scene.h"
 #include "saga/actor.h"
 #include "saga/rscfile.h"
-#include "saga/sagaresnames.h"
 
 #include "graphics/iff.h"
 #include "common/util.h"
diff --git a/engines/saga/scene.h b/engines/saga/scene.h
index 0e4c0ed66a..723792f050 100644
--- a/engines/saga/scene.h
+++ b/engines/saga/scene.h
@@ -38,9 +38,21 @@ namespace Saga {
 //#define SCENE_DEBUG // for scene debugging
 
 #define SCENE_DOORS_MAX 16
-
 #define NO_CHAPTER_CHANGE -2
 
+// Scenes
+#define ITE_SCENE_INV -1
+#define ITE_SCENE_PUZZLE 26
+#define ITE_SCENE_LODGE 21
+#define ITE_SCENE_ENDCREDIT1 295
+#define ITE_SCENE_OVERMAP 226
+
+// Default scenes
+#define ITE_DEFAULT_SCENE 32
+#define IHNM_DEFAULT_SCENE 151
+#define ITEDEMO_DEFAULT_SCENE 68
+#define IHNMDEMO_DEFAULT_SCENE 144
+
 class ObjectMap;
 
 struct Event;
diff --git a/engines/saga/sfuncs.cpp b/engines/saga/sfuncs.cpp
index 4862ce3be0..ea61f5ce04 100644
--- a/engines/saga/sfuncs.cpp
+++ b/engines/saga/sfuncs.cpp
@@ -47,7 +47,6 @@
 
 #include "saga/scene.h"
 #include "saga/isomap.h"
-#include "saga/sagaresnames.h"
 
 #include "common/config-manager.h"
 
diff --git a/engines/saga/sndres.cpp b/engines/saga/sndres.cpp
index 9d3d4a9afa..8d269fb3e8 100644
--- a/engines/saga/sndres.cpp
+++ b/engines/saga/sndres.cpp
@@ -28,7 +28,6 @@
 #include "saga/saga.h"
 
 #include "saga/itedata.h"
-#include "saga/sagaresnames.h"
 #include "saga/rscfile.h"
 #include "saga/sndres.h"
 #include "saga/sound.h"
@@ -43,6 +42,9 @@
 
 namespace Saga {
 
+#define RID_IHNM_SFX_LUT 265
+#define RID_IHNMDEMO_SFX_LUT 222
+
 SndRes::SndRes(SagaEngine *vm) : _vm(vm) {
 	// Load sound module resource file contexts
 	_sfxContext = _vm->_resource->getContext(GAME_SOUNDFILE);
@@ -259,11 +261,11 @@ bool SndRes::load(ResourceContext *context, uint32 resourceId, SoundBuffer &buff
 
 	switch (resourceType) {
 	case kSoundPCM:
-		buffer.frequency = soundInfo->frequency;
+		buffer.frequency = 22050;
 		buffer.isSigned = soundInfo->isSigned;
 		buffer.sampleBits = soundInfo->sampleBits;
 		buffer.size = soundResourceLength;
-		buffer.stereo = soundInfo->stereo;
+		buffer.stereo = false;
 		if (onlyHeader) {
 			buffer.buffer = NULL;
 			free(soundResource);
@@ -273,11 +275,11 @@ bool SndRes::load(ResourceContext *context, uint32 resourceId, SoundBuffer &buff
 		result = true;
 		break;
 	case kSoundMacPCM:
-		buffer.frequency = soundInfo->frequency;
+		buffer.frequency = 22050;
 		buffer.isSigned = soundInfo->isSigned;
 		buffer.sampleBits = soundInfo->sampleBits;
 		buffer.size = soundResourceLength - 36;
-		buffer.stereo = soundInfo->stereo;
+		buffer.stereo = false;
 		if (onlyHeader) {
 			buffer.buffer = NULL;
 		} else {
@@ -288,10 +290,10 @@ bool SndRes::load(ResourceContext *context, uint32 resourceId, SoundBuffer &buff
 		result = true;
 		break;
 	case kSoundVOX:
-		buffer.frequency = soundInfo->frequency;
+		buffer.frequency = 22050;
 		buffer.isSigned = soundInfo->isSigned;
 		buffer.sampleBits = soundInfo->sampleBits;
-		buffer.stereo = soundInfo->stereo;
+		buffer.stereo = false;
 		buffer.size = soundResourceLength * 4;
 		if (onlyHeader) {
 			buffer.buffer = NULL;
diff --git a/engines/saga/sprite.cpp b/engines/saga/sprite.cpp
index b5c675a403..e9d002819c 100644
--- a/engines/saga/sprite.cpp
+++ b/engines/saga/sprite.cpp
@@ -29,7 +29,6 @@
 
 #include "saga/gfx.h"
 #include "saga/scene.h"
-#include "saga/sagaresnames.h"
 #include "saga/rscfile.h"
 #include "saga/font.h"
 
@@ -37,6 +36,11 @@
 
 namespace Saga {
 
+#define RID_IHNM_ARROW_SPRITES 13
+#define RID_IHNM_SAVEREMINDER_SPRITES 14
+#define RID_IHNMDEMO_ARROW_SPRITES 8
+#define RID_IHNMDEMO_SAVEREMINDER_SPRITES 9
+
 Sprite::Sprite(SagaEngine *vm) : _vm(vm) {
 	debug(8, "Initializing sprite subsystem...");
 
diff --git a/engines/saga/sthread.cpp b/engines/saga/sthread.cpp
index bc18632659..c1b289a060 100644
--- a/engines/saga/sthread.cpp
+++ b/engines/saga/sthread.cpp
@@ -34,10 +34,12 @@
 #include "saga/script.h"
 
 #include "saga/scene.h"
-#include "saga/sagaresnames.h"
 
 namespace Saga {
 
+#define RID_SCENE1_VOICE_START 57
+#define RID_SCENE1_VOICE_END 186
+
 ScriptThread *Script::createThread(uint16 scriptModuleNumber, uint16 scriptEntryPointNumber) {
 	ScriptThread *newThread;
 
@@ -653,8 +655,8 @@ bool Script::runThread(ScriptThread *thread, uint instructionLimit) {
 
 				if (_vm->getGameId() == GID_ITE_DISK_G) { // special ITE dos
 					if ((_vm->_scene->currentSceneNumber() == ITE_DEFAULT_SCENE) &&
-						(iparam1 >= 288) && (iparam1 <= (RID_SCENE1_VOICE_138 - RID_SCENE1_VOICE_009 + 288))) {
-						sampleResourceId = RID_SCENE1_VOICE_009 + iparam1 - 288;
+						(iparam1 >= 288) && (iparam1 <= (RID_SCENE1_VOICE_END - RID_SCENE1_VOICE_START + 288))) {
+						sampleResourceId = RID_SCENE1_VOICE_START + iparam1 - 288;
 					}
 				} else {
 					if (thread->_voiceLUT->voicesCount > first) {
diff --git a/engines/scumm/charset.cpp b/engines/scumm/charset.cpp
index 46d034d880..8f3175f098 100644
--- a/engines/scumm/charset.cpp
+++ b/engines/scumm/charset.cpp
@@ -371,7 +371,7 @@ int CharsetRenderer::getStringWidth(int arg, const byte *text) {
 					break;
 			}
 		} else {
-			if (chr == '@' && _vm->_language != Common::ZH_TWN)
+			if (chr == '@' && !(_vm->_game.id == GID_CMI && _vm->_language == Common::ZH_TWN))
 				continue;
 			if (chr == 255 || (_vm->_game.version <= 6 && chr == 254)) {
 				chr = text[pos++];
@@ -400,7 +400,8 @@ int CharsetRenderer::getStringWidth(int arg, const byte *text) {
 
 			// Some localizations may override colors
 			// See credits in Chinese COMI
-			if (chr == '^' && pos == 1) {
+			if (_vm->_game.id == GID_CMI && _vm->_language == Common::ZH_TWN &&
+			    chr == '^' && pos == 1) {
 				if (text[pos] == 'c') {
 					pos += 4;
 					chr = text[pos++];
diff --git a/engines/scumm/debugger.cpp b/engines/scumm/debugger.cpp
index 954e400c2c..9f9115e207 100644
--- a/engines/scumm/debugger.cpp
+++ b/engines/scumm/debugger.cpp
@@ -498,25 +498,24 @@ bool ScummDebugger::Cmd_Object(int argc, const char **argv) {
 }
 
 bool ScummDebugger::Cmd_Debug(int argc, const char **argv) {
-	Common::Array<Common::EngineDebugLevel> lvls = Common::listSpecialDebugLevels();
+	const Common::DebugLevelContainer &lvls = Common::listSpecialDebugLevels();
 
 	bool setFlag = false;	// Remove or add debug channel?
 
 	if ((argc == 1) && (Common::getEnabledSpecialDebugLevels() == 0)) {
 		DebugPrintf("No debug flags are enabled\n");
 		DebugPrintf("Available Channels: ");
-		for (uint i = 0; i < lvls.size(); i++) {
-			DebugPrintf("%s, ", lvls[i].option.c_str());
+		for (Common::DebugLevelContainer::iterator i = lvls.begin(); i != lvls.end(); ++i) {
+			DebugPrintf("%s, ", i->option.c_str());
 		}
 		DebugPrintf("\n");
 		return true;
 	}
 
 	if ((argc == 1) && (Common::getEnabledSpecialDebugLevels() > 0)) {
-		for (uint i = 0; i < lvls.size(); i++) {
-			if (lvls[i].enabled)
-				DebugPrintf("%s - %s\n", lvls[i].option.c_str(),
-							 lvls[i].description.c_str());
+		for (Common::DebugLevelContainer::iterator i = lvls.begin(); i != lvls.end(); ++i) {
+			if (i->enabled)
+				DebugPrintf("%s - %s\n", i->option.c_str(), i->description.c_str());
 		}
 		return true;
 	}
@@ -529,25 +528,24 @@ bool ScummDebugger::Cmd_Debug(int argc, const char **argv) {
 	} else {
 		DebugPrintf("Syntax: Debug +CHANNEL, or Debug -CHANNEL\n");
 		DebugPrintf("Available Channels: ");
-		for (uint i = 0; i < lvls.size(); i++) {
-			DebugPrintf("%s, ", lvls[i].option.c_str());
-			DebugPrintf("\n");
+		for (Common::DebugLevelContainer::iterator i = lvls.begin(); i != lvls.end(); ++i) {
+			DebugPrintf("%s\n", i->option.c_str());
 		}
 	}
 
 	// Identify flag
 	const char *realFlag = argv[1] + 1;
-	for (uint i = 0; i < lvls.size(); i++) {
-		if ((scumm_stricmp(lvls[i].option.c_str(), realFlag)) == 0) {
+	for (Common::DebugLevelContainer::iterator i = lvls.begin(); i != lvls.end(); ++i) {
+		if (i->option.equalsIgnoreCase(realFlag)) {
 			if (setFlag) {
-				enableSpecialDebugLevel(lvls[i].option);
+				enableSpecialDebugLevel(i->option);
 				DebugPrintf("Enable ");
 			} else {
-				disableSpecialDebugLevel(lvls[i].option);
+				disableSpecialDebugLevel(i->option);
 				DebugPrintf("Disable ");
 			}
 
-			DebugPrintf("%s\n", lvls[i].description.c_str());
+			DebugPrintf("%s\n", i->description.c_str());
 			return true;
 		}
 	}
diff --git a/engines/scumm/detection_tables.h b/engines/scumm/detection_tables.h
index 49ac5a18eb..474707ec55 100644
--- a/engines/scumm/detection_tables.h
+++ b/engines/scumm/detection_tables.h
@@ -642,6 +642,7 @@ static const GameFilenamePattern gameFilenamesTable[] = {
 	{ "pajama", "Pajama Sam", kGenHEMac, UNK_LANG, Common::kPlatformMacintosh, 0 },
 	{ "pajama", "PajamaNHD", kGenHEPC, UNK_LANG, UNK, 0 },
 	{ "pajama", "PJS-DEMO", kGenHEPC, UNK_LANG, UNK, 0 },
+	{ "pajama", "pjsam", kGenHEPC, UNK_LANG, UNK, 0 },
 	{ "pajama", "PjSamDemo", kGenHEPC, UNK_LANG, UNK, 0 },
 	{ "pajama", "PYJAMA", kGenHEPC, Common::DE_DEU, UNK, 0 },
 	{ "pajama", "SAMDEMO", kGenHEPC, Common::FR_FRA, UNK, 0 },
diff --git a/engines/scumm/saveload.cpp b/engines/scumm/saveload.cpp
index a8ef26c484..36b82519e9 100644
--- a/engines/scumm/saveload.cpp
+++ b/engines/scumm/saveload.cpp
@@ -23,6 +23,8 @@
  *
  */
 
+#include <time.h>	// for ScummEngine::saveInfos / ScummEngine::loadInfos
+
 #include "common/config-manager.h"
 #include "common/savefile.h"
 #include "common/system.h"
@@ -44,8 +46,6 @@
 #include "sound/audiocd.h"
 #include "sound/mixer.h"
 
-#include <time.h>	// for ScummEngine::saveInfos / ScummEngine::loadInfos
-
 namespace Scumm {
 
 struct SaveGameHeader {
diff --git a/engines/scumm/script_v6.cpp b/engines/scumm/script_v6.cpp
index faae72b6dd..04ea53137b 100644
--- a/engines/scumm/script_v6.cpp
+++ b/engines/scumm/script_v6.cpp
@@ -23,6 +23,8 @@
  *
  */
 
+#include <time.h>	// for ScummEngine_v6::o6_getDateTime()
+
 #include "common/config-manager.h"
 #include "common/system.h"
 
@@ -44,8 +46,6 @@
 #include "sound/mididrv.h"
 #include "sound/mixer.h"
 
-#include <time.h>	// for ScummEngine_v6::o6_getDateTime()
-
 namespace Scumm {
 
 #define OPCODE(x)	_OPCODE(ScummEngine_v6, x)
diff --git a/engines/scumm/scumm-md5.h b/engines/scumm/scumm-md5.h
index f0bc179c61..a95fe790b2 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 Mon May 12 04:29:20 2008
+  This file was generated by the md5table tool on Sat May 24 00:59:21 2008
   DO NOT EDIT MANUALLY!
  */
 
@@ -107,6 +107,7 @@ static const MD5Table md5table[] = {
 	{ "22c9eb04455440131ffc157aeb8d40a8", "fbear", "HE 70", "Demo", -1, Common::EN_ANY, Common::kPlatformWindows },
 	{ "22d07d6c386c9c25aca5dac2a0c0d94b", "maniac", "NES", "", 262144, Common::SE_SWE, Common::kPlatformNES },
 	{ "22f4ea88a09da12df9308ba30bcb7d0f", "loom", "EGA", "EGA", -1, Common::EN_ANY, Common::kPlatformPC },
+	{ "23394c8d29cc63c61313959431a12476", "spyfox", "HE 100", "Updated", -1, Common::EN_ANY, Common::kPlatformWindows },
 	{ "257f8c14d8c584f7ddd601bcb00920c7", "maniac", "NES", "", 262144, Common::DE_DEU, Common::kPlatformNES },
 	{ "2723fea3dae0cb47768c424b145ae0e7", "tentacle", "", "Floppy", 7932, Common::EN_ANY, Common::kPlatformPC },
 	{ "27b3a4224ad63d5b04627595c1c1a025", "zak", "V2", "V2", -1, Common::IT_ITA, Common::kPlatformAmiga },
@@ -156,6 +157,7 @@ static const MD5Table md5table[] = {
 	{ "39fd6db10d0222d817025c4d3346e3b4", "farm", "", "Demo", -1, Common::EN_ANY, Common::kPlatformMacintosh },
 	{ "3a03dab514e4038df192d8a8de469788", "atlantis", "", "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 },
 	{ "3a5ec90d556d4920976c5578bfbfaf79", "maniac", "NES", "extracted", -1, Common::DE_DEU, Common::kPlatformNES },
 	{ "3af61c5edf8e15b43dbafd285b2e9777", "puttcircus", "", "Demo", -1, Common::HB_ISR, Common::kPlatformWindows },
@@ -300,6 +302,7 @@ static const MD5Table md5table[] = {
 	{ "771bc18ec6f93837b839c992b211904b", "monkey", "Demo", "EGA Demo", -1, Common::DE_DEU, Common::kPlatformPC },
 	{ "77f5c9cc0986eb729c1a6b4c8823bbae", "zak", "FM-TOWNS", "Demo", 7520, Common::EN_ANY, Common::kPlatformFMTowns },
 	{ "780e4a0ae2ff17dc296f4a79543b44f8", "puttmoon", "", "", -1, Common::UNK_LANG, Common::kPlatformPC },
+	{ "782393c5934ecd0b536eaf5fd541bd26", "pajama", "HE 100", "Updated", -1, Common::EN_ANY, Common::kPlatformWindows },
 	{ "78bd5f036ea35a878b74e4f47941f784", "freddi4", "HE 99", "", -1, Common::RU_RUS, Common::kPlatformWindows },
 	{ "78c07ca088526d8d4446a4c2cb501203", "freddi3", "HE 99", "", -1, Common::FR_FRA, Common::kPlatformUnknown },
 	{ "7974365d3dc0f43a2748c975f91ff042", "monkey2", "", "", -1, Common::ES_ESP, Common::kPlatformPC },
@@ -428,6 +431,7 @@ static const MD5Table md5table[] = {
 	{ "bbadf7309c4a2c2763e4bbba3c3be634", "freddi3", "", "Demo", -1, Common::FR_FRA, Common::kPlatformUnknown },
 	{ "bc4700bc0e12879f6d25d14d6be6cfdd", "spyfox2", "", "", -1, Common::DE_DEU, Common::kPlatformUnknown },
 	{ "bd126753de619a495f9f22adc951c8d5", "monkey2", "", "", -1, Common::IT_ITA, Common::kPlatformPC },
+	{ "be2abe172f58db170de3a037daa1dd27", "puttputt", "HE 61", "", -1, Common::JA_JPN, Common::kPlatform3DO },
 	{ "be39a5d4db60e8aa736b9086778cb45c", "spyozon", "", "", -1, Common::EN_GRB, Common::kPlatformWindows },
 	{ "be83e882b44f2767bc08d4f766ebc347", "maniac", "V2", "V2", -1, Common::DE_DEU, Common::kPlatformAtariST },
 	{ "bf8b52fdd9a69c67f34e8e9fec72661c", "farm", "HE 71", "Demo", -1, Common::EN_ANY, Common::kPlatformWindows },
diff --git a/engines/scumm/string.cpp b/engines/scumm/string.cpp
index f42a803a3d..81ffaa89ba 100644
--- a/engines/scumm/string.cpp
+++ b/engines/scumm/string.cpp
@@ -174,11 +174,10 @@ void ScummEngine_v6::drawBlastTexts() {
 
 				// Some localizations may override colors
 				// See credits in Chinese COMI
-				if (c == '^' && (buf == _blastTextQueue[i].text + 1)) {
-					int color;
-					switch (*buf) {
-					case 'c':
-						color = buf[3] - '0' + 10 *(buf[2] - '0');
+				if (_game.id == GID_CMI && 	_language == Common::ZH_TWN &&
+				      c == '^' && (buf == _blastTextQueue[i].text + 1)) {
+					if (*buf == 'c') {
+						int color = buf[3] - '0' + 10 *(buf[2] - '0');
 						_charset->setColor(color);
 
 						buf += 4;
@@ -1114,7 +1113,8 @@ int ScummEngine::convertMessageToString(const byte *msg, byte *dst, int dstSize)
 				num += (_game.version == 8) ? 4 : 2;
 			}
 		} else {
-			if (!(chr == '@' && _game.heversion <= 71) || _language == Common::ZH_TWN) {
+			if (!(chr == '@' && _game.heversion <= 71) ||
+			    (_game.id == GID_CMI && _language == Common::ZH_TWN)) {
 				*dst++ = chr;
 			}
 		}
@@ -1462,8 +1462,17 @@ void ScummEngine_v7::translateText(const byte *text, byte *trans_buff) {
 	trans_buff[0] = 0;
 	_lastStringTag[0] = 0;
 
+	if (_game.version >= 7 && text[0] == '/') {
+		// Extract the string tag from the text: /..../
+		for (i = 0; (i < 12) && (text[i + 1] != '/'); i++)
+			_lastStringTag[i] = toupper(text[i + 1]);
+		_lastStringTag[i] = 0;
+	}
+
 	// WORKAROUND for bug #1172655.
 	if (_game.id == GID_DIG) {
+		// Based on the second release of The Dig
+		// Only applies to the subtitles and not speech
 		if (!strcmp((const char *)text, "faint light"))
 			text = (const byte *)"/NEW.007/faint light";
 		else if (!strcmp((const char *)text, "glowing crystal"))
@@ -1472,9 +1481,9 @@ void ScummEngine_v7::translateText(const byte *text, byte *trans_buff) {
 			text = (const byte *)"/NEW.009/glowing crystals";
 		else if (!strcmp((const char *)text, "pit"))
 			text = (const byte *)"/NEW.010/pit";
-		else if (!strcmp((const char *)text, "You wish."))
+		else if (!strcmp((const char *)text, "/NEWTON.032/"))
 			text = (const byte *)"/NEW.011/You wish.";
-		else if (!strcmp((const char *)text, "In your dreams."))
+		else if (!strcmp((const char *)text, "/NEWTON.034/"))
 			text = (const byte *)"/NEW.012/In your dreams";
 		else if (!strcmp((const char *)text, "left"))
 			text = (const byte *)"/CATHPLAT.068/left";
@@ -1488,12 +1497,6 @@ void ScummEngine_v7::translateText(const byte *text, byte *trans_buff) {
 			text = (const byte *)"/NEW.013/unattached lens";
 		else if (!strcmp((const char *)text, "lens slot"))
 			text = (const byte *)"/NEW.014/lens slot";
-
-		// Added in second release of The Dig
-		else if (!strcmp((const char *)text, "/NEWTON.032/"))
-			text = (const byte *)"/NEW.11/You wish.";
-		else if (!strcmp((const char *)text, "/NEWTON.034/"))
-			text = (const byte *)"/NEW.12/In your dreams";
 		else if (!strcmp((const char *)text, "Jonathon Jackson"))
 			text = (const byte *)"Aram Gutowski";
 		else if (!strcmp((const char *)text, "Brink"))
@@ -1506,8 +1509,8 @@ void ScummEngine_v7::translateText(const byte *text, byte *trans_buff) {
 	if (_game.version >= 7 && text[0] == '/') {
 		// Extract the string tag from the text: /..../
 		for (i = 0; (i < 12) && (text[i + 1] != '/'); i++)
-			_lastStringTag[i] = target.tag[i] = toupper(text[i + 1]);
-		_lastStringTag[i] = target.tag[i] = 0;
+			target.tag[i] = toupper(text[i + 1]);
+		target.tag[i] = 0;
 		text += i + 2;
 
 		// If a language file was loaded, try to find a translated version
diff --git a/engines/sword2/mouse.cpp b/engines/sword2/mouse.cpp
index 44d2383f78..af4f121e96 100644
--- a/engines/sword2/mouse.cpp
+++ b/engines/sword2/mouse.cpp
@@ -1462,19 +1462,19 @@ void Mouse::checkPlayerActivity(uint32 seconds) {
 		_vm->_logic->writeVar(RESULT, 0);
 }
 
-void Mouse::pauseGame() {
-	// Make the mouse cursor normal. This is the only place where we are
-	// allowed to clear the luggage this way.
+void Mouse::pauseEngine(bool pause) {
+	if (pause) {
+		// Make the mouse cursor normal. This is the only place where
+		// we are allowed to clear the luggage this way.
 
-	clearPointerText();
-	setLuggageAnim(NULL, 0);
-	setMouse(0);
-	setMouseTouching(1);
-}
-
-void Mouse::unpauseGame() {
-	if (_vm->_logic->readVar(OBJECT_HELD) && _realLuggageItem)
-		setLuggage(_realLuggageItem);
+		clearPointerText();
+		setLuggageAnim(NULL, 0);
+		setMouse(0);
+		setMouseTouching(1);
+	} else {
+		if (_vm->_logic->readVar(OBJECT_HELD) && _realLuggageItem)
+			setLuggage(_realLuggageItem);
+	}
 }
 
 #define MOUSEFLASHFRAME 6
diff --git a/engines/sword2/mouse.h b/engines/sword2/mouse.h
index 09ac9ced20..b87129ac7f 100644
--- a/engines/sword2/mouse.h
+++ b/engines/sword2/mouse.h
@@ -211,8 +211,7 @@ public:
 	uint32 getMouseTouching() { return _mouseTouching; }
 	void setMouseTouching(uint32 touching) { _mouseTouching = touching; }
 
-	void pauseGame();
-	void unpauseGame();
+	void pauseEngine(bool pause);
 
 	void setMouse(uint32 res);
 	void setLuggage(uint32 res);
diff --git a/engines/sword2/sword2.cpp b/engines/sword2/sword2.cpp
index 0601d11791..26fd598d9d 100644
--- a/engines/sword2/sword2.cpp
+++ b/engines/sword2/sword2.cpp
@@ -392,7 +392,7 @@ int Sword2Engine::go() {
 
 #ifdef SWORD2_DEBUG
 		if (_stepOneCycle) {
-			pauseGame();
+			pauseEngineIntern(true);
 			_stepOneCycle = false;
 		}
 #endif
@@ -406,9 +406,9 @@ int Sword2Engine::go() {
 				switch (ke->kbd.keycode) {
 				case Common::KEYCODE_p:
 					if (_gamePaused)
-						unpauseGame();
+						pauseEngineIntern(false);
 					else
-						pauseGame();
+						pauseEngineIntern(true);
 					break;
 				case Common::KEYCODE_c:
 					if (!_logic->readVar(DEMO) && !_mouse->isChoosing()) {
@@ -421,7 +421,7 @@ int Sword2Engine::go() {
 				case Common::KEYCODE_SPACE:
 					if (_gamePaused) {
 						_stepOneCycle = true;
-						unpauseGame();
+						pauseEngineIntern(false);
 					}
 					break;
 				case Common::KEYCODE_s:
@@ -689,53 +689,56 @@ void Sword2Engine::sleepUntil(uint32 time) {
 	}
 }
 
-void Sword2Engine::pauseGame() {
-	// Don't allow Pause while screen fading or while black
-	if (_screen->getFadeStatus() != RDFADE_NONE)
-		return;
+void Sword2Engine::pauseEngineIntern(bool pause) {
+	if (pause) {
+		// FIXME: We should never disallow pausing, and we need to do
+		// something about pausing during cutscene moves, credits, etc.
 
-	_sound->pauseAllSound();
-	_mouse->pauseGame();
+		// Don't allow Pause while screen fading or while black
+		if (_screen->getFadeStatus() != RDFADE_NONE)
+			return;
 
-	// If render level is at max, turn it down because palette-matching
-	// won't work when the palette is dimmed.
+		_sound->pauseAllSound();
+		_mouse->pauseEngine(true);
 
-	if (_screen->getRenderLevel() == 3) {
-		_screen->setRenderLevel(2);
-		_graphicsLevelFudged = true;
-	}
+		// If render level is at max, turn it down because palette-
+		// matching won't work when the palette is dimmed.
+
+		if (_screen->getRenderLevel() == 3) {
+			_screen->setRenderLevel(2);
+			_graphicsLevelFudged = true;
+		}
 
 #ifdef SWORD2_DEBUG
-	// Don't dim it if we're single-stepping through frames
-	// dim the palette during the pause
+		// Don't dim it if we're single-stepping through frames
+		// dim the palette during the pause
 
-	if (!_stepOneCycle)
-		_screen->dimPalette();
+		if (!_stepOneCycle)
+			_screen->dimPalette();
 #else
-	_screen->dimPalette();
+		_screen->dimPalette();
 #endif
 
-	_gamePaused = true;
-}
-
-void Sword2Engine::unpauseGame() {
-	_mouse->unpauseGame();
-	_sound->unpauseAllSound();
+		_gamePaused = true;
+	} else {
+		_mouse->pauseEngine(false);
+		_sound->unpauseAllSound();
 
-	// Put back game screen palette; see screen.cpp
-	_screen->setFullPalette(-1);
+		// Put back game screen palette; see screen.cpp
+		_screen->setFullPalette(-1);
 
-	// If graphics level at max, turn up again
-	if (_graphicsLevelFudged) {
-		_screen->setRenderLevel(3);
-		_graphicsLevelFudged = false;
-	}
+		// If graphics level at max, turn up again
+		if (_graphicsLevelFudged) {
+			_screen->setRenderLevel(3);
+			_graphicsLevelFudged = false;
+		}
 
-	_gamePaused = false;
+		_gamePaused = false;
 
-	// If mouse is about or we're in a chooser menu
-	if (!_mouse->getMouseStatus() || _mouse->isChoosing())
-		_mouse->setMouse(NORMAL_MOUSE_ID);
+		// If mouse is about or we're in a chooser menu
+		if (!_mouse->getMouseStatus() || _mouse->isChoosing())
+			_mouse->setMouse(NORMAL_MOUSE_ID);
+	}
 }
 
 uint32 Sword2Engine::getMillis() {
diff --git a/engines/sword2/sword2.h b/engines/sword2/sword2.h
index a9a1e21875..ba59772a71 100644
--- a/engines/sword2/sword2.h
+++ b/engines/sword2/sword2.h
@@ -113,8 +113,7 @@ private:
 
 	uint32 calcChecksum(byte *buffer, uint32 size);
 
-	void pauseGame();
-	void unpauseGame();
+	virtual void pauseEngineIntern(bool pause);
 
 	uint32 _totalStartups;
 	uint32 _totalScreenManagers;