KYRA: cleanup dir

Reorganize all files in sub directories. The file placement isn't as intuitive as it might be for other engines, which is probably the reason why this hasn't been done before.

11 files changed, 3749 insertions, 0 deletions

diff --git a/engines/kyra/text/text.cpp b/engines/kyra/text/text.cpp
new file mode 100644
index 0000000000..36af67e6aa
--- /dev/null
+++ b/engines/kyra/text/text.cpp
@@ -0,0 +1,330 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "kyra/text/text.h"
+#include "kyra/kyra_v1.h"
+
+namespace Kyra {
+
+TextDisplayer::TextDisplayer(KyraEngine_v1 *vm, Screen *screen) {
+	_screen = screen;
+	_vm = vm;
+
+	_talkCoords.y = 0x88;
+	_talkCoords.x = 0;
+	_talkCoords.w = 0;
+	_talkMessageY = 0xC;
+	_talkMessageH = 0;
+	_talkMessagePrinted = false;
+	memset(_talkSubstrings, 0, sizeof(_talkSubstrings));
+	memset(_talkBuffer, 0, sizeof(_talkBuffer));
+}
+
+void TextDisplayer::setTalkCoords(uint16 y) {
+	_talkCoords.y = y;
+}
+
+int TextDisplayer::getCenterStringX(const char *str, int x1, int x2) {
+	_screen->_charWidth = -2;
+	int strWidth = _screen->getTextWidth(str);
+	_screen->_charWidth = 0;
+	int w = x2 - x1 + 1;
+	return x1 + (w - strWidth) / 2;
+}
+
+int TextDisplayer::getCharLength(const char *str, int len) {
+	int charsCount = 0;
+	if (*str) {
+		_screen->_charWidth = -2;
+		int i = 0;
+		while (i <= len && *str) {
+			uint c = *str++;
+			c &= 0xFF;
+			if (c >= 0x7F && _vm->gameFlags().lang == Common::JA_JPN) {
+				c = READ_LE_UINT16(str - 1);
+				++str;
+			}
+			i += _screen->getCharWidth(c);
+			++charsCount;
+		}
+		_screen->_charWidth = 0;
+	}
+	return charsCount;
+}
+
+int TextDisplayer::dropCRIntoString(char *str, int offs) {
+	int pos = 0;
+	str += offs;
+	while (*str) {
+		if (*str == ' ') {
+			*str = '\r';
+			return pos;
+		}
+		++str;
+		++pos;
+	}
+	return 0;
+}
+
+char *TextDisplayer::preprocessString(const char *str) {
+	if (str != _talkBuffer) {
+		assert(strlen(str) < sizeof(_talkBuffer) - 1);
+		strcpy(_talkBuffer, str);
+	}
+	char *p = _talkBuffer;
+	while (*p) {
+		if (*p == '\r') {
+			return _talkBuffer;
+		}
+		++p;
+	}
+	p = _talkBuffer;
+	Screen::FontId curFont = _screen->setFont(Screen::FID_8_FNT);
+	_screen->_charWidth = -2;
+	int textWidth = _screen->getTextWidth(p);
+	_screen->_charWidth = 0;
+	if (textWidth > 176) {
+		if (textWidth > 352) {
+			int count = getCharLength(p, textWidth / 3);
+			int offs = dropCRIntoString(p, count);
+			p += count + offs;
+			_screen->_charWidth = -2;
+			textWidth = _screen->getTextWidth(p);
+			_screen->_charWidth = 0;
+			count = getCharLength(p, textWidth / 2);
+			dropCRIntoString(p, count);
+		} else {
+			int count = getCharLength(p, textWidth / 2);
+			dropCRIntoString(p, count);
+		}
+	}
+	_screen->setFont(curFont);
+	return _talkBuffer;
+}
+
+int TextDisplayer::buildMessageSubstrings(const char *str) {
+	int currentLine = 0;
+	int pos = 0;
+	while (*str) {
+		if (*str == '\r') {
+			assert(currentLine < TALK_SUBSTRING_NUM);
+			_talkSubstrings[currentLine * TALK_SUBSTRING_LEN + pos] = '\0';
+			++currentLine;
+			pos = 0;
+		} else {
+			_talkSubstrings[currentLine * TALK_SUBSTRING_LEN + pos] = *str;
+			++pos;
+			if (pos >= TALK_SUBSTRING_LEN - 2)
+				pos = TALK_SUBSTRING_LEN - 2;
+		}
+		++str;
+	}
+	_talkSubstrings[currentLine * TALK_SUBSTRING_LEN + pos] = '\0';
+	return currentLine + 1;
+}
+
+int TextDisplayer::getWidestLineWidth(int linesCount) {
+	int maxWidth = 0;
+	_screen->_charWidth = -2;
+	for (int l = 0; l < linesCount; ++l) {
+		int w = _screen->getTextWidth(&_talkSubstrings[l * TALK_SUBSTRING_LEN]);
+		if (maxWidth < w) {
+			maxWidth = w;
+		}
+	}
+	_screen->_charWidth = 0;
+	return maxWidth;
+}
+
+void TextDisplayer::calcWidestLineBounds(int &x1, int &x2, int w, int cx) {
+	x1 = cx - w / 2;
+	if (x1 + w >= Screen::SCREEN_W - 12) {
+		x1 = Screen::SCREEN_W - 12 - w - 1;
+	} else if (x1 < 12) {
+		x1 = 12;
+	}
+	x2 = x1 + w + 1;
+}
+
+void TextDisplayer::restoreTalkTextMessageBkgd(int srcPage, int dstPage) {
+	if (_talkMessagePrinted) {
+		_talkMessagePrinted = false;
+		_screen->copyRegion(_talkCoords.x, _talkCoords.y, _talkCoords.x, _talkMessageY, _talkCoords.w, _talkMessageH, srcPage, dstPage, Screen::CR_NO_P_CHECK);
+	}
+}
+
+void TextDisplayer::printTalkTextMessage(const char *text, int x, int y, uint8 color, int srcPage, int dstPage) {
+	char *str = preprocessString(text);
+	int lineCount = buildMessageSubstrings(str);
+	int top = y - lineCount * 10;
+	if (top < 0) {
+		top = 0;
+	}
+	_talkMessageY = top;
+	_talkMessageH = lineCount * 10;
+	int w = getWidestLineWidth(lineCount);
+	int x1, x2;
+	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::CR_NO_P_CHECK);
+	int curPage = _screen->_curPage;
+	_screen->_curPage = srcPage;
+
+	if (_vm->gameFlags().platform == Common::kPlatformAmiga)
+		setTextColor(color);
+
+	for (int i = 0; i < lineCount; ++i) {
+		top = i * 10 + _talkMessageY;
+		char *msg = &_talkSubstrings[i * TALK_SUBSTRING_LEN];
+		int left = getCenterStringX(msg, x1, x2);
+		printText(msg, left, top, color, 0xC, 0);
+	}
+	_screen->_curPage = curPage;
+	_talkMessagePrinted = true;
+}
+
+void TextDisplayer::printText(const char *str, int x, int y, uint8 c0, uint8 c1, uint8 c2) {
+	uint8 colorMap[] = { 0, 15, 12, 12 };
+	colorMap[3] = c1;
+	_screen->setTextColor(colorMap, 0, 3);
+	_screen->_charWidth = -2;
+	_screen->printText(str, x, y, c0, c2);
+	_screen->_charWidth = 0;
+}
+
+void TextDisplayer::printCharacterText(const char *text, int8 charNum, int charX) {
+	int top, left, x1, x2, w, x;
+	char *msg;
+
+	text = preprocessString(text);
+	int lineCount = buildMessageSubstrings(text);
+	w = getWidestLineWidth(lineCount);
+	x = charX;
+	calcWidestLineBounds(x1, x2, w, x);
+
+	uint8 color = 0;
+	if (_vm->gameFlags().platform == Common::kPlatformAmiga) {
+		const uint8 colorTable[] = { 0x1F, 0x1B, 0xC9, 0x80, 0x1E, 0x81, 0x11, 0xD8, 0x55, 0x3A, 0x3A };
+		color = colorTable[charNum];
+
+		setTextColor(color);
+	} else {
+		const uint8 colorTable[] = { 0x0F, 0x09, 0xC9, 0x80, 0x05, 0x81, 0x0E, 0xD8, 0x55, 0x3A, 0x3A };
+		color = colorTable[charNum];
+	}
+
+	for (int i = 0; i < lineCount; ++i) {
+		top = i * 10 + _talkMessageY;
+		msg = &_talkSubstrings[i * TALK_SUBSTRING_LEN];
+		left = getCenterStringX(msg, x1, x2);
+		printText(msg, left, top, color, 0xC, 0);
+	}
+}
+
+void TextDisplayer::setTextColor(uint8 color) {
+	byte r, g, b;
+
+	switch (color) {
+	case 4:
+		// 0x09E
+		r = 0;
+		g = 37;
+		b = 58;
+		break;
+
+	case 5:
+		// 0xFF5
+		r = 63;
+		g = 63;
+		b = 21;
+		break;
+
+	case 27:
+		// 0x5FF
+		r = 21;
+		g = 63;
+		b = 63;
+		break;
+
+	case 34:
+		// 0x8E5
+		r = 33;
+		g = 58;
+		b = 21;
+		break;
+
+	case 58:
+		// 0x9FB
+		r = 37;
+		g = 63;
+		b = 46;
+		break;
+
+	case 85:
+		// 0x7CF
+		r = 29;
+		g = 50;
+		b = 63;
+		break;
+
+	case 114:
+	case 117:
+		// 0xFAF
+		r = 63;
+		g = 42;
+		b = 63;
+		break;
+
+	case 128:
+	case 129:
+		// 0xFCC
+		r = 63;
+		g = 50;
+		b = 50;
+		break;
+
+	case 201:
+		// 0xFD8
+		r = 63;
+		g = 54;
+		b = 33;
+		break;
+
+	case 216:
+		// 0xFC6
+		r = 63;
+		g = 50;
+		b = 25;
+		break;
+
+	default:
+		// 0xEEE
+		r = 58;
+		g = 58;
+		b = 58;
+	}
+
+	_screen->setPaletteIndex(0x10, r, g, b);
+}
+
+} // End of namespace Kyra
diff --git a/engines/kyra/text/text.h b/engines/kyra/text/text.h
new file mode 100644
index 0000000000..3ea51c389c
--- /dev/null
+++ b/engines/kyra/text/text.h
@@ -0,0 +1,81 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef KYRA_TEXT_H
+#define KYRA_TEXT_H
+
+#include "common/scummsys.h"
+
+#include "kyra/graphics/screen.h"
+
+namespace Kyra {
+class KyraEngine_v1;
+
+class TextDisplayer {
+public:
+	TextDisplayer(KyraEngine_v1 *vm, Screen *screen);
+	virtual ~TextDisplayer() {}
+
+	int maxSubstringLen() const { return TALK_SUBSTRING_LEN; }
+
+	void setTalkCoords(uint16 y);
+	int getCenterStringX(const char *str, int x1, int x2);
+	int getCharLength(const char *str, int len);
+	int dropCRIntoString(char *str, int offs);
+	virtual char *preprocessString(const char *str);
+	int buildMessageSubstrings(const char *str);
+	int getWidestLineWidth(int linesCount);
+	virtual void calcWidestLineBounds(int &x1, int &x2, int w, int cx);
+	virtual void restoreTalkTextMessageBkgd(int srcPage, int dstPage);
+	void printTalkTextMessage(const char *text, int x, int y, uint8 color, int srcPage, int dstPage);
+	virtual void printText(const char *str, int x, int y, uint8 c0, uint8 c1, uint8 c2);
+	void printCharacterText(const char *text, int8 charNum, int charX);
+
+	uint16 _talkMessageY;
+	uint16 _talkMessageH;
+	bool printed() const { return _talkMessagePrinted; }
+
+protected:
+	Screen *_screen;
+	KyraEngine_v1 *_vm;
+
+	struct TalkCoords {
+		uint16 y, x, w;
+	};
+
+	// TODO: AMIGA and LoK specific, move to a better location
+	void setTextColor(uint8 color);
+
+	enum {
+		TALK_SUBSTRING_LEN = 80,
+		TALK_SUBSTRING_NUM = 6
+	};
+
+	char _talkBuffer[1040];
+	char _talkSubstrings[TALK_SUBSTRING_LEN * TALK_SUBSTRING_NUM];
+	TalkCoords _talkCoords;
+	bool _talkMessagePrinted;
+};
+
+} // End of namespace Kyra
+
+#endif
diff --git a/engines/kyra/text/text_hof.cpp b/engines/kyra/text/text_hof.cpp
new file mode 100644
index 0000000000..2d6332a0a2
--- /dev/null
+++ b/engines/kyra/text/text_hof.cpp
@@ -0,0 +1,672 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "kyra/text/text_hof.h"
+#include "kyra/resource/resource.h"
+
+#include "common/system.h"
+
+namespace Kyra {
+
+TextDisplayer_HoF::TextDisplayer_HoF(KyraEngine_HoF *vm, Screen_v2 *screen)
+	: TextDisplayer(vm, screen), _vm(vm) {
+}
+
+void TextDisplayer_HoF::backupTalkTextMessageBkgd(int srcPage, int dstPage) {
+	_screen->copyRegion(_talkCoords.x, _talkMessageY, 0, 144, _talkCoords.w, _talkMessageH, srcPage, dstPage);
+}
+
+void TextDisplayer_HoF::restoreTalkTextMessageBkgd(int srcPage, int dstPage) {
+	_screen->copyRegion(0, 144, _talkCoords.x, _talkMessageY, _talkCoords.w, _talkMessageH, srcPage, dstPage);
+}
+
+void TextDisplayer_HoF::restoreScreen() {
+	_vm->restorePage3();
+	_vm->drawAnimObjects();
+	_screen->copyRegion(_talkCoords.x, _talkMessageY, _talkCoords.x, _talkMessageY, _talkCoords.w, _talkMessageH, 2, 0, Screen::CR_NO_P_CHECK);
+	_vm->flagAnimObjsForRefresh();
+	_vm->refreshAnimObjects(0);
+}
+
+void TextDisplayer_HoF::printCustomCharacterText(const char *text, int x, int y, uint8 c1, int srcPage, int dstPage) {
+	text = preprocessString(text);
+	int lineCount = buildMessageSubstrings(text);
+	int w = getWidestLineWidth(lineCount);
+	int h = lineCount * 10;
+	y = MAX(0, y - (lineCount * 10));
+	int x1 = 0, x2 = 0;
+	calcWidestLineBounds(x1, x2, w, x);
+
+	_talkCoords.x = x1;
+	_talkCoords.w = w+2;
+	_talkCoords.y = y;
+	_talkMessageY = y;
+	_talkMessageH = h;
+
+	backupTalkTextMessageBkgd(srcPage, dstPage);
+	int curPageBackUp = _screen->_curPage;
+	_screen->_curPage = srcPage;
+
+	if (_vm->textEnabled()) {
+		for (int i = 0; i < lineCount; ++i) {
+			const char *msg = &_talkSubstrings[i * TALK_SUBSTRING_LEN];
+			printText(msg, getCenterStringX(msg, x1, x2), i * 10 + _talkMessageY, c1, 0xCF, 0);
+		}
+	}
+
+	_screen->_curPage = curPageBackUp;
+}
+
+char *TextDisplayer_HoF::preprocessString(const char *str) {
+	if (str != _talkBuffer) {
+		assert(strlen(str) < sizeof(_talkBuffer) - 1);
+		strcpy(_talkBuffer, str);
+	}
+
+	char *p = _talkBuffer;
+	while (*p) {
+		if (*p == '\r')
+			return _talkBuffer;
+		++p;
+	}
+
+	p = _talkBuffer;
+	Screen::FontId curFont = _screen->setFont(Screen::FID_8_FNT);
+	_screen->_charWidth = -2;
+	int textWidth = _screen->getTextWidth(p);
+	_screen->_charWidth = 0;
+
+	int maxTextWidth = (_vm->language() == 0) ? 176 : 240;
+
+	if (textWidth > maxTextWidth) {
+		if (textWidth > (maxTextWidth*2)) {
+			int count = getCharLength(p, textWidth / 3);
+			int offs = dropCRIntoString(p, count);
+			p += count + offs;
+			_screen->_charWidth = -2;
+			textWidth = _screen->getTextWidth(p);
+			_screen->_charWidth = 0;
+			count = getCharLength(p, textWidth / 2);
+			dropCRIntoString(p, count);
+		} else {
+			int count = getCharLength(p, textWidth / 2);
+			dropCRIntoString(p, count);
+		}
+	}
+	_screen->setFont(curFont);
+	return _talkBuffer;
+}
+
+void TextDisplayer_HoF::calcWidestLineBounds(int &x1, int &x2, int w, int x) {
+	x1 = x;
+	x1 -= (w >> 1);
+	x2 = x1 + w + 1;
+
+	if (x1 + w >= 311)
+		x1 = 311 - w - 1;
+
+	if (x1 < 8)
+		x1 = 8;
+
+	x2 = x1 + w + 1;
+}
+
+#pragma mark -
+
+int KyraEngine_HoF::chatGetType(const char *str) {
+	str += strlen(str);
+	--str;
+	switch (*str) {
+	case '!':
+		return 2;
+
+	case ')':
+		return -1;
+
+	case '?':
+		return 1;
+
+	default:
+		return 0;
+	}
+}
+
+int KyraEngine_HoF::chatCalcDuration(const char *str) {
+	static const uint8 durationMultiplicator[] = { 16, 14, 12, 10, 8, 8, 7, 6, 5, 4 };
+
+	int duration = strlen(str);
+	duration *= _flags.isTalkie ? 8 : durationMultiplicator[(_configTextspeed / 10)];
+	return MAX<int>(duration, 120);
+}
+
+void KyraEngine_HoF::objectChat(const char *str, int object, int vocHigh, int vocLow) {
+	setNextIdleAnimTimer();
+
+	_chatVocHigh = _chatVocLow = -1;
+
+	objectChatInit(str, object, vocHigh, vocLow);
+	_chatText = str;
+	_chatObject = object;
+	int chatType = chatGetType(str);
+	if (chatType == -1) {
+		_chatIsNote = true;
+		chatType = 0;
+	}
+
+	if (_mainCharacter.facing > 7)
+		_mainCharacter.facing = 5;
+
+	static const uint8 talkScriptTable[] = {
+		6, 7, 8,
+		3, 4, 5,
+		3, 4, 5,
+		0, 1, 2,
+		0, 1, 2,
+		0, 1, 2,
+		3, 4, 5,
+		3, 4, 5
+	};
+
+	assert(_mainCharacter.facing * 3 + chatType < ARRAYSIZE(talkScriptTable));
+	int script = talkScriptTable[_mainCharacter.facing * 3 + chatType];
+
+	static const char *const chatScriptFilenames[] = {
+		"_Z1FSTMT.EMC",
+		"_Z1FQUES.EMC",
+		"_Z1FEXCL.EMC",
+		"_Z1SSTMT.EMC",
+		"_Z1SQUES.EMC",
+		"_Z1SEXCL.EMC",
+		"_Z1BSTMT.EMC",
+		"_Z1BQUES.EMC",
+		"_Z1BEXCL.EMC"
+	};
+
+	objectChatProcess(chatScriptFilenames[script]);
+	_chatIsNote = false;
+
+	_text->restoreScreen();
+
+	_mainCharacter.animFrame = _characterFrameTable[_mainCharacter.facing];
+	updateCharacterAnim(0);
+
+	_chatText = 0;
+	_chatObject = -1;
+
+	setNextIdleAnimTimer();
+}
+
+void KyraEngine_HoF::objectChatInit(const char *str, int object, int vocHigh, int vocLow) {
+	str = _text->preprocessString(str);
+	int lineNum = _text->buildMessageSubstrings(str);
+
+	int yPos = 0, xPos = 0;
+
+	if (!object) {
+		int scale = getScale(_mainCharacter.x1, _mainCharacter.y1);
+		yPos = _mainCharacter.y1 - ((_mainCharacter.height * scale) >> 8) - 8;
+		xPos = _mainCharacter.x1;
+	} else {
+		yPos = _talkObjectList[object].y;
+		xPos = _talkObjectList[object].x;
+	}
+
+	yPos -= lineNum * 10;
+	yPos = MAX(yPos, 0);
+	_text->_talkMessageY = yPos;
+	_text->_talkMessageH = lineNum*10;
+
+	int width = _text->getWidestLineWidth(lineNum);
+	_text->calcWidestLineBounds(xPos, yPos, width, xPos);
+	_text->_talkCoords.x = xPos;
+	_text->_talkCoords.w = width + 2;
+
+	restorePage3();
+	_text->backupTalkTextMessageBkgd(2, 2);
+
+	_chatTextEnabled = textEnabled();
+	if (_chatTextEnabled) {
+		objectChatPrintText(str, object);
+		_chatEndTime = _system->getMillis() + chatCalcDuration(str) * _tickLength;
+	} else {
+		_chatEndTime = _system->getMillis();
+	}
+
+	if (speechEnabled()) {
+		_chatVocHigh = vocHigh;
+		_chatVocLow = vocLow;
+	} else {
+		_chatVocHigh = _chatVocLow = -1;
+	}
+}
+
+void KyraEngine_HoF::objectChatPrintText(const char *str, int object) {
+	int c1 = _talkObjectList[object].color;
+	str = _text->preprocessString(str);
+	int lineNum = _text->buildMessageSubstrings(str);
+	int maxWidth = _text->getWidestLineWidth(lineNum);
+	int x = (object == 0) ? _mainCharacter.x1 : _talkObjectList[object].x;
+	int cX1 = 0, cX2 = 0;
+	_text->calcWidestLineBounds(cX1, cX2, maxWidth, x);
+
+	for (int i = 0; i < lineNum; ++i) {
+		str = &_text->_talkSubstrings[i*_text->maxSubstringLen()];
+
+		int y = _text->_talkMessageY + i * 10;
+		x = _text->getCenterStringX(str, cX1, cX2);
+
+		_text->printText(str, x, y, c1, 0xCF, 0);
+	}
+}
+
+void KyraEngine_HoF::objectChatProcess(const char *script) {
+	memset(&_chatScriptData, 0, sizeof(_chatScriptData));
+	memset(&_chatScriptState, 0, sizeof(_chatScriptState));
+
+	_emc->load(script, &_chatScriptData, &_opcodesAnimation);
+	_emc->init(&_chatScriptState, &_chatScriptData);
+	_emc->start(&_chatScriptState, 0);
+	while (_emc->isValid(&_chatScriptState))
+		_emc->run(&_chatScriptState);
+
+	_animShapeFilename[2] = _characterShapeFile + '0';
+	uint8 *shapeBuffer = _res->fileData(_animShapeFilename, 0);
+	if (shapeBuffer) {
+		int shapeCount = initAnimationShapes(shapeBuffer);
+
+		if (_chatVocHigh >= 0) {
+			playVoice(_chatVocHigh, _chatVocLow);
+			_chatVocHigh = _chatVocLow = -1;
+		}
+
+		objectChatWaitToFinish();
+
+		uninitAnimationShapes(shapeCount, shapeBuffer);
+	} else {
+		warning("couldn't load file '%s'", _animShapeFilename);
+	}
+
+	_emc->unload(&_chatScriptData);
+}
+
+void KyraEngine_HoF::objectChatWaitToFinish() {
+	int charAnimFrame = _mainCharacter.animFrame;
+	setCharacterAnimDim(_animShapeWidth, _animShapeHeight);
+
+	_emc->init(&_chatScriptState, &_chatScriptData);
+	_emc->start(&_chatScriptState, 1);
+
+	bool running = true;
+	const uint32 endTime = _chatEndTime;
+	resetSkipFlag();
+
+	while (running && !shouldQuit()) {
+		if (!_emc->isValid(&_chatScriptState))
+			_emc->start(&_chatScriptState, 1);
+
+		_animNeedUpdate = false;
+		while (!_animNeedUpdate && _emc->isValid(&_chatScriptState))
+			_emc->run(&_chatScriptState);
+
+		int curFrame = _animNewFrame;
+		uint32 delayTime = _animDelayTime;
+
+		if (!_chatIsNote)
+			_mainCharacter.animFrame = 33 + curFrame;
+
+		updateCharacterAnim(0);
+
+		uint32 nextFrame = _system->getMillis() + delayTime * _tickLength;
+
+		while (_system->getMillis() < nextFrame && !shouldQuit()) {
+			updateWithText();
+
+			const uint32 curTime = _system->getMillis();
+			if ((textEnabled() && curTime > endTime) || (speechEnabled() && !textEnabled() && !snd_voiceIsPlaying()) || skipFlag()) {
+				resetSkipFlag();
+				nextFrame = curTime;
+				running = false;
+			}
+
+			delay(10);
+		}
+	}
+
+	_mainCharacter.animFrame = charAnimFrame;
+	updateCharacterAnim(0);
+	resetCharacterAnimDim();
+}
+
+void KyraEngine_HoF::startDialogue(int dlgIndex) {
+	updateDlgBuffer();
+	int csEntry, vocH, unused1, unused2;
+	loadDlgHeader(csEntry, vocH, unused1, unused2);
+	int s = _conversationState[dlgIndex][csEntry];
+	uint8 bufferIndex = 8;
+
+	if (s == -1) {
+		bufferIndex += (dlgIndex * 6);
+		_conversationState[dlgIndex][csEntry] = 0;
+	} else if (!s || s == 2) {
+		bufferIndex += (dlgIndex * 6 + 2);
+		_conversationState[dlgIndex][csEntry] = 1;
+	} else {
+		bufferIndex += (dlgIndex * 6 + 4);
+		_conversationState[dlgIndex][csEntry] = 2;
+	}
+
+	int offs = READ_LE_UINT16(_dlgBuffer + bufferIndex);
+	processDialogue(offs, vocH, csEntry);
+}
+
+void KyraEngine_HoF::zanthSceneStartupChat() {
+	int lowest = _flags.isTalkie ? 6 : 5;
+	int tableIndex = _mainCharacter.sceneId - READ_LE_UINT16(&_ingameTalkObjIndex[lowest + _newChapterFile]);
+	if (queryGameFlag(0x159) || _newSceneDlgState[tableIndex])
+		return;
+
+	int csEntry, vocH, scIndex1, scIndex2;
+	updateDlgBuffer();
+	loadDlgHeader(csEntry, vocH, scIndex1, scIndex2);
+
+	uint8 bufferIndex = 8 + scIndex1 * 6 + scIndex2 * 4 + tableIndex * 2;
+	int offs = READ_LE_UINT16(_dlgBuffer + bufferIndex);
+	processDialogue(offs, vocH, csEntry);
+
+	_newSceneDlgState[tableIndex] = 1;
+}
+
+void KyraEngine_HoF::randomSceneChat() {
+	int lowest = _flags.isTalkie ? 6 : 5;
+	int tableIndex = (_mainCharacter.sceneId - READ_LE_UINT16(&_ingameTalkObjIndex[lowest + _newChapterFile])) << 2;
+	if (queryGameFlag(0x164))
+		return;
+
+	int csEntry, vocH, scIndex1, unused;
+	updateDlgBuffer();
+	loadDlgHeader(csEntry, vocH, scIndex1, unused);
+
+	if (_chatAltFlag) {
+		_chatAltFlag = 0;
+		tableIndex += 2;
+	} else {
+		_chatAltFlag = 1;
+	}
+
+	uint8 bufferIndex = 8 + scIndex1 * 6 + tableIndex;
+	int offs = READ_LE_UINT16(_dlgBuffer + bufferIndex);
+	processDialogue(offs, vocH, csEntry);
+}
+
+void KyraEngine_HoF::updateDlgBuffer() {
+	static const char suffixTalkie[] = "EFG";
+	static const char suffixTowns[] = "G  J";
+
+	if (_currentChapter == _npcTalkChpIndex && _mainCharacter.dlgIndex == _npcTalkDlgIndex)
+		return;
+
+	_npcTalkChpIndex = _currentChapter;
+	_npcTalkDlgIndex = _mainCharacter.dlgIndex;
+
+	Common::String filename = Common::String::format("CH%.02d-S%.02d.DL", _currentChapter, _npcTalkDlgIndex);
+
+	const char *suffix = _flags.isTalkie ? suffixTalkie : suffixTowns;
+	if (_flags.platform != Common::kPlatformDOS || _flags.isTalkie)
+		filename += suffix[_lang];
+	else
+		filename += 'G';
+
+	delete[] _dlgBuffer;
+	_dlgBuffer = _res->fileData(filename.c_str(), 0);
+}
+
+void KyraEngine_HoF::loadDlgHeader(int &csEntry, int &vocH, int &scIndex1, int &scIndex2) {
+	csEntry = READ_LE_UINT16(_dlgBuffer);
+	vocH = READ_LE_UINT16(_dlgBuffer + 2);
+	scIndex1 = READ_LE_UINT16(_dlgBuffer + 4);
+	scIndex2 = READ_LE_UINT16(_dlgBuffer + 6);
+}
+
+void KyraEngine_HoF::processDialogue(int dlgOffset, int vocH, int csEntry) {
+	int activeTimSequence = -1;
+	int nextTimSequence = -1;
+	int cmd = 0;
+	int vocHi = -1;
+	int vocLo = -1;
+	bool loop = true;
+	int offs = dlgOffset;
+
+	_screen->hideMouse();
+
+	while (loop) {
+		cmd = READ_LE_UINT16(_dlgBuffer + offs);
+		offs += 2;
+
+		nextTimSequence = READ_LE_UINT16(&_ingameTalkObjIndex[cmd]);
+
+		if (nextTimSequence == 10) {
+			if (queryGameFlag(0x3E))
+				nextTimSequence = 14;
+			if (queryGameFlag(0x3F))
+				nextTimSequence = 15;
+			if (queryGameFlag(0x40))
+				nextTimSequence = 16;
+		}
+
+		if (nextTimSequence == 27 && _mainCharacter.sceneId == 34)
+			nextTimSequence = 41;
+
+		if (queryGameFlag(0x72)) {
+			if (nextTimSequence == 18)
+				nextTimSequence = 43;
+			else if (nextTimSequence == 19)
+				nextTimSequence = 44;
+		}
+
+		if (_mainCharacter.x1 > 160) {
+			if (nextTimSequence == 4)
+				nextTimSequence = 46;
+			else if (nextTimSequence == 5)
+				nextTimSequence = 47;
+		}
+
+		if (cmd == 10) {
+			loop = false;
+
+		} else if (cmd == 4) {
+			csEntry = READ_LE_UINT16(_dlgBuffer + offs);
+			setDlgIndex(csEntry);
+			offs += 2;
+
+		} else {
+			if (!_flags.isTalkie || cmd == 11) {
+				int len = READ_LE_UINT16(_dlgBuffer + offs);
+				offs += 2;
+				if (_flags.isTalkie) {
+					vocLo = READ_LE_UINT16(_dlgBuffer + offs);
+					offs += 2;
+				}
+				memcpy(_unkBuf500Bytes, _dlgBuffer + offs, len);
+				_unkBuf500Bytes[len] = 0;
+				offs += len;
+				if (_flags.isTalkie)
+					continue;
+
+			} else if (_flags.isTalkie) {
+				int len = READ_LE_UINT16(_dlgBuffer + offs);
+				offs += 2;
+				static const int irnv[] = { 91, 105, 110, 114, 118 };
+				vocHi = irnv[vocH - 1] + csEntry;
+				vocLo = READ_LE_UINT16(_dlgBuffer + offs);
+				offs += 2;
+				memcpy(_unkBuf500Bytes, _dlgBuffer + offs, len);
+				_unkBuf500Bytes[len] = 0;
+				offs += len;
+			}
+
+			if (_unkBuf500Bytes[0]) {
+				if ((!_flags.isTalkie && cmd == 11) || (_flags.isTalkie && cmd == 12)) {
+					if (activeTimSequence > -1) {
+						deinitTalkObject(activeTimSequence);
+						activeTimSequence = -1;
+					}
+					objectChat((const char *)_unkBuf500Bytes, 0, vocHi, vocLo);
+				} else {
+					if (activeTimSequence != nextTimSequence) {
+						if (activeTimSequence > -1) {
+							deinitTalkObject(activeTimSequence);
+							activeTimSequence = -1;
+						}
+						initTalkObject(nextTimSequence);
+						activeTimSequence = nextTimSequence;
+					}
+					npcChatSequence((const char *)_unkBuf500Bytes, nextTimSequence, vocHi, vocLo);
+				}
+			}
+		}
+	}
+
+	if (activeTimSequence > -1)
+		deinitTalkObject(activeTimSequence);
+
+	_screen->showMouse();
+}
+
+void KyraEngine_HoF::initTalkObject(int index) {
+	TalkObject &object = _talkObjectList[index];
+
+	char STAFilename[13];
+	char ENDFilename[13];
+
+	strcpy(STAFilename, object.filename);
+	strcpy(_TLKFilename, object.filename);
+	strcpy(ENDFilename, object.filename);
+
+	strcat(STAFilename + 4, "_STA.TIM");
+	strcat(_TLKFilename + 4, "_TLK.TIM");
+	strcat(ENDFilename + 4, "_END.TIM");
+
+	_currentTalkSections.STATim = _tim->load(STAFilename, &_timOpcodes);
+	_currentTalkSections.TLKTim = _tim->load(_TLKFilename, &_timOpcodes);
+	_currentTalkSections.ENDTim = _tim->load(ENDFilename, &_timOpcodes);
+
+	if (object.scriptId != -1) {
+		_specialSceneScriptStateBackup[object.scriptId] = _specialSceneScriptState[object.scriptId];
+		_specialSceneScriptState[object.scriptId] = 1;
+	}
+
+	if (_currentTalkSections.STATim) {
+		_tim->resetFinishedFlag();
+		while (!shouldQuit() && !_tim->finished()) {
+			_tim->exec(_currentTalkSections.STATim, false);
+			if (_chatText)
+				updateWithText();
+			else
+				update();
+			delay(10);
+		}
+	}
+}
+
+void KyraEngine_HoF::deinitTalkObject(int index) {
+	TalkObject &object = _talkObjectList[index];
+
+	if (_currentTalkSections.ENDTim) {
+		_tim->resetFinishedFlag();
+		while (!shouldQuit() && !_tim->finished()) {
+			_tim->exec(_currentTalkSections.ENDTim, false);
+			if (_chatText)
+				updateWithText();
+			else
+				update();
+			delay(10);
+		}
+	}
+
+	if (object.scriptId != -1)
+		_specialSceneScriptState[object.scriptId] = _specialSceneScriptStateBackup[object.scriptId];
+
+	_tim->unload(_currentTalkSections.STATim);
+	_tim->unload(_currentTalkSections.TLKTim);
+	_tim->unload(_currentTalkSections.ENDTim);
+}
+
+void KyraEngine_HoF::npcChatSequence(const char *str, int objectId, int vocHigh, int vocLow) {
+	_chatText = str;
+	_chatObject = objectId;
+	objectChatInit(str, objectId, vocHigh, vocLow);
+
+	if (!_currentTalkSections.TLKTim)
+		_currentTalkSections.TLKTim = _tim->load(_TLKFilename, &_timOpcodes);
+
+	setNextIdleAnimTimer();
+
+	uint32 ct = chatCalcDuration(str);
+	uint32 time = _system->getMillis();
+	_chatEndTime =  time + (3 + ct) * _tickLength;
+	uint32 chatAnimEndTime = time + (3 + (ct >> 1)) * _tickLength;
+
+	if (_chatVocHigh >= 0) {
+		playVoice(_chatVocHigh, _chatVocLow);
+		_chatVocHigh = _chatVocLow = -1;
+	}
+
+	while (((textEnabled() && _chatEndTime > _system->getMillis()) || (speechEnabled() && snd_voiceIsPlaying())) && !(shouldQuit() || skipFlag())) {
+		if ((!speechEnabled() && chatAnimEndTime > _system->getMillis()) || (speechEnabled() && snd_voiceIsPlaying())) {
+			_tim->resetFinishedFlag();
+			while (!_tim->finished() && !skipFlag() && !shouldQuit()) {
+				if (_currentTalkSections.TLKTim)
+					_tim->exec(_currentTalkSections.TLKTim, false);
+				else
+					_tim->resetFinishedFlag();
+
+				updateWithText();
+				delay(10);
+			}
+
+			if (_currentTalkSections.TLKTim)
+				_tim->stopCurFunc();
+		}
+		updateWithText();
+	}
+
+	resetSkipFlag();
+
+	_tim->unload(_currentTalkSections.TLKTim);
+
+	_text->restoreScreen();
+	_chatText = 0;
+	_chatObject = -1;
+	setNextIdleAnimTimer();
+}
+
+void KyraEngine_HoF::setDlgIndex(int dlgIndex) {
+	if (dlgIndex == _mainCharacter.dlgIndex)
+		return;
+	memset(_newSceneDlgState, 0, 32);
+	for (int i = 0; i < 19; i++)
+		memset(_conversationState[i], -1, 14);
+	_chatAltFlag = false;
+	_mainCharacter.dlgIndex = dlgIndex;
+}
+
+} // End of namespace Kyra
diff --git a/engines/kyra/text/text_hof.h b/engines/kyra/text/text_hof.h
new file mode 100644
index 0000000000..cced5bf536
--- /dev/null
+++ b/engines/kyra/text/text_hof.h
@@ -0,0 +1,52 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef KYRA_TEXT_HOF_H
+#define KYRA_TEXT_HOF_H
+
+#include "kyra/text/text.h"
+
+namespace Kyra {
+
+class Screen_v2;
+class KyraEngine_HoF;
+
+class TextDisplayer_HoF : public TextDisplayer {
+friend class KyraEngine_HoF;
+public:
+	TextDisplayer_HoF(KyraEngine_HoF *vm, Screen_v2 *screen);
+
+	void backupTalkTextMessageBkgd(int srcPage, int dstPage);
+	void restoreTalkTextMessageBkgd(int srcPage, int dstPage);
+	void restoreScreen();
+
+	void printCustomCharacterText(const char *src, int x, int y, uint8 c1, int srcPage, int dstPage);
+
+	char *preprocessString(const char *str);
+	void calcWidestLineBounds(int &x1, int &x2, int w, int x);
+private:
+	KyraEngine_HoF *_vm;
+};
+
+} // End of namespace Kyra
+
+#endif
diff --git a/engines/kyra/text/text_lok.cpp b/engines/kyra/text/text_lok.cpp
new file mode 100644
index 0000000000..c45f0410e3
--- /dev/null
+++ b/engines/kyra/text/text_lok.cpp
@@ -0,0 +1,396 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "kyra/text/text.h"
+#include "kyra/engine/kyra_lok.h"
+#include "kyra/graphics/animator_lok.h"
+#include "kyra/engine/sprites.h"
+#include "kyra/engine/timer.h"
+
+#include "common/system.h"
+
+namespace Kyra {
+
+void KyraEngine_LoK::waitForChatToFinish(int vocFile, int16 chatDuration, const char *chatStr, uint8 charNum, const bool printText) {
+	bool hasUpdatedNPCs = false;
+	bool runLoop = true;
+	uint8 currPage;
+
+	uint32 timeToEnd = strlen(chatStr) * 8 * _tickLength + _system->getMillis();
+
+	if (textEnabled() && !speechEnabled() && chatDuration != -1) {
+		switch (_configTextspeed) {
+		case 0:
+			chatDuration *= 2;
+			break;
+		case 2:
+			chatDuration /= 4;
+			break;
+		case 3:
+			chatDuration = -1;
+			break;
+		}
+	}
+
+	if (chatDuration != -1)
+		chatDuration *= _tickLength;
+
+	if (vocFile != -1)
+		snd_playVoiceFile(vocFile);
+
+	_timer->disable(14);
+	_timer->disable(18);
+	_timer->disable(19);
+
+	uint32 timeAtStart = _system->getMillis();
+	uint32 loopStart;
+	while (runLoop) {
+		loopStart = _system->getMillis();
+		if (_currentCharacter->sceneId == 210)
+			if (seq_playEnd())
+				break;
+
+		if (_system->getMillis() > timeToEnd && !hasUpdatedNPCs) {
+			hasUpdatedNPCs = true;
+			_timer->disable(15);
+			_currHeadShape = 4;
+			_animator->animRefreshNPC(0);
+			_animator->animRefreshNPC(_talkingCharNum);
+
+			if (_charSayUnk2 != -1) {
+				_animator->sprites()[_charSayUnk2].active = 0;
+				_sprites->_anims[_charSayUnk2].play = false;
+				_charSayUnk2 = -1;
+			}
+		}
+
+		_timer->update();
+		_sprites->updateSceneAnims();
+		_animator->restoreAllObjectBackgrounds();
+		_animator->preserveAnyChangedBackgrounds();
+		_animator->prepDrawAllObjects();
+
+		if (printText) {
+			currPage = _screen->_curPage;
+			_screen->_curPage = 2;
+			_text->printCharacterText(chatStr, charNum, _characterList[charNum].x1);
+			_screen->_curPage = currPage;
+		}
+
+		_animator->copyChangedObjectsForward(0);
+		updateTextFade();
+
+		if (((chatDuration < (int16)(_system->getMillis() - timeAtStart)) && chatDuration != -1 && printText) || (!printText && !snd_voiceIsPlaying()))
+			break;
+
+		uint32 nextTime = loopStart + _tickLength;
+
+		while (_system->getMillis() < nextTime) {
+			updateInput();
+
+			if (skipFlag()) {
+				runLoop = false;
+				break;
+			}
+
+			if (nextTime - _system->getMillis() >= 10) {
+				_system->delayMillis(10);
+				_system->updateScreen();
+			}
+		}
+	}
+
+	if (skipFlag()) {
+		resetSkipFlag();
+		snd_stopVoice();
+	}
+
+	_timer->enable(14);
+	_timer->enable(15);
+	_timer->enable(18);
+	_timer->enable(19);
+}
+
+void KyraEngine_LoK::endCharacterChat(int8 charNum, int16 convoInitialized) {
+	_charSayUnk3 = -1;
+
+	if (charNum > 4 && charNum < 11) {
+		_animator->sprites()[_disabledTalkAnimObject].active = 1;
+		_sprites->_anims[_disabledTalkAnimObject].play = true;
+
+		_animator->sprites()[_enabledTalkAnimObject].active = 0;
+		_sprites->_anims[_enabledTalkAnimObject].play = false;
+	}
+
+	if (convoInitialized != 0) {
+		_talkingCharNum = -1;
+		if (_currentCharacter->currentAnimFrame != 88)
+			_currentCharacter->currentAnimFrame = 7;
+		_animator->animRefreshNPC(0);
+		_animator->updateAllObjectShapes();
+	}
+}
+
+void KyraEngine_LoK::restoreChatPartnerAnimFrame(int8 charNum) {
+	_talkingCharNum = -1;
+
+	if (charNum > 0 && charNum < 5) {
+		_characterList[charNum].currentAnimFrame = _currentChatPartnerBackupFrame;
+		_animator->animRefreshNPC(charNum);
+	}
+
+	if (_currentCharacter->currentAnimFrame != 88)
+		_currentCharacter->currentAnimFrame = 7;
+
+	_animator->animRefreshNPC(0);
+	_animator->updateAllObjectShapes();
+}
+
+void KyraEngine_LoK::backupChatPartnerAnimFrame(int8 charNum) {
+	_talkingCharNum = 0;
+
+	if (charNum < 5 && charNum > 0)
+		_currentChatPartnerBackupFrame = _characterList[charNum].currentAnimFrame;
+
+	if (_currentCharacter->currentAnimFrame != 88) {
+		_currentCharacter->currentAnimFrame = 16;
+		if (_scaleMode != 0)
+			_currentCharacter->currentAnimFrame = 7;
+	}
+
+	_animator->animRefreshNPC(0);
+	_animator->updateAllObjectShapes();
+}
+
+int8 KyraEngine_LoK::getChatPartnerNum() {
+	uint8 sceneTable[] = {0x2, 0x5, 0x2D, 0x7, 0x1B, 0x8, 0x22, 0x9, 0x30, 0x0A};
+	int pos = 0;
+	int partner = -1;
+
+	for (int i = 1; i < 6; i++) {
+		if (_currentCharacter->sceneId == sceneTable[pos]) {
+			partner = sceneTable[pos + 1];
+			break;
+		}
+		pos += 2;
+	}
+
+	for (int i = 1; i < 5; i++) {
+		if (_characterList[i].sceneId == _currentCharacter->sceneId) {
+			partner = i;
+			break;
+		}
+	}
+	return partner;
+}
+
+int KyraEngine_LoK::initCharacterChat(int8 charNum) {
+	int returnValue = 0;
+
+	if (_talkingCharNum == -1) {
+		returnValue = 1;
+		_talkingCharNum = 0;
+
+		if (_currentCharacter->currentAnimFrame != 88) {
+			_currentCharacter->currentAnimFrame = 16;
+			if (_scaleMode != 0)
+				_currentCharacter->currentAnimFrame = 7;
+		}
+
+		_animator->animRefreshNPC(0);
+		_animator->updateAllObjectShapes();
+	}
+
+	_charSayUnk2 = -1;
+	_animator->flagAllObjectsForBkgdChange();
+	_animator->restoreAllObjectBackgrounds();
+
+	if (charNum > 4 && charNum < 11) {
+		const uint8 animDisableTable[] = { 3, 1, 1, 5, 0, 6 };
+		const uint8 animEnableTable[] = { 4, 2, 5, 6, 1, 7 };
+
+		_disabledTalkAnimObject = animDisableTable[charNum - 5];
+		_enabledTalkAnimObject = animEnableTable[charNum - 5];
+
+		_animator->sprites()[_disabledTalkAnimObject].active = 0;
+		_sprites->_anims[_disabledTalkAnimObject].play = false;
+
+		_animator->sprites()[_enabledTalkAnimObject].active = 1;
+		_sprites->_anims[_enabledTalkAnimObject].play = true;
+
+		_charSayUnk2 = _enabledTalkAnimObject;
+	}
+
+	_animator->flagAllObjectsForRefresh();
+	_animator->flagAllObjectsForBkgdChange();
+	_animator->preserveAnyChangedBackgrounds();
+	_charSayUnk3 = charNum;
+
+	return returnValue;
+}
+
+void KyraEngine_LoK::characterSays(int vocFile, const char *chatStr, int8 charNum, int8 chatDuration) {
+	uint8 startAnimFrames[] =  { 0x10, 0x32, 0x56, 0x0, 0x0, 0x0 };
+
+	uint16 chatTicks;
+	int16 convoInitialized;
+	int8 chatPartnerNum;
+
+	if (_currentCharacter->sceneId == 210)
+		return;
+
+	snd_voiceWaitForFinish(true);
+
+	convoInitialized = initCharacterChat(charNum);
+	chatPartnerNum = getChatPartnerNum();
+
+	if (chatPartnerNum >= 0 && chatPartnerNum < 5)
+		backupChatPartnerAnimFrame(chatPartnerNum);
+
+	if (charNum < 5) {
+		_characterList[charNum].currentAnimFrame = startAnimFrames[charNum];
+		_charSayUnk3 = charNum;
+		_talkingCharNum = charNum;
+		_animator->animRefreshNPC(charNum);
+	}
+
+	char *processedString = _text->preprocessString(chatStr);
+	int lineNum = _text->buildMessageSubstrings(processedString);
+
+	int16 yPos = _characterList[charNum].y1;
+	yPos -= ((_scaleTable[yPos] * _characterList[charNum].height) >> 8);
+	yPos -= 8;
+	yPos -= lineNum * 10;
+
+	if (yPos < 11)
+		yPos = 11;
+
+	if (yPos > 100)
+		yPos = 100;
+
+	_text->_talkMessageY = yPos;
+	_text->_talkMessageH = lineNum * 10;
+
+	const bool printText = textEnabled();
+
+	if (printText) {
+		_animator->restoreAllObjectBackgrounds();
+
+		_screen->copyRegion(12, _text->_talkMessageY, 12, 136, 296, _text->_talkMessageH, 2, 2);
+
+		_text->printCharacterText(processedString, charNum, _characterList[charNum].x1);
+	}
+
+	if (chatDuration == -2)
+		chatTicks = strlen(processedString) * 9;
+	else
+		chatTicks = chatDuration;
+
+	if (!speechEnabled())
+		vocFile = -1;
+	waitForChatToFinish(vocFile, chatTicks, chatStr, charNum, printText);
+
+	if (printText) {
+		_animator->restoreAllObjectBackgrounds();
+
+		_screen->copyRegion(12, 136, 12, _text->_talkMessageY, 296, _text->_talkMessageH, 2, 2);
+		_animator->preserveAllBackgrounds();
+		_animator->prepDrawAllObjects();
+
+		_screen->copyRegion(12, _text->_talkMessageY, 12, _text->_talkMessageY, 296, _text->_talkMessageH, 2, 0);
+		_animator->flagAllObjectsForRefresh();
+		_animator->copyChangedObjectsForward(0);
+	}
+
+	if (chatPartnerNum != -1 && chatPartnerNum < 5)
+		restoreChatPartnerAnimFrame(chatPartnerNum);
+
+	endCharacterChat(charNum, convoInitialized);
+}
+
+void KyraEngine_LoK::drawSentenceCommand(const char *sentence, int color) {
+	_screen->fillRect(8, 143, 311, 152, _flags.platform == Common::kPlatformAmiga ? 19 : 12);
+
+	if (_flags.platform == Common::kPlatformAmiga) {
+		if (color != 19) {
+			_currSentenceColor[0] = 0x3F;
+			_currSentenceColor[1] = 0x3F;
+			_currSentenceColor[2] = 0x3F;
+
+			_screen->setInterfacePalette(_screen->getPalette(1),
+			                             _currSentenceColor[0], _currSentenceColor[1], _currSentenceColor[2]);
+		}
+	} else if (_startSentencePalIndex != color || _fadeText != false) {
+		_currSentenceColor[0] = _screen->getPalette(0)[765] = _screen->getPalette(0)[color * 3 + 0];
+		_currSentenceColor[1] = _screen->getPalette(0)[766] = _screen->getPalette(0)[color * 3 + 1];
+		_currSentenceColor[2] = _screen->getPalette(0)[767] = _screen->getPalette(0)[color * 3 + 2];
+
+		_screen->setScreenPalette(_screen->getPalette(0));
+		_startSentencePalIndex = color;
+	}
+
+	_text->printText(sentence, 8, 143, 0xFF, _flags.platform == Common::kPlatformAmiga ? 19 : 12, 0);
+	setTextFadeTimerCountdown(15);
+	_fadeText = false;
+}
+
+void KyraEngine_LoK::updateSentenceCommand(const char *str1, const char *str2, int color) {
+	char sentenceCommand[500];
+	Common::strlcpy(sentenceCommand, str1, sizeof(sentenceCommand));
+	if (str2)
+		Common::strlcat(sentenceCommand, str2, sizeof(sentenceCommand));
+
+	drawSentenceCommand(sentenceCommand, color);
+	_screen->updateScreen();
+}
+
+void KyraEngine_LoK::updateTextFade() {
+	if (!_fadeText)
+		return;
+
+	bool finished = false;
+	for (int i = 0; i < 3; i++) {
+		if (_currSentenceColor[i] > 4)
+			_currSentenceColor[i] -= 4;
+		else if (_currSentenceColor[i]) {
+			_currSentenceColor[i] = 0;
+			finished = true;
+		}
+	}
+
+	if (_flags.platform == Common::kPlatformAmiga) {
+		_screen->setInterfacePalette(_screen->getPalette(1),
+		                             _currSentenceColor[0], _currSentenceColor[1], _currSentenceColor[2]);
+	} else {
+		_screen->getPalette(0)[765] = _currSentenceColor[0];
+		_screen->getPalette(0)[766] = _currSentenceColor[1];
+		_screen->getPalette(0)[767] = _currSentenceColor[2];
+		_screen->setScreenPalette(_screen->getPalette(0));
+	}
+
+	if (finished) {
+		_fadeText = false;
+		_startSentencePalIndex = -1;
+	}
+}
+
+} // End of namespace Kyra
diff --git a/engines/kyra/text/text_lol.cpp b/engines/kyra/text/text_lol.cpp
new file mode 100644
index 0000000000..7c724e3b8e
--- /dev/null
+++ b/engines/kyra/text/text_lol.cpp
@@ -0,0 +1,348 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifdef ENABLE_LOL
+
+#include "kyra/text/text_lol.h"
+#include "kyra/engine/lol.h"
+#include "kyra/graphics/screen_lol.h"
+#include "kyra/engine/timer.h"
+#include "kyra/sound/sound.h"
+
+#include "common/system.h"
+
+namespace Kyra {
+
+TextDisplayer_LoL::TextDisplayer_LoL(LoLEngine *engine, Screen_LoL *screenLoL) : TextDisplayer_rpg(engine, screenLoL),
+	_vm(engine), _screen(screenLoL), _scriptTextParameter(0) {
+
+	memset(_stringParameters, 0, 15 * sizeof(char *));
+	_buffer = new char[600];
+	memset(_buffer, 0, 600);
+
+	_waitButtonSpace = 0;
+}
+
+TextDisplayer_LoL::~TextDisplayer_LoL() {
+	delete[] _buffer;
+}
+
+void TextDisplayer_LoL::setupField(bool mode) {
+	if (_vm->textEnabled()) {
+
+		int y = 142;
+		int h = 37;
+		int stepY = 3;
+		int stepH = 1;
+
+		if (_vm->gameFlags().use16ColorMode) {
+			y = 140;
+			h = 39;
+			stepY = 4;
+			stepH = 2;
+		}
+
+		if (mode) {
+			_screen->copyRegionToBuffer(3, 0, 0, 320, 40, _vm->_pageBuffer1);
+			_screen->copyRegion(80, y, 0, 0, 240, h, 0, 3, Screen::CR_NO_P_CHECK);
+			_screen->copyRegionToBuffer(3, 0, 0, 320, 40, _vm->_pageBuffer2);
+			_screen->copyBlockToPage(3, 0, 0, 320, 40, _vm->_pageBuffer1);
+		} else {
+			_screen->setScreenDim(clearDim(4));
+			int cp = _screen->setCurPage(2);
+			_screen->copyRegionToBuffer(3, 0, 0, 320, 40, _vm->_pageBuffer1);
+			_screen->copyBlockToPage(3, 0, 0, 320, 40, _vm->_pageBuffer2);
+			_screen->copyRegion(0, 0, 80, y, 240, h, 3, _screen->_curPage, Screen::CR_NO_P_CHECK);
+
+			for (int i = 177; i > 141; i--) {
+				uint32 endTime = _vm->_system->getMillis() + _vm->_tickLength;
+				_screen->copyRegion(83, i - stepH + 1, 83, i - stepH, 235, stepY, 0, 0, Screen::CR_NO_P_CHECK);
+				_screen->copyRegion(83, i + 1, 83, i + 1, 235, 1, 2, 0, Screen::CR_NO_P_CHECK);
+				_vm->updateInput();
+				_screen->updateScreen();
+				_vm->delayUntil(endTime);
+			}
+
+			_screen->copyBlockToPage(3, 0, 0, 320, 200, _vm->_pageBuffer1);
+			_screen->setCurPage(cp);
+
+			_vm->_updateFlags &= 0xFFFD;
+		}
+	} else {
+		if (!mode)
+			_screen->setScreenDim(clearDim(4));
+		_vm->toggleSelectedCharacterFrame(1);
+	}
+}
+
+void TextDisplayer_LoL::expandField() {
+	uint8 *tmp = _vm->_pageBuffer1 + 13000;
+
+	if (_vm->textEnabled()) {
+		_vm->_fadeText = false;
+		_vm->_textColorFlag = 0;
+		_vm->_timer->disable(11);
+		_screen->setScreenDim(clearDim(3));
+		_screen->copyRegionToBuffer(3, 0, 0, 320, 10, tmp);
+
+		int y = 140;
+		int h = 3;
+		int stepH = 0;
+
+		if (_vm->gameFlags().use16ColorMode) {
+			y = 139;
+			h = 4;
+			stepH = 1;
+		}
+
+		_screen->copyRegion(83, y, 0, 0, 235, h, 0, 2, Screen::CR_NO_P_CHECK);
+
+		for (int i = 140; i < 177; i++) {
+			uint32 endTime = _vm->_system->getMillis() + _vm->_tickLength;
+			_screen->copyRegion(0, 0, 83, i - stepH, 235, h, 2, 0, Screen::CR_NO_P_CHECK);
+			_vm->updateInput();
+			_screen->updateScreen();
+			_vm->delayUntil(endTime);
+		}
+
+		_screen->copyBlockToPage(3, 0, 0, 320, 10, tmp);
+		_vm->_updateFlags |= 2;
+
+	} else {
+		clearDim(3);
+		_vm->toggleSelectedCharacterFrame(0);
+	}
+}
+
+void TextDisplayer_LoL::printDialogueText(int dim, char *str, EMCState *script, const uint16 *paramList, int16 paramIndex) {
+	int oldDim = 0;
+
+	if (dim == 3) {
+		if (_vm->_updateFlags & 2) {
+			oldDim = clearDim(4);
+			_textDimData[4].color1 = _vm->gameFlags().use16ColorMode ? 0x33 : 254;
+			_textDimData[4].color2 = _screen->_curDim->unkA;
+		} else {
+			oldDim = clearDim(3);
+			_textDimData[3].color1 = _vm->gameFlags().use16ColorMode ? 0x33 : 192;
+			_textDimData[3].color2 = _screen->_curDim->unkA;
+			if (!_vm->gameFlags().use16ColorMode)
+				_screen->copyColor(192, 254);
+			_vm->enableTimer(11);
+			_vm->_textColorFlag = 0;
+			_vm->_fadeText = false;
+		}
+	} else {
+		oldDim = _screen->curDimIndex();
+		_screen->setScreenDim(dim);
+		_lineCount = 0;
+		_textDimData[dim].color1 = _vm->gameFlags().use16ColorMode ? 0x33 : 254;
+		_textDimData[dim].color2 = _screen->_curDim->unkA;
+	}
+
+	int cp = _screen->setCurPage(0);
+	Screen::FontId of = _screen->setFont((_vm->gameFlags().lang == Common::JA_JPN && _vm->gameFlags().use16ColorMode) ? Screen::FID_SJIS_FNT : Screen::FID_9_FNT);
+
+	preprocessString(str, script, paramList, paramIndex);
+	_numCharsTotal = strlen(_dialogueBuffer);
+	displayText(_dialogueBuffer);
+
+	_screen->setScreenDim(oldDim);
+	_screen->setCurPage(cp);
+	_screen->setFont(of);
+	_lineCount = 0;
+	_vm->_fadeText = false;
+}
+
+void TextDisplayer_LoL::printMessage(uint16 type, const char *str, ...) {
+	static const uint8 textColors256[] = { 0xFE, 0xA2, 0x84, 0x97, 0x9F };
+	static const uint8 textColors16[] = { 0x33, 0xAA, 0x88, 0x55, 0x99 };
+	static const uint8 soundEffect[] = { 0x0B, 0x00, 0x2B, 0x1B, 0x00 };
+
+	const uint8 *textColors = _vm->gameFlags().use16ColorMode ? textColors16 : textColors256;
+
+	if (type & 4)
+		type ^= 4;
+	else
+		_vm->stopPortraitSpeechAnim();
+
+	uint16 col = textColors[type & 0x7FFF];
+
+	int od = _screen->curDimIndex();
+
+	if (_vm->_updateFlags & 2) {
+		clearDim(4);
+		_textDimData[4].color1 = col;
+	} else {
+		clearDim(3);
+		if (_vm->gameFlags().use16ColorMode) {
+			_textDimData[3].color1 = col;
+		} else {
+			_screen->copyColor(192, col);
+			_textDimData[3].color1 = 192;
+		}
+		_vm->enableTimer(11);
+	}
+
+	va_list args;
+	va_start(args, str);
+
+	vsnprintf((char *)_buffer, 240, str, args);
+
+	va_end(args);
+
+	displayText(_buffer);
+
+	_screen->setScreenDim(od);
+	_lineCount = 0;
+
+	if (!(type & 0x8000)) {
+		if (soundEffect[type])
+			_vm->sound()->playSoundEffect(soundEffect[type]);
+	}
+
+	_vm->_textColorFlag = type & 0x7FFF;
+	_vm->_fadeText = false;
+}
+
+void TextDisplayer_LoL::preprocessString(char *str, EMCState *script, const uint16 *paramList, int16 paramIndex) {
+	char *dst = _dialogueBuffer;
+
+	for (char *s = str; *s;) {
+		if (_vm->gameFlags().lang == Common::JA_JPN) {
+			uint8 c = *s;
+			if (c >= 0xE0 || (c > 0x80 && c < 0xA0)) {
+				*dst++ = *s++;
+				*dst++ = *s++;
+				continue;
+			}
+		}
+
+		if (*s != '%') {
+			*dst++ = *s++;
+			continue;
+		}
+
+		char para = *++s;
+		bool eos = false;
+
+		switch (para) {
+		case '\0':
+			eos = true;
+			break;
+		case '#':
+			para = *++s;
+			switch (para) {
+			case 'E':
+			case 'G':
+			case 'X':
+			case 'c':
+			case 'd':
+			case 'e':
+			case 'f':
+			case 'g':
+			case 's':
+			case 'u':
+			case 'x':
+				break;
+			default:
+				eos = true;
+			}
+			break;
+		case ' ':
+		case '+':
+		case '-':
+			++s;
+		default:
+			break;
+		}
+
+		if (eos)
+			continue;
+
+		para = *s;
+
+		switch (para) {
+		case '\0':
+			eos = true;
+			break;
+		case '0':
+			++s;
+			break;
+		default:
+			while (para && para > 47 && para < 58)
+				para = *++s;
+			break;
+		}
+		if (eos)
+			continue;
+
+		para = *s++;
+
+		switch (para) {
+		case 'a':
+			strcpy(dst, Common::String::format("%d", _scriptTextParameter).c_str());
+			dst += strlen(dst);
+			break;
+
+		case 'n':
+			strcpy(dst, _vm->_characters[script ? script->stack[script->sp + paramIndex] : paramList[paramIndex]].name);
+			dst += strlen(dst);
+			break;
+
+		case 's':
+			strcpy(dst, _vm->getLangString(script ? script->stack[script->sp + paramIndex] : paramList[paramIndex]));
+			dst += strlen(dst);
+			break;
+
+		case 'X':
+		case 'd':
+		case 'u':
+		case 'x':
+			strcpy(dst, Common::String::format("%d", script ? script->stack[script->sp + paramIndex] : paramList[paramIndex]).c_str());
+			dst += strlen(dst);
+			break;
+
+		case '\0':
+		default:
+			continue;
+		}
+	}
+	*dst = 0;
+}
+
+KyraRpgEngine *TextDisplayer_LoL::vm() {
+	return _vm;
+}
+
+Screen *TextDisplayer_LoL::screen() {
+	return _screen;
+}
+
+void TextDisplayer_LoL::textPageBreak() {
+	strcpy(_pageBreakString, _vm->getLangString(0x4073));
+	TextDisplayer_rpg::textPageBreak();
+}
+
+} // End of namespace Kyra
+
+#endif // ENABLE_LOL
diff --git a/engines/kyra/text/text_lol.h b/engines/kyra/text/text_lol.h
new file mode 100644
index 0000000000..00428971ca
--- /dev/null
+++ b/engines/kyra/text/text_lol.h
@@ -0,0 +1,70 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef KYRA_TEXT_LOL_H
+#define KYRA_TEXT_LOL_H
+
+#if defined(ENABLE_EOB) || defined(ENABLE_LOL)
+#include "kyra/text/text_rpg.h"
+#endif
+#include "common/scummsys.h"
+
+#ifdef ENABLE_LOL
+
+namespace Kyra {
+
+class Screen_LoL;
+class LoLEngine;
+struct EMCState;
+
+class TextDisplayer_LoL : public TextDisplayer_rpg {
+public:
+	TextDisplayer_LoL(LoLEngine *engine, Screen_LoL *screenLoL);
+	~TextDisplayer_LoL();
+
+	void setupField(bool mode);
+	void expandField();
+
+	void printDialogueText(int dim, char *str, EMCState *script, const uint16 *paramList, int16 paramIndex);
+	void printMessage(uint16 type, const char *str, ...) GCC_PRINTF(3, 4);
+
+	int16 _scriptTextParameter;
+
+private:
+	virtual KyraRpgEngine *vm();
+	virtual Screen *screen();
+
+	void preprocessString(char *str, EMCState *script, const uint16 *paramList, int16 paramIndex);
+	void textPageBreak();
+
+	char *_stringParameters[15];
+	char *_buffer;
+
+	LoLEngine *_vm;
+	Screen_LoL *_screen;
+};
+
+} // End of namespace Kyra
+
+#endif // ENABLE_LOL
+
+#endif
diff --git a/engines/kyra/text/text_mr.cpp b/engines/kyra/text/text_mr.cpp
new file mode 100644
index 0000000000..8400700503
--- /dev/null
+++ b/engines/kyra/text/text_mr.cpp
@@ -0,0 +1,894 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "kyra/text/text_mr.h"
+#include "kyra/resource/resource.h"
+
+#include "common/system.h"
+
+namespace Kyra {
+
+TextDisplayer_MR::TextDisplayer_MR(KyraEngine_MR *vm, Screen_MR *screen)
+	: TextDisplayer(vm, screen), _vm(vm), _screen(screen) {
+}
+
+char *TextDisplayer_MR::preprocessString(const char *str) {
+	if (_talkBuffer != str) {
+		assert(strlen(str) < sizeof(_talkBuffer) - 1);
+		strcpy(_talkBuffer, str);
+	}
+
+	char *p = _talkBuffer;
+	while (*p) {
+		if (*p++ == '\r')
+			return _talkBuffer;
+	}
+
+	p = _talkBuffer;
+	Screen::FontId curFont = _screen->setFont(Screen::FID_8_FNT);
+	_screen->_charWidth = -2;
+
+	const int maxTextWidth = (_vm->language() == 0) ? 176 : 240;
+	int textWidth = _screen->getTextWidth(p);
+
+	if (textWidth > maxTextWidth) {
+		int count = 0, offs = 0;
+		if (textWidth > (3*maxTextWidth)) {
+			count = getCharLength(p, textWidth/4);
+			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, count, getCharLength(p, maxTextWidth));
+			p += count + offs;
+			textWidth = _screen->getTextWidth(p);
+		}
+
+		count = getCharLength(p, textWidth/2);
+		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, count, getCharLength(p, maxTextWidth));
+		}
+	}
+
+	_screen->setFont(curFont);
+	return _talkBuffer;
+}
+
+int TextDisplayer_MR::dropCRIntoString(char *str, int minOffs, int maxOffs) {
+	int offset = 0;
+	char *proc = str + minOffs;
+
+	for (int i = minOffs; i < maxOffs; ++i) {
+		if (*proc == ' ') {
+			*proc = '\r';
+			return offset;
+		} else if (*proc == '-') {
+			memmove(proc+1, proc, strlen(proc)+1);
+			*(++proc) = '\r';
+			++offset;
+			return offset;
+		}
+
+		++offset;
+		++proc;
+
+		if (!*proc)
+			return 0;
+	}
+
+	offset = 0;
+	proc = str + minOffs;
+	for (int i = minOffs; i >= 0; --i) {
+		if (*proc == ' ') {
+			*proc = '\r';
+			return offset;
+		} else if (*proc == '-') {
+			memmove(proc+1, proc, strlen(proc)+1);
+			*(++proc) = '\r';
+			++offset;
+			return offset;
+		}
+
+		--offset;
+		--proc;
+
+		if (!*proc)
+			return 0;
+	}
+
+	*(str + minOffs) = '\r';
+	return 0;
+}
+
+void TextDisplayer_MR::printText(const char *str, int x, int y, uint8 c0, uint8 c1, uint8 c2) {
+	if (_vm->_albumChatActive) {
+		c0 = 0xEE;
+		c1 = 0xE3;
+		c2 = 0x00;
+	}
+
+	uint8 colorMap[] = { 0, 255, 240, 240 };
+	colorMap[3] = c1;
+	_screen->setTextColor(colorMap, 0, 3);
+	_screen->_charWidth = -2;
+	_screen->printText(str, x, y, c0, c2);
+	_screen->_charWidth = 0;
+}
+
+void TextDisplayer_MR::restoreScreen() {
+	_vm->restorePage3();
+	_vm->drawAnimObjects();
+	_screen->copyRegion(_talkCoords.x, _talkMessageY, _talkCoords.x, _talkMessageY, _talkCoords.w, _talkMessageH, 2, 0, Screen::CR_NO_P_CHECK);
+	_vm->flagAnimObjsForRefresh();
+	_vm->refreshAnimObjects(0);
+}
+
+void TextDisplayer_MR::calcWidestLineBounds(int &x1, int &x2, int w, int x) {
+	x1 = x;
+	x1 -= (w >> 1);
+	x2 = x1 + w + 1;
+
+	if (x1 + w >= 311)
+		x1 = 311 - w - 1;
+
+	if (x1 < 8)
+		x1 = 8;
+
+	x2 = x1 + w + 1;
+}
+
+#pragma mark -
+
+int KyraEngine_MR::chatGetType(const char *str) {
+	while (*str)
+		++str;
+	--str;
+	switch (*str) {
+	case '!':
+		return 2;
+
+	case ')':
+		return 3;
+
+	case '?':
+		return 1;
+
+	case '.':
+	default:
+		return 0;
+	}
+}
+
+int KyraEngine_MR::chatCalcDuration(const char *str) {
+	return MAX<int>(120, strlen(str)*6);
+}
+
+void KyraEngine_MR::objectChat(const char *str, int object, int vocHigh, int vocLow) {
+	if (_mainCharacter.animFrame == 87 || _mainCharacter.animFrame == 0xFFFF || _mainCharacter.x1 <= 0 || _mainCharacter.y1 <= 0)
+		return;
+
+	_chatVocLow = _chatVocHigh = -1;
+	objectChatInit(str, object, vocHigh, vocLow);
+	_chatText = str;
+	_chatObject = object;
+	int chatType = chatGetType(str);
+
+	if (_mainCharacter.facing > 7)
+		_mainCharacter.facing = 5;
+
+	static const uint8 talkScriptTable[] = {
+		0x10, 0x11, 0x12, 0x13,
+		0x0C, 0x0D, 0x0E, 0x0F,
+		0x0C, 0x0D, 0x0E, 0x0F,
+		0x04, 0x05, 0x06, 0x07,
+		0x00, 0x01, 0x02, 0x03,
+		0x00, 0x01, 0x02, 0x03,
+		0x08, 0x09, 0x0A, 0x0B,
+		0x08, 0x09, 0x0A, 0x0B
+	};
+
+	static const char *const talkFilenameTable[] = {
+		"MTFL00S.EMC", "MTFL00Q.EMC", "MTFL00E.EMC", "MTFL00T.EMC",
+		"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",  "MTA00E.EMC",  "MTA00T.EMC"
+	};
+
+	int chat = talkScriptTable[chatType + _mainCharacter.facing * 4];
+	objectChatProcess(talkFilenameTable[chat]);
+	_text->restoreScreen();
+	_mainCharacter.animFrame = _characterFrameTable[_mainCharacter.facing];
+	updateCharacterAnim(0);
+	_chatText = 0;
+	_chatObject = -1;
+	setNextIdleAnimTimer();
+}
+
+void KyraEngine_MR::objectChatInit(const char *str, int object, int vocHigh, int vocLow) {
+	str = _text->preprocessString(str);
+	int lineNum = _text->buildMessageSubstrings(str);
+
+	int xPos = 0, yPos = 0;
+
+	if (!object) {
+		int scale = getScale(_mainCharacter.x1, _mainCharacter.y1);
+		yPos = _mainCharacter.y1 - ((_mainCharacter.height * scale) >> 8) - 8;
+		xPos = _mainCharacter.x1;
+	} else {
+		yPos = _talkObjectList[object].y;
+		xPos = _talkObjectList[object].x;
+	}
+
+	yPos -= lineNum * 10;
+	yPos = MAX(yPos, 0);
+	_text->_talkMessageY = yPos;
+	_text->_talkMessageH = lineNum*10;
+
+	int width = _text->getWidestLineWidth(lineNum);
+	_text->calcWidestLineBounds(xPos, yPos, width, xPos);
+	_text->_talkCoords.x = xPos;
+	_text->_talkCoords.w = width + 2;
+
+	restorePage3();
+
+	_chatTextEnabled = textEnabled();
+	if (_chatTextEnabled) {
+		objectChatPrintText(str, object);
+		_chatEndTime = _system->getMillis() + chatCalcDuration(str) * _tickLength;
+	} else {
+		_chatEndTime = _system->getMillis();
+	}
+
+	if (speechEnabled()) {
+		_chatVocHigh = vocHigh;
+		_chatVocLow = vocLow;
+	} else {
+		_chatVocHigh = _chatVocLow = -1;
+	}
+}
+
+void KyraEngine_MR::objectChatPrintText(const char *str, int object) {
+	int c1 = _talkObjectList[object].color;
+	str = _text->preprocessString(str);
+	int lineNum = _text->buildMessageSubstrings(str);
+	int maxWidth = _text->getWidestLineWidth(lineNum);
+	int x = (object == 0) ? _mainCharacter.x1 : _talkObjectList[object].x;
+	int cX1 = 0, cX2 = 0;
+	_text->calcWidestLineBounds(cX1, cX2, maxWidth, x);
+
+	for (int i = 0; i < lineNum; ++i) {
+		str = &_text->_talkSubstrings[i*_text->maxSubstringLen()];
+
+		int y = _text->_talkMessageY + i * 10;
+		x = _text->getCenterStringX(str, cX1, cX2);
+
+		_text->printText(str, x, y, c1, 0xF0, 0);
+	}
+}
+
+void KyraEngine_MR::objectChatProcess(const char *script) {
+	memset(&_chatScriptData, 0, sizeof(_chatScriptData));
+	memset(&_chatScriptState, 0, sizeof(_chatScriptState));
+
+	_emc->load(script, &_chatScriptData, &_opcodesAnimation);
+	_emc->init(&_chatScriptState, &_chatScriptData);
+	_emc->start(&_chatScriptState, 0);
+	while (_emc->isValid(&_chatScriptState))
+		_emc->run(&_chatScriptState);
+
+	if (_chatVocHigh >= 0) {
+		playVoice(_chatVocHigh, _chatVocLow);
+		_chatVocHigh = _chatVocLow = -1;
+	}
+
+	_useFrameTable = true;
+	objectChatWaitToFinish();
+	_useFrameTable = false;
+
+	_emc->unload(&_chatScriptData);
+}
+
+void KyraEngine_MR::objectChatWaitToFinish() {
+	int charAnimFrame = _mainCharacter.animFrame;
+	setCharacterAnimDim(_animShapeWidth, _animShapeHeight);
+
+	_emc->init(&_chatScriptState, &_chatScriptData);
+	_emc->start(&_chatScriptState, 1);
+
+	bool running = true;
+	const uint32 endTime = _chatEndTime;
+	resetSkipFlag();
+
+	while (running && !shouldQuit()) {
+		if (!_emc->isValid(&_chatScriptState))
+			_emc->start(&_chatScriptState, 1);
+
+		_animNeedUpdate = false;
+		while (!_animNeedUpdate && _emc->isValid(&_chatScriptState) && !shouldQuit())
+			_emc->run(&_chatScriptState);
+
+		int curFrame = _animNewFrame;
+		uint32 delayTime = _animDelayTime;
+
+		_mainCharacter.animFrame = curFrame;
+		updateCharacterAnim(0);
+
+		uint32 nextFrame = _system->getMillis() + delayTime * _tickLength;
+
+		while (_system->getMillis() < nextFrame && !shouldQuit()) {
+			updateWithText();
+
+			const uint32 curTime = _system->getMillis();
+			if ((textEnabled() && !speechEnabled() && curTime > endTime) || (speechEnabled() && !snd_voiceIsPlaying()) || skipFlag()) {
+				snd_stopVoice();
+				resetSkipFlag();
+				nextFrame = curTime;
+				running = false;
+			}
+
+			delay(10);
+		}
+	}
+
+	_mainCharacter.animFrame = charAnimFrame;
+	updateCharacterAnim(0);
+	resetCharacterAnimDim();
+}
+
+void KyraEngine_MR::badConscienceChat(const char *str, int vocHigh, int vocLow) {
+	if (!_badConscienceShown)
+		return;
+
+	setNextIdleAnimTimer();
+	_chatVocHigh = _chatVocLow = -1;
+	objectChatInit(str, 1, vocHigh, vocLow);
+	_chatText = str;
+	_chatObject = 1;
+	badConscienceChatWaitToFinish();
+	updateSceneAnim(0x0E, _badConscienceFrameTable[_badConscienceAnim+16]);
+	_text->restoreScreen();
+	update();
+	_chatText = 0;
+	_chatObject = -1;
+}
+
+void KyraEngine_MR::badConscienceChatWaitToFinish() {
+	if (_chatVocHigh) {
+		playVoice(_chatVocHigh, _chatVocLow);
+		_chatVocHigh = _chatVocLow = -1;
+	}
+
+	bool running = true;
+	const uint32 endTime = _chatEndTime;
+	resetSkipFlag();
+
+	uint32 nextFrame = _system->getMillis() + _rnd.getRandomNumberRng(4, 8) * _tickLength;
+
+	int frame = _badConscienceFrameTable[_badConscienceAnim+24];
+	while (running && !shouldQuit()) {
+		if (nextFrame < _system->getMillis()) {
+			++frame;
+			if (_badConscienceFrameTable[_badConscienceAnim+32] < frame)
+				frame = _badConscienceFrameTable[_badConscienceAnim+24];
+
+			updateSceneAnim(0x0E, frame);
+			updateWithText();
+
+			nextFrame = _system->getMillis() + _rnd.getRandomNumberRng(4, 8) * _tickLength;
+		}
+
+		updateWithText();
+
+		const uint32 curTime = _system->getMillis();
+		if ((textEnabled() && !speechEnabled() && curTime > endTime) || (speechEnabled() && !snd_voiceIsPlaying()) || skipFlag()) {
+			snd_stopVoice();
+			resetSkipFlag();
+			nextFrame = curTime;
+			running = false;
+		}
+
+		delay(10);
+	}
+}
+
+void KyraEngine_MR::goodConscienceChat(const char *str, int vocHigh, int vocLow) {
+	if (!_goodConscienceShown)
+		return;
+
+	setNextIdleAnimTimer();
+	_chatVocHigh = _chatVocLow = -1;
+	objectChatInit(str, 87, vocHigh, vocLow);
+	_chatText = str;
+	_chatObject = 87;
+	goodConscienceChatWaitToFinish();
+	updateSceneAnim(0x0F, _goodConscienceFrameTable[_goodConscienceAnim+10]);
+	_text->restoreScreen();
+	update();
+	_chatText = 0;
+	_chatObject = -1;
+}
+
+void KyraEngine_MR::goodConscienceChatWaitToFinish() {
+	if (_chatVocHigh) {
+		playVoice(_chatVocHigh, _chatVocLow);
+		_chatVocHigh = _chatVocLow = -1;
+	}
+
+	bool running = true;
+	const uint32 endTime = _chatEndTime;
+	resetSkipFlag();
+
+	uint32 nextFrame = _system->getMillis() + _rnd.getRandomNumberRng(3, 6) * _tickLength;
+
+	int frame = _goodConscienceFrameTable[_goodConscienceAnim+15];
+	while (running && !shouldQuit()) {
+		if (nextFrame < _system->getMillis()) {
+			++frame;
+			if (_goodConscienceFrameTable[_goodConscienceAnim+20] < frame)
+				frame = _goodConscienceFrameTable[_goodConscienceAnim+15];
+
+			updateSceneAnim(0x0F, frame);
+			updateWithText();
+
+			nextFrame = _system->getMillis() + _rnd.getRandomNumberRng(3, 6) * _tickLength;
+		}
+
+		updateWithText();
+
+		const uint32 curTime = _system->getMillis();
+		if ((textEnabled() && !speechEnabled() && curTime > endTime) || (speechEnabled() && !snd_voiceIsPlaying()) || skipFlag()) {
+			snd_stopVoice();
+			resetSkipFlag();
+			nextFrame = curTime;
+			running = false;
+		}
+
+		delay(10);
+	}
+}
+
+void KyraEngine_MR::albumChat(const char *str, int vocHigh, int vocLow) {
+	_talkObjectList[1].x = 190;
+	_talkObjectList[1].y = 188;
+
+	_chatVocHigh = _chatVocLow = -1;
+	_albumChatActive = true;
+	albumChatInit(str, 1, vocHigh, vocLow);
+	_albumChatActive = false;
+
+	_chatText = str;
+	_chatObject = 1;
+	_screen->hideMouse();
+	albumChatWaitToFinish();
+	_screen->showMouse();
+
+	_chatText = 0;
+	_chatObject = -1;
+}
+
+void KyraEngine_MR::albumChatInit(const char *str, int object, int vocHigh, int vocLow) {
+	Common::String realString;
+
+	while (*str) {
+		if (str[0] == '\\' && str[1] == 'r') {
+			realString += '\r';
+			++str;
+		} else {
+			realString += *str;
+		}
+
+		++str;
+	}
+
+	str = realString.c_str();
+
+	str = _text->preprocessString(str);
+	int lineNum = _text->buildMessageSubstrings(str);
+
+	int xPos = 0, yPos = 0;
+
+	if (!object) {
+		int scale = getScale(_mainCharacter.x1, _mainCharacter.y1);
+		yPos = _mainCharacter.y1 - ((_mainCharacter.height * scale) >> 8) - 8;
+		xPos = _mainCharacter.x1;
+	} else {
+		yPos = _talkObjectList[object].y;
+		xPos = _talkObjectList[object].x;
+	}
+
+	yPos -= lineNum * 10;
+	yPos = MAX(yPos, 0);
+	_text->_talkMessageY = yPos;
+	_text->_talkMessageH = lineNum*10;
+
+	int width = _text->getWidestLineWidth(lineNum);
+	_text->calcWidestLineBounds(xPos, yPos, width, xPos);
+	_text->_talkCoords.x = xPos;
+	_text->_talkCoords.w = width + 2;
+
+	_screen->hideMouse();
+
+	if (textEnabled()) {
+		objectChatPrintText(str, object);
+		_chatEndTime = _system->getMillis() + chatCalcDuration(str) * _tickLength;
+	} else {
+		_chatEndTime = _system->getMillis();
+	}
+
+	if (speechEnabled()) {
+		_chatVocHigh = vocHigh;
+		_chatVocLow = vocLow;
+	} else {
+		_chatVocHigh = _chatVocLow = -1;
+	}
+
+	_screen->showMouse();
+}
+
+void KyraEngine_MR::albumChatWaitToFinish() {
+	if (_chatVocHigh) {
+		playVoice(_chatVocHigh, _chatVocLow);
+		_chatVocHigh = _chatVocLow = -1;
+	}
+
+	bool running = true;
+	const uint32 endTime = _chatEndTime;
+	resetSkipFlag();
+
+	uint32 nextFrame = 0;
+	int frame = 12;
+	while (running && !shouldQuit()) {
+		if (nextFrame < _system->getMillis()) {
+			++frame;
+			if (frame > 22)
+				frame = 13;
+
+			albumRestoreRect();
+			_album.wsa->displayFrame(frame, 2, -100, 90, 0x4000, 0, 0);
+			albumUpdateRect();
+
+			nextFrame = _system->getMillis() + _rnd.getRandomNumberRng(4, 8) * _tickLength;
+		}
+
+		if (_album.nextPage != 14)
+			albumUpdateAnims();
+		else
+			_screen->updateScreen();
+
+		const uint32 curTime = _system->getMillis();
+		if ((textEnabled() && !speechEnabled() && curTime > endTime) || (speechEnabled() && !snd_voiceIsPlaying()) || skipFlag()) {
+			snd_stopVoice();
+			resetSkipFlag();
+			nextFrame = curTime;
+			running = false;
+		}
+
+		delay(10);
+	}
+}
+
+void KyraEngine_MR::malcolmSceneStartupChat() {
+	if (_noStartupChat)
+		return;
+
+	int index = _mainCharacter.sceneId - _chapterLowestScene[_currentChapter];
+	if (_newSceneDlgState[index])
+		return;
+
+	updateDlgBuffer();
+	int vocHighBase = 0, vocHighIndex = 0, index1 = 0, index2 = 0;
+	loadDlgHeader(vocHighBase, vocHighIndex, index1, index2);
+
+	_cnvFile->seek(index1*6, SEEK_CUR);
+	_cnvFile->seek(index2*4, SEEK_CUR);
+	_cnvFile->seek(index*2, SEEK_CUR);
+	_cnvFile->seek(_cnvFile->readUint16LE(), SEEK_SET);
+
+	_isStartupDialog = true;
+	processDialog(vocHighIndex, vocHighBase, 0);
+	_isStartupDialog = false;
+	_newSceneDlgState[index] = true;
+}
+
+void KyraEngine_MR::updateDlgBuffer() {
+	if (_cnvFile)
+		_cnvFile->seek(0, SEEK_SET);
+
+	if (_curDlgIndex == _mainCharacter.dlgIndex && _curDlgChapter == _currentChapter && _curDlgLang == _lang)
+		return;
+
+	Common::String dlgFile = Common::String::format("CH%.02d-S%.02d.%s", _currentChapter, _mainCharacter.dlgIndex, _languageExtension[_lang]);
+	Common::String cnvFile = Common::String::format("CH%.02d-S%.02d.CNV", _currentChapter, _mainCharacter.dlgIndex);
+
+	delete _cnvFile;
+	delete _dlgBuffer;
+
+	_res->exists(cnvFile.c_str(), true);
+	_res->exists(dlgFile.c_str(), true);
+	_cnvFile = _res->createReadStream(cnvFile);
+	_dlgBuffer = _res->createReadStream(dlgFile);
+	assert(_cnvFile);
+	assert(_dlgBuffer);
+}
+
+void KyraEngine_MR::loadDlgHeader(int &vocHighBase, int &vocHighIndex, int &index1, int &index2) {
+	assert(_cnvFile);
+	vocHighIndex = _cnvFile->readSint16LE();
+	vocHighBase = _cnvFile->readSint16LE();
+	index1 = _cnvFile->readSint16LE();
+	index2 = _cnvFile->readSint16LE();
+}
+
+void KyraEngine_MR::setDlgIndex(int index) {
+	if (_mainCharacter.dlgIndex != index) {
+		memset(_newSceneDlgState, 0, sizeof(_newSceneDlgState));
+		memset(_conversationState, -1, sizeof(_conversationState));
+		_chatAltFlag = false;
+		_mainCharacter.dlgIndex = index;
+	}
+}
+
+void KyraEngine_MR::updateDlgIndex() {
+	uint16 dlgIndex = _mainCharacter.dlgIndex;
+
+	if (_currentChapter == 1) {
+		static const uint8 dlgIndexMoodNice[] = { 0x0C, 0x0E, 0x10, 0x0F, 0x11 };
+		static const uint8 dlgIndexMoodNormal[] = { 0x00, 0x02, 0x04, 0x03, 0x05 };
+		static const uint8 dlgIndexMoodEvil[] = { 0x06, 0x08, 0x0A, 0x09, 0x0B };
+
+		if (_malcolmsMood == 0)
+			dlgIndex = dlgIndexMoodNice[_characterShapeFile];
+		else if (_malcolmsMood == 1)
+			dlgIndex = dlgIndexMoodNormal[_characterShapeFile];
+		else if (_malcolmsMood == 2)
+			dlgIndex = dlgIndexMoodEvil[_characterShapeFile];
+	} else if (_currentChapter == 2) {
+		if (dlgIndex >= 8)
+			dlgIndex -= 4;
+		if (dlgIndex >= 4)
+			dlgIndex -= 4;
+
+		if (_malcolmsMood == 0)
+			dlgIndex += 8;
+		else if (_malcolmsMood == 2)
+			dlgIndex += 4;
+	} else if (_currentChapter == 4) {
+		if (dlgIndex >= 10)
+			dlgIndex -= 5;
+		if (dlgIndex >= 5)
+			dlgIndex -= 5;
+
+		if (_malcolmsMood == 0)
+			dlgIndex += 10;
+		else if (_malcolmsMood == 2)
+			dlgIndex += 5;
+	}
+
+	_mainCharacter.dlgIndex = dlgIndex;
+}
+
+void KyraEngine_MR::processDialog(int vocHighIndex, int vocHighBase, int funcNum) {
+	bool running = true;
+	int script = -1;
+	int vocHigh = -1, vocLow = -1;
+
+	while (running) {
+		uint16 cmd = _cnvFile->readUint16LE();
+		int object = cmd - 12;
+
+		if (cmd == 10) {
+			break;
+		} else if (cmd == 4) {
+			vocHighBase = _cnvFile->readUint16LE();
+			setDlgIndex(vocHighBase);
+		} else if (cmd == 11) {
+			int strSize = _cnvFile->readUint16LE();
+			vocLow = _cnvFile->readUint16LE();
+			_cnvFile->read(_stringBuffer, strSize);
+			_stringBuffer[strSize] = 0;
+		} else {
+			vocHigh = _vocHighTable[vocHighIndex-1] + vocHighBase;
+			vocLow = _cnvFile->readUint16LE();
+			getTableEntry(_dlgBuffer, vocLow, _stringBuffer);
+
+			if (_isStartupDialog) {
+				delay(60*_tickLength, true);
+				_isStartupDialog = false;
+			}
+
+			if (*_stringBuffer == 0)
+				continue;
+
+			if (cmd != 12) {
+				if (object != script) {
+					if (script >= 0) {
+						dialogEndScript(script);
+						script = -1;
+					}
+
+					dialogStartScript(object, funcNum);
+					script = object;
+				}
+
+				npcChatSequence(_stringBuffer, object, vocHigh, vocLow);
+			} else {
+				if (script >= 0) {
+					dialogEndScript(script);
+					script = -1;
+				}
+
+				objectChat(_stringBuffer, 0, vocHigh, vocLow);
+				playStudioSFX(_stringBuffer);
+			}
+		}
+	}
+
+	if (script != -1)
+		dialogEndScript(script);
+}
+
+void KyraEngine_MR::dialogStartScript(int object, int funcNum) {
+	_dialogSceneAnim = _talkObjectList[object].sceneAnim;
+	_dialogSceneScript = _talkObjectList[object].sceneScript;
+	if (_dialogSceneAnim >= 0 && _dialogSceneScript >= 0) {
+		_specialSceneScriptStateBackup[_dialogSceneScript] = _specialSceneScriptState[_dialogSceneScript];
+		_specialSceneScriptState[_dialogSceneScript] = true;
+	}
+
+	_emc->init(&_dialogScriptState, &_dialogScriptData);
+	_emc->load(_talkObjectList[object].filename, &_dialogScriptData, &_opcodesDialog);
+
+	_dialogScriptFuncStart = funcNum * 3 + 0;
+	_dialogScriptFuncProc = funcNum * 3 + 1;
+	_dialogScriptFuncEnd = funcNum * 3 + 2;
+
+	_emc->start(&_dialogScriptState, _dialogScriptFuncStart);
+	while (_emc->isValid(&_dialogScriptState))
+		_emc->run(&_dialogScriptState);
+}
+
+void KyraEngine_MR::dialogEndScript(int object) {
+	_emc->init(&_dialogScriptState, &_dialogScriptData);
+	_emc->start(&_dialogScriptState, _dialogScriptFuncEnd);
+
+	while (_emc->isValid(&_dialogScriptState))
+		_emc->run(&_dialogScriptState);
+
+	if (_dialogSceneAnim >= 0 && _dialogSceneScript >= 0) {
+		_specialSceneScriptState[_dialogSceneScript] = _specialSceneScriptStateBackup[_dialogSceneScript];
+		_dialogSceneScript = _dialogSceneAnim = -1;
+	}
+
+	_emc->unload(&_dialogScriptData);
+}
+
+void KyraEngine_MR::npcChatSequence(const char *str, int object, int vocHigh, int vocLow) {
+	_chatText = str;
+	_chatObject = object;
+	_chatVocHigh = _chatVocLow = -1;
+
+	objectChatInit(str, object, vocHigh, vocLow);
+
+	if (_chatVocHigh >= 0 && _chatVocLow >= 0) {
+		playVoice(_chatVocHigh, _chatVocLow);
+		_chatVocHigh = _chatVocLow = -1;
+	}
+
+	_emc->init(&_dialogScriptState, &_dialogScriptData);
+	_emc->start(&_dialogScriptState, _dialogScriptFuncProc);
+
+	resetSkipFlag();
+
+	uint32 endTime = _chatEndTime;
+	bool running = true;
+	while (running && !shouldQuit()) {
+		if (!_emc->run(&_dialogScriptState)) {
+			_emc->init(&_dialogScriptState, &_dialogScriptData);
+			_emc->start(&_dialogScriptState, _dialogScriptFuncProc);
+		}
+
+		const uint32 curTime = _system->getMillis();
+		if ((textEnabled() && !speechEnabled() && curTime > endTime) || (speechEnabled() && !snd_voiceIsPlaying()) || skipFlag()) {
+			snd_stopVoice();
+			resetSkipFlag();
+			running = false;
+		}
+	}
+	_text->restoreScreen();
+	_chatText = 0;
+	_chatObject= - 1;
+}
+
+void KyraEngine_MR::randomSceneChat() {
+	updateDlgBuffer();
+
+	int index = (_mainCharacter.sceneId - _chapterLowestScene[_currentChapter]) * 2;
+
+	int vocHighBase = 0, vocHighIndex = 0, index1 = 0, index2 = 0;
+	loadDlgHeader(vocHighBase, vocHighIndex, index1, index2);
+
+	if (_chatAltFlag)
+		index++;
+	_chatAltFlag = !_chatAltFlag;
+
+	_cnvFile->seek(index1*6, SEEK_CUR);
+	_cnvFile->seek(index*2, SEEK_CUR);
+	_cnvFile->seek(_cnvFile->readUint16LE(), SEEK_SET);
+
+	processDialog(vocHighIndex, vocHighBase, 0);
+}
+
+void KyraEngine_MR::doDialog(int dlgIndex, int funcNum) {
+	switch (_currentChapter-2) {
+	case 0:
+		dlgIndex -= 34;
+		break;
+
+	case 1:
+		dlgIndex -= 54;
+		break;
+
+	case 2:
+		dlgIndex -= 55;
+		break;
+
+	case 3:
+		dlgIndex -= 70;
+		break;
+
+	default:
+		break;
+	}
+
+	updateDlgBuffer();
+
+	int vocHighBase = 0, vocHighIndex = 0, index1 = 0, index2 = 0;
+	loadDlgHeader(vocHighBase, vocHighIndex, index1, index2);
+
+	int convState = _conversationState[dlgIndex][vocHighBase];
+	uint32 offset = ((vocHighIndex == 1) ? dlgIndex - 1 : dlgIndex) * 6;
+	if (convState == -1) {
+		_cnvFile->seek(offset, SEEK_CUR);
+		_conversationState[dlgIndex][vocHighBase] = 0;
+	} else if (convState == 0 || convState == 2) {
+		_cnvFile->seek(offset+2, SEEK_CUR);
+		_conversationState[dlgIndex][vocHighBase] = 1;
+	} else {
+		_cnvFile->seek(offset+4, SEEK_CUR);
+		_conversationState[dlgIndex][vocHighBase] = 2;
+	}
+
+	_cnvFile->seek(_cnvFile->readUint16LE(), SEEK_SET);
+
+	processDialog(vocHighIndex, vocHighBase, funcNum);
+}
+
+} // End of namespace Kyra
diff --git a/engines/kyra/text/text_mr.h b/engines/kyra/text/text_mr.h
new file mode 100644
index 0000000000..339aba691d
--- /dev/null
+++ b/engines/kyra/text/text_mr.h
@@ -0,0 +1,52 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef KYRA_TEXT_MR_H
+#define KYRA_TEXT_MR_H
+
+#include "kyra/text/text.h"
+
+#include "kyra/engine/kyra_mr.h"
+
+namespace Kyra {
+
+class TextDisplayer_MR : public TextDisplayer {
+friend class KyraEngine_MR;
+public:
+	TextDisplayer_MR(KyraEngine_MR *vm, Screen_MR *screen);
+
+	char *preprocessString(const char *str);
+	int dropCRIntoString(char *str, int minOffs, int maxOffs);
+
+	void printText(const char *str, int x, int y, uint8 c0, uint8 c1, uint8 c2);
+
+	void restoreScreen();
+
+	void calcWidestLineBounds(int &x1, int &x2, int w, int x);
+protected:
+	KyraEngine_MR *_vm;
+	Screen_MR *_screen;
+};
+
+} // End of namespace Kyra
+
+#endif
diff --git a/engines/kyra/text/text_rpg.cpp b/engines/kyra/text/text_rpg.cpp
new file mode 100644
index 0000000000..10e1a4409f
--- /dev/null
+++ b/engines/kyra/text/text_rpg.cpp
@@ -0,0 +1,739 @@
+/* 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.
+ *
+ */
+
+#if defined(ENABLE_EOB) || defined(ENABLE_LOL)
+
+#include "kyra/engine/kyra_rpg.h"
+#include "kyra/engine/timer.h"
+
+#include "common/system.h"
+
+namespace Kyra {
+
+enum {
+	kEoBTextBufferSize = 2560
+};
+
+TextDisplayer_rpg::TextDisplayer_rpg(KyraRpgEngine *engine, Screen *scr) : _vm(engine), _screen(scr),
+	_lineCount(0), _printFlag(false), _lineWidth(0), _numCharsTotal(0), _allowPageBreak(true),
+	_numCharsLeft(0), _numCharsPrinted(0), _sjisTextModeLineBreak(false), _waitButtonMode(1) {
+
+	_dialogueBuffer = new char[kEoBTextBufferSize];
+	memset(_dialogueBuffer, 0, kEoBTextBufferSize);
+
+	_currentLine = new char[85];
+	memset(_currentLine, 0, 85);
+
+	_textDimData = new TextDimData[_screen->screenDimTableCount()];
+
+	for (int i = 0; i < _screen->screenDimTableCount(); i++) {
+		const ScreenDim *d = _screen->getScreenDim(i);
+		_textDimData[i].color1 = d->unk8;
+		_textDimData[i].color2 = d->unkA;
+		_textDimData[i].line = d->unkC;
+		_textDimData[i].column = d->unkE;
+	}
+
+	_table1 = new char[128];
+	memset(_table1, 0, 128);
+	_table2 = new char[16];
+	memset(_table2, 0, 16);
+
+	_waitButtonSpace = 0;
+}
+
+TextDisplayer_rpg::~TextDisplayer_rpg() {
+	delete[] _dialogueBuffer;
+	delete[] _currentLine;
+	delete[] _textDimData;
+	delete[] _table1;
+	delete[] _table2;
+}
+
+void TextDisplayer_rpg::setupField(int dim, bool mode) {
+	setPageBreakFlag();
+
+	_textDimData[dim].color2 = _vm->guiSettings()->colors.fill;
+	_screen->setScreenDim(dim);
+
+	if (mode) {
+		_screen->set16bitShadingLevel(4);
+		clearCurDim();
+		_screen->set16bitShadingLevel(0);
+	} else {
+		resetDimTextPositions(dim);
+	}
+}
+
+void TextDisplayer_rpg::resetDimTextPositions(int dim) {
+	_textDimData[dim].column = 0;
+	_textDimData[dim].line = 0;
+}
+
+void TextDisplayer_rpg::resetPageBreakString() {
+	if (_vm->_moreStrings)
+		strcpy(_pageBreakString, _vm->_moreStrings[0]);
+}
+
+void TextDisplayer_rpg::setPageBreakFlag() {
+	_allowPageBreak = true;
+	_lineCount = 0;
+}
+
+void TextDisplayer_rpg::removePageBreakFlag() {
+	_allowPageBreak = false;
+}
+
+void TextDisplayer_rpg::displayText(char *str, ...) {
+	_printFlag = false;
+
+	_lineWidth = 0;
+	_numCharsLeft = 0;
+	_numCharsPrinted = 0;
+
+	_tempString1 = str;
+	_tempString2 = 0;
+
+	_currentLine[0] = 0;
+
+	memset(_ctrl, 0, 3);
+
+	char c = parseCommand();
+
+	va_list args;
+	va_start(args, str);
+
+	const ScreenDim *sd = _screen->_curDim;
+	int sdx = _screen->curDimIndex();
+
+	bool sjisTextMode = (_vm->gameFlags().lang == Common::JA_JPN && _vm->gameFlags().use16ColorMode && (sdx == 3 || sdx == 4 || sdx == 5 || sdx == 15)) ? true : false;
+	int sjisOffs = (sjisTextMode || _vm->game() == GI_EOB2) ? 8 : 9;
+	Screen::FontId of = (_vm->game() == GI_EOB2 && _vm->gameFlags().platform == Common::kPlatformFMTowns) ? _screen->setFont(Screen::FID_8_FNT) : _screen->_currentFont;
+
+	uint16 charsPerLine = (sd->w << 3) / (_screen->getFontWidth() + _screen->_charWidth);
+
+	while (c) {
+		char a = tolower((unsigned char)_ctrl[1]);
+
+		if (!_tempString2 && c == '%') {
+			if (a == 'd') {
+				strcpy(_scriptParaString, Common::String::format("%d", va_arg(args, int)).c_str());
+				_tempString2 = _scriptParaString;
+			} else if (a == 's') {
+				_tempString2 = va_arg(args, char *);
+			} else {
+				break;
+			}
+
+			_ctrl[0] = _ctrl[2];
+			_ctrl[2] = _ctrl[1] = 0;
+			c = parseCommand();
+		}
+
+		if (_vm->gameFlags().lang == Common::JA_JPN) {
+			uint8 cu = (uint8) c;
+			if (cu >= 0xE0 || (cu > 0x80 && cu < 0xA0)) {
+				if ((_textDimData[sdx].column + _lineWidth + sjisOffs) > (sd->w << 3))
+					printLine(_currentLine);
+
+				_currentLine[_numCharsLeft++] = c;
+				_currentLine[_numCharsLeft++] = parseCommand();
+				_currentLine[_numCharsLeft] = '\0';
+
+				_lineWidth += sjisOffs;
+				c = parseCommand();
+				continue;
+			}
+		}
+
+		uint16 dv = _textDimData[sdx].column / (_screen->getFontWidth() + _screen->_charWidth);
+
+		switch (c - 1) {
+		case 0:
+			printLine(_currentLine);
+			textPageBreak();
+			_numCharsPrinted = 0;
+			break;
+
+		case 1:
+			printLine(_currentLine);
+			_textDimData[sdx].color2 = parseCommand();
+			break;
+
+		case 5:
+			printLine(_currentLine);
+			_textDimData[sdx].color1 = parseCommand();
+			break;
+
+		case 8:
+			printLine(_currentLine);
+			dv = _textDimData[sdx].column / (_screen->getFontWidth() + _screen->_charWidth);
+			dv = ((dv + 8) & 0xFFF8) - 1;
+			if (dv >= charsPerLine)
+				dv = 0;
+			_textDimData[sdx].column = (_screen->getFontWidth() + _screen->_charWidth) * dv;
+			break;
+
+		case 12:
+			if (sjisTextMode)
+				_sjisTextModeLineBreak = true;
+			printLine(_currentLine);
+			_sjisTextModeLineBreak = false;
+			_lineCount++;
+			_textDimData[sdx].column = 0;
+			_textDimData[sdx].line++;
+			break;
+
+		case 11: case 18: case 23:
+		case 24: case 26: case 28:
+			// These are at the time of writing this comment not known to be
+			// used. In case there is some use of them in some odd version
+			// we display this warning here.
+			warning("TextDisplayer_rpg::displayText: Triggered stub function %d", c - 1);
+			break;
+
+		default:
+			if (_vm->game() == GI_EOB1 || _vm->game() == GI_LOL || (unsigned char)c > 30) {
+				_lineWidth += (sjisTextMode ? 4 : (_screen->_currentFont == Screen::FID_SJIS_FNT ? 9 : _screen->getCharWidth((uint8)c)));
+				_currentLine[_numCharsLeft++] = c;
+				_currentLine[_numCharsLeft] = 0;
+
+				if ((_textDimData[sdx].column + _lineWidth) > (sd->w << 3))
+					printLine(_currentLine);
+			}
+		}
+
+		c = parseCommand();
+	}
+
+	va_end(args);
+
+	if (_numCharsLeft)
+		printLine(_currentLine);
+
+	_screen->setFont(of);
+}
+
+char TextDisplayer_rpg::parseCommand() {
+	if (!_ctrl[1])
+		readNextPara();
+
+	char res = _ctrl[1];
+	_ctrl[1] = _ctrl[2];
+	_ctrl[2] = 0;
+
+	if (!_ctrl[1])
+		readNextPara();
+
+	return res;
+}
+
+void TextDisplayer_rpg::readNextPara() {
+	char c = 0;
+	char d = 0;
+
+	if (_tempString2) {
+		if (*_tempString2) {
+			d = *_tempString2++;
+		} else {
+			_tempString2 = 0;
+			d = _ctrl[0];
+		}
+	}
+
+	if (!d && _tempString1) {
+		if (*_tempString1)
+			d = *_tempString1++;
+		else
+			_tempString1 = 0;
+	}
+
+	// This seems to be some sort of character conversion mechanism. The original doesn't make any use of it, however.
+	// All necessary conversions take place somewhere else. This code actually causes issues if the character conversions
+	// don't take place before calling displayText(). So we disable it for now. If some (not yet supported) localized
+	// versions depend on this code we'll have to look at this again.
+#if 0
+	if ((_vm->game() != GI_LOL) && (d & 0x80)) {
+		d &= 0x7F;
+		c = d & 7;
+		d = (d & 0x78) >> 3;
+		uint8 l = d;
+		c = _table1[(l << 3) + c];
+		d = _table2[l];
+	}
+#endif
+
+	_ctrl[1] = d;
+	_ctrl[2] = c;
+}
+
+void TextDisplayer_rpg::printLine(char *str) {
+	const ScreenDim *sd = _screen->_curDim;
+	int sdx = _screen->curDimIndex();
+	bool sjisTextMode = _vm->gameFlags().lang == Common::JA_JPN && (_vm->gameFlags().use16ColorMode && (sdx == 3 || sdx == 4 || sdx == 5 || sdx == 15)) ? true : false;
+
+	int fh = (_screen->_currentFont == Screen::FID_SJIS_FNT) ? 9 : (_screen->getFontHeight() + _screen->_charOffset);
+	int lines = (sd->h - _screen->_charOffset) / fh;
+
+	while (_textDimData[sdx].line >= lines) {
+		if ((lines - _waitButtonSpace) <= _lineCount && _allowPageBreak) {
+			_lineCount = 0;
+			textPageBreak();
+			_numCharsPrinted = 0;
+		}
+
+		int h1 = ((sd->h / fh) - 1) * fh;
+		int h2 = sd->h - fh;
+
+		if (h2)
+			_screen->copyRegion(sd->sx << 3, sd->sy + fh, sd->sx << 3, sd->sy, sd->w << 3, h2, _screen->_curPage, _screen->_curPage, Screen::CR_NO_P_CHECK);
+
+		_screen->set16bitShadingLevel(4);
+		_screen->fillRect(sd->sx << 3, sd->sy + h1, ((sd->sx + sd->w) << 3) - 1, sd->sy + sd->h - 1, _textDimData[sdx].color2);
+		_screen->set16bitShadingLevel(0);
+
+		if (_textDimData[sdx].line)
+			_textDimData[sdx].line--;
+	}
+
+	int x1 = (sd->sx << 3) + _textDimData[sdx].column;
+	int y = sd->sy + (sjisTextMode ? (_textDimData[sdx].line << 3) : (fh * _textDimData[sdx].line));
+	int w = sd->w << 3;
+	int lw = _lineWidth;
+	int s = _numCharsLeft;
+	char c = 0;
+	uint8 twoByteCharOffs = 0;
+
+
+	if (sjisTextMode) {
+		bool ct = true;
+
+		if ((lw + _textDimData[sdx].column) >= w) {
+			if ((lines - 1 - (_waitButtonSpace << 1)) <= _lineCount)
+				// cut off line to leave space for "MORE" button
+				w -= _vm->guiSettings()->buttons.waitReserve;
+		} else {
+			if (!_sjisTextModeLineBreak || (_lineCount + 1 < lines - 1))
+				ct = false;
+			else
+				// cut off line to leave space for "MORE" button
+				w -= _vm->guiSettings()->buttons.waitReserve;
+		}
+
+		if (ct) {
+			w -= _textDimData[sdx].column;
+
+			int n2 = 0;
+			int n1 = (w / 4) - 1;
+
+			while (n2 < n1 && n2 < s) {
+				c = str[n2];
+				uint8 cu = (uint8) c;
+				if (cu >= 0xE0 || (cu > 0x80 && cu < 0xA0))
+					n2++;
+				n2++;
+			}
+			s = n2;
+		}
+	} else {
+		if (_vm->gameFlags().lang == Common::JA_JPN) {
+			for (int i = 0; i < s; ++i) {
+				uint8 cu = (uint8) str[i];
+				if (cu >= 0xE0 || (cu > 0x80 && cu < 0xA0))
+					twoByteCharOffs = 8;
+			}
+		}
+
+		if ((lw + _textDimData[sdx].column) >= w) {
+			if ((lines - 1) <= _lineCount && _allowPageBreak)
+				// cut off line to leave space for "MORE" button
+				w -= _vm->guiSettings()->buttons.waitReserve;
+
+			w -= _textDimData[sdx].column;
+
+			int lineLastCharPos = 0;
+			int strPos = s - 1;
+
+			if (twoByteCharOffs) {
+				lw = 0;
+				int prevStrPos = 0;
+				c = str[0];
+
+				for (strPos = 0; strPos < s; ++strPos) {
+					uint8 cu = (uint8) str[strPos];
+					if (cu >= 0xE0 || (cu > 0x80 && cu < 0xA0)) {
+						lw += 9;
+						strPos++;
+					} else {
+						lw += _screen->getCharWidth((uint8)c);
+					}
+
+					if (!lineLastCharPos && w < lw + twoByteCharOffs)
+						lineLastCharPos = prevStrPos;
+
+					if (lineLastCharPos && c == ' ') {
+						s = strPos;
+						_printFlag = false;
+						break;
+					}
+					prevStrPos = strPos;
+					c = (char) cu;
+				}
+
+				if (!lineLastCharPos) {
+					lineLastCharPos = s - 1;
+					if (lineLastCharPos && str[lineLastCharPos] == ' ') {
+						s = strPos;
+						_printFlag = false;
+					}
+				}
+
+				lw = _lineWidth;
+
+			} else {
+				while (strPos > 0) {
+					//cut off line after last space
+					c = str[strPos];
+
+					lw -= _screen->getCharWidth((uint8)c);
+
+					if (!lineLastCharPos && lw <= w)
+						lineLastCharPos = strPos;
+
+					if (lineLastCharPos && c == ' ') {
+						s = strPos;
+						_printFlag = false;
+						break;
+					}
+					strPos--;
+				}
+			}
+
+			if (!strPos) {
+				if (_textDimData[sdx].column && !_printFlag) {
+					s = lw = 0;
+					_printFlag = true;
+				} else {
+					s = lineLastCharPos;
+				}
+			}
+
+		}
+	}
+
+	c = str[s];
+	str[s] = 0;
+
+	uint8 col = _textDimData[sdx].color1;
+	if (sjisTextMode && (sdx == 2 || sdx == 3 || sdx == 4 || sdx == 5 || sdx == 15)) {
+		switch (_textDimData[sdx].color1) {
+		case 0x88:
+			col = 0x41;
+			break;
+		case 0x55:
+			col = 0x81;
+			break;
+		case 0xAA:
+			col = 0x21;
+			break;
+		case 0x99:
+			col = 0xA1;
+			break;
+		case 0x33:
+			col = 0xE1;
+			break;
+		case 0x18:
+			col = 0x61;
+			break;
+		default:
+			col = 1;
+			break;
+		}
+		_screen->printText(str, x1 & ~3, (y + 8) & ~7, col, 0);
+	} else {
+		_screen->printText(str, x1, y, col, _textDimData[sdx].color2);
+		_screen->updateScreen();
+	}
+
+	_textDimData[sdx].column += lw;
+	_numCharsPrinted += strlen(str);
+
+	str[s] = c;
+
+	if (c == ' ')
+		s++;
+
+	if (str[s] == ' ')
+		s++;
+
+	uint32 len = strlen(&str[s]);
+	for (uint32 i = 0; i < len; i++)
+		str[i] = str[s + i];
+	str[len] = 0;
+
+	_numCharsLeft = strlen(str);
+	_lineWidth = sjisTextMode ? (_numCharsLeft << 2) : (_screen->_currentFont == Screen::FID_SJIS_FNT ? _numCharsLeft * 9 : _screen->getTextWidth(str));
+
+	if (!_numCharsLeft && (_textDimData[sdx].column + twoByteCharOffs) <= (sd->w << 3))
+		return;
+
+	_textDimData[sdx].column = 0;
+	_textDimData[sdx].line++;
+	_lineCount++;
+
+	printLine(str);
+}
+
+void TextDisplayer_rpg::printDialogueText(int stringId, const char *pageBreakString) {
+	const char *str = (const char *)(_screen->getCPagePtr(5) + READ_LE_UINT16(&_screen->getCPagePtr(5)[(stringId - 1) << 1]));
+	assert(strlen(str) < kEoBTextBufferSize);
+	Common::strlcpy(_dialogueBuffer, str, kEoBTextBufferSize);
+
+	_screen->set16bitShadingLevel(4);
+	displayText(_dialogueBuffer);
+	_screen->set16bitShadingLevel(0);
+
+	if (pageBreakString) {
+		if (pageBreakString[0]) {
+			strcpy(_pageBreakString, pageBreakString);
+			displayWaitButton();
+			resetPageBreakString();
+		}
+	}
+}
+
+void TextDisplayer_rpg::printDialogueText(const char *str, bool wait) {
+	assert(strlen(str) < kEoBTextBufferSize);
+	Common::strlcpy(_dialogueBuffer, str, kEoBTextBufferSize);
+
+	strcpy(_dialogueBuffer, str);
+	displayText(_dialogueBuffer);
+	if (wait)
+		displayWaitButton();
+}
+
+void TextDisplayer_rpg::printMessage(const char *str, int textColor, ...) {
+	int tc = _textDimData[_screen->curDimIndex()].color1;
+
+	if (textColor != -1)
+		_textDimData[_screen->curDimIndex()].color1 = textColor;
+
+	va_list args;
+	va_start(args, textColor);
+	vsnprintf(_dialogueBuffer, kEoBTextBufferSize - 1, str, args);
+	va_end(args);
+
+	displayText(_dialogueBuffer);
+
+	if (_vm->game() != GI_EOB1)
+		_textDimData[_screen->curDimIndex()].color1 = tc;
+
+	if (!_screen->_curPage)
+		_screen->updateScreen();
+}
+
+int TextDisplayer_rpg::clearDim(int dim) {
+	int res = _screen->curDimIndex();
+	_screen->setScreenDim(dim);
+	_textDimData[dim].color1 = _screen->_curDim->unk8;
+	_textDimData[dim].color2 = _vm->game() == GI_LOL ? _screen->_curDim->unkA : _vm->guiSettings()->colors.fill;
+	clearCurDim();
+	return res;
+}
+
+void TextDisplayer_rpg::clearCurDim() {
+	int d = _screen->curDimIndex();
+	const ScreenDim *tmp = _screen->getScreenDim(d);
+	if (_vm->gameFlags().use16ColorMode) {
+		_screen->fillRect(tmp->sx << 3, tmp->sy, ((tmp->sx + tmp->w) << 3) - 2, (tmp->sy + tmp->h) - 2, _textDimData[d].color2);
+	} else
+		_screen->fillRect(tmp->sx << 3, tmp->sy, ((tmp->sx + tmp->w) << 3) - 1, (tmp->sy + tmp->h) - 1, _textDimData[d].color2);
+
+	_lineCount = 0;
+	_textDimData[d].column = _textDimData[d].line = 0;
+}
+
+void TextDisplayer_rpg::textPageBreak() {
+	if (_vm->game() != GI_LOL)
+		SWAP(_vm->_dialogueButtonLabelColor1, _vm->_dialogueButtonLabelColor2);
+
+	int cp = _screen->setCurPage(0);
+	Screen::FontId cf = _screen->setFont((_vm->gameFlags().lang == Common::JA_JPN && _vm->gameFlags().use16ColorMode) ? Screen::FID_SJIS_FNT : ((_vm->game() == GI_EOB2 && _vm->gameFlags().platform == Common::kPlatformFMTowns) ? Screen::FID_8_FNT : Screen::FID_6_FNT));
+
+	if (_vm->game() == GI_LOL)
+		_vm->_timer->pauseSingleTimer(11, true);
+
+	_vm->_fadeText = false;
+	int resetPortraitAfterSpeechAnim = 0;
+	int updatePortraitSpeechAnimDuration = 0;
+
+	if (_vm->_updateCharNum != -1)  {
+		resetPortraitAfterSpeechAnim = _vm->_resetPortraitAfterSpeechAnim;
+		_vm->_resetPortraitAfterSpeechAnim = 0;
+		updatePortraitSpeechAnimDuration = _vm->_updatePortraitSpeechAnimDuration;
+		if (_vm->_updatePortraitSpeechAnimDuration > 36)
+			_vm->_updatePortraitSpeechAnimDuration = 36;
+	}
+
+	uint32 speechPartTime = 0;
+	if (_vm->speechEnabled() && _vm->_activeVoiceFileTotalTime && _numCharsTotal)
+		speechPartTime = _vm->_system->getMillis() + ((_numCharsPrinted * _vm->_activeVoiceFileTotalTime) / _numCharsTotal);
+
+	const ScreenDim *dim = _screen->getScreenDim(_screen->curDimIndex());
+
+	int x = ((dim->sx + dim->w) << 3) - (_vm->_dialogueButtonWidth + 3);
+	int y = 0;
+	int w = _vm->_dialogueButtonWidth;
+
+	if (_vm->game() == GI_LOL) {
+		if (_vm->_needSceneRestore && (_vm->_updateFlags & 2)) {
+			if (_vm->_currentControlMode || !(_vm->_updateFlags & 2)) {
+				y = dim->sy + dim->h - 5;
+			} else {
+				x += 6;
+				y = dim->sy + dim->h - 2;
+			}
+		} else {
+			y = dim->sy + dim->h - 10;
+		}
+	} else {
+		y = _vm->guiSettings()->buttons.waitY[_waitButtonMode];
+		x = _vm->guiSettings()->buttons.waitX[_waitButtonMode];
+		w = _vm->guiSettings()->buttons.waitWidth[_waitButtonMode];
+	}
+
+	if (_vm->gameFlags().use16ColorMode) {
+		_vm->gui_drawBox(x + 8, (y & ~7) - 1, 66, 10, 0xEE, 0xCC, -1);
+		_screen->printText(_pageBreakString, (x + 37 - (strlen(_pageBreakString) << 1) + 4) & ~3, (y + 2) & ~7, 0xC1, 0);
+	} else {
+		int yOffs = (_vm->game() == GI_EOB2 && _vm->gameFlags().platform == Common::kPlatformFMTowns) ? 1 : 2;
+		_screen->set16bitShadingLevel(4);
+		_vm->gui_drawBox(x, y, w, _vm->guiSettings()->buttons.height, _vm->guiSettings()->colors.frame1, _vm->guiSettings()->colors.frame2, _vm->guiSettings()->colors.fill);
+		_screen->set16bitShadingLevel(0);
+		_screen->printText(_pageBreakString, x + (w >> 1) - (_vm->screen()->getTextWidth(_pageBreakString) >> 1), y + yOffs, _vm->_dialogueButtonLabelColor1, 0);
+	}
+
+	_vm->removeInputTop();
+
+	bool loop = true;
+	bool target = false;
+
+	do {
+		int inputFlag = _vm->checkInput(0, false) & 0xFF;
+		_vm->removeInputTop();
+
+		while (!inputFlag && !_vm->shouldQuit()) {
+			_vm->update();
+
+			if (_vm->speechEnabled()) {
+				if (((_vm->_system->getMillis() > speechPartTime) || (_vm->snd_updateCharacterSpeech() != 2)) && speechPartTime) {
+					loop = false;
+					inputFlag = _vm->_keyMap[Common::KEYCODE_RETURN];
+					break;
+				}
+			}
+
+			inputFlag = _vm->checkInput(0, false) & 0xFF;
+			_vm->removeInputTop();
+		}
+
+		_vm->gui_notifyButtonListChanged();
+
+		if (inputFlag == _vm->_keyMap[Common::KEYCODE_SPACE] || inputFlag == _vm->_keyMap[Common::KEYCODE_RETURN]) {
+			loop = false;
+		} else if (inputFlag == 199 || inputFlag == 201) {
+			if (_vm->posWithinRect(_vm->_mouseX, _vm->_mouseY, x, y, x + w, y + 9)) {
+				if (_vm->game() == GI_LOL)
+					target = true;
+				else
+					loop = false;
+			}
+		} else if (inputFlag == 200 || inputFlag == 202) {
+			if (target)
+				loop = false;
+		}
+	} while (loop && !_vm->shouldQuit());
+
+	_screen->set16bitShadingLevel(4);
+	if (_vm->gameFlags().use16ColorMode)
+		_screen->fillRect(x + 8, y, x + 57, y + 9, _textDimData[_screen->curDimIndex()].color2);
+	else
+		_screen->fillRect(x, y, x + w - 1, y + _vm->guiSettings()->buttons.height - 1, _textDimData[_screen->curDimIndex()].color2);
+
+	clearCurDim();
+	_screen->set16bitShadingLevel(0);
+	_screen->updateScreen();
+
+	if (_vm->game() == GI_LOL)
+		_vm->_timer->pauseSingleTimer(11, false);
+
+	if (_vm->_updateCharNum != -1) {
+		_vm->_resetPortraitAfterSpeechAnim = resetPortraitAfterSpeechAnim;
+		if (updatePortraitSpeechAnimDuration > 36)
+			updatePortraitSpeechAnimDuration -= 36;
+		else
+			updatePortraitSpeechAnimDuration >>= 1;
+
+		_vm->_updatePortraitSpeechAnimDuration = updatePortraitSpeechAnimDuration;
+	}
+
+	_screen->setFont(cf);
+	_screen->setCurPage(cp);
+
+	if (_vm->game() != GI_LOL)
+		SWAP(_vm->_dialogueButtonLabelColor1, _vm->_dialogueButtonLabelColor2);
+
+	_vm->removeInputTop();
+}
+
+void TextDisplayer_rpg::displayWaitButton() {
+	_vm->_dialogueNumButtons = 1;
+	_vm->_dialogueButtonString[0] = _pageBreakString;
+	_vm->_dialogueButtonString[1] = 0;
+	_vm->_dialogueButtonString[2] = 0;
+	_vm->_dialogueHighlightedButton = 0;
+
+	_vm->_dialogueButtonPosX = &_vm->guiSettings()->buttons.waitX[_waitButtonMode];
+	_vm->_dialogueButtonPosY = &_vm->guiSettings()->buttons.waitY[_waitButtonMode];
+	_vm->_dialogueButtonWidth = _vm->guiSettings()->buttons.waitWidth[_waitButtonMode];
+	_vm->_dialogueButtonYoffs = 0;
+
+	SWAP(_vm->_dialogueButtonLabelColor1, _vm->_dialogueButtonLabelColor2);
+	_vm->drawDialogueButtons();
+
+	if (!_vm->shouldQuit())
+		_vm->removeInputTop();
+
+	while (!_vm->processDialogue() && !_vm->shouldQuit()) {}
+
+	_screen->set16bitShadingLevel(4);
+	_screen->fillRect(_vm->_dialogueButtonPosX[0], _vm->_dialogueButtonPosY[0], _vm->_dialogueButtonPosX[0] + _vm->_dialogueButtonWidth - 1, _vm->_dialogueButtonPosY[0] + _vm->guiSettings()->buttons.height - 1, _vm->guiSettings()->colors.fill);
+	clearCurDim();
+	_screen->set16bitShadingLevel(0);
+	_screen->updateScreen();
+	_vm->_dialogueButtonWidth = 95;
+	SWAP(_vm->_dialogueButtonLabelColor1, _vm->_dialogueButtonLabelColor2);
+}
+
+} // End of namespace Kyra
+
+#endif // (ENABLE_EOB || ENABLE_LOL)
diff --git a/engines/kyra/text/text_rpg.h b/engines/kyra/text/text_rpg.h
new file mode 100644
index 0000000000..30d3463726
--- /dev/null
+++ b/engines/kyra/text/text_rpg.h
@@ -0,0 +1,115 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#if defined(ENABLE_EOB) || defined(ENABLE_LOL)
+
+#ifndef KYRA_TEXT_EOB_H
+#define KYRA_TEXT_EOB_H
+
+#include "common/scummsys.h"
+
+namespace Kyra {
+
+class Screen;
+class KyraRpgEngine;
+
+class TextDisplayer_rpg {
+public:
+	TextDisplayer_rpg(KyraRpgEngine *engine, Screen *scr);
+	virtual ~TextDisplayer_rpg();
+
+	void setupField(int dim, bool mode);
+
+	void printDialogueText(int stringId, const char *pageBreakString);
+	void printDialogueText(const char *str, bool wait = false);
+	void printMessage(const char *str, int textColor = -1, ...);
+
+	int clearDim(int dim);
+	void clearCurDim();
+
+	void resetDimTextPositions(int dim);
+	void resetPageBreakString();
+	void setPageBreakFlag();
+	void removePageBreakFlag();
+
+	void allowPageBreak(bool mode) { _allowPageBreak = mode; }
+	void setWaitButtonMode(int mode) { _waitButtonMode = mode; }
+	int lineCount() { return _lineCount; }
+
+protected:
+	virtual KyraRpgEngine *vm() { return _vm; }
+	virtual Screen *screen() { return _screen; }
+
+	void displayText(char *str, ...);
+	char parseCommand();
+	void readNextPara();
+	void printLine(char *str);
+	virtual void textPageBreak();
+	void displayWaitButton();
+
+	char *_dialogueBuffer;
+
+	char *_tempString1;
+	char *_tempString2;
+	char *_currentLine;
+	char _ctrl[3];
+
+	uint16 _lineWidth;
+	uint32 _numCharsTotal;
+	uint32 _numCharsLeft;
+	uint32 _numCharsPrinted;
+
+	bool _printFlag;
+	bool _sjisTextModeLineBreak;
+
+	char _pageBreakString[20];
+	char _scriptParaString[11];
+	int _lineCount;
+
+	bool _allowPageBreak;
+	int _waitButtonSpace;
+	int _waitButtonMode;
+
+	static const char _pageBreakDefault[3][5];
+
+	struct TextDimData {
+		uint8 color1;
+		uint8 color2;
+		uint16 column;
+		uint8 line;
+	};
+
+	TextDimData *_textDimData;
+
+private:
+	KyraRpgEngine *_vm;
+	Screen *_screen;
+
+	char *_table1;
+	char *_table2;
+};
+
+} // End of namespace Kyra
+
+#endif
+
+#endif // ENABLE_EOB || ENABLE_LOL