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.

1 files changed, 4513 insertions, 0 deletions

diff --git a/engines/kyra/engine/lol.cpp b/engines/kyra/engine/lol.cpp
new file mode 100644
index 0000000000..9cf045a876
--- /dev/null
+++ b/engines/kyra/engine/lol.cpp
@@ -0,0 +1,4513 @@
+/* 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/engine/lol.h"
+#include "kyra/graphics/screen_lol.h"
+#include "kyra/resource/resource.h"
+#include "kyra/engine/timer.h"
+#include "kyra/engine/util.h"
+#include "kyra/gui/debugger.h"
+#include "kyra/sound/sound.h"
+
+#include "audio/audiostream.h"
+
+#include "common/config-manager.h"
+#include "common/system.h"
+#include "common/translation.h"
+
+#include "backends/keymapper/keymapper.h"
+
+namespace Kyra {
+
+const char *const LoLEngine::kKeymapName = "lol";
+
+LoLEngine::LoLEngine(OSystem *system, const GameFlags &flags) : KyraRpgEngine(system, flags) {
+	_screen = 0;
+	_gui = 0;
+	_tim = 0;
+
+	_lang = 0;
+	Common::Language lang = Common::parseLanguage(ConfMan.get("language"));
+	if (lang == _flags.fanLang && _flags.replacedLang != Common::UNK_LANG)
+		lang = _flags.replacedLang;
+
+	switch (lang) {
+	case Common::EN_ANY:
+	case Common::EN_USA:
+	case Common::EN_GRB:
+		_lang = 0;
+		break;
+
+	case Common::FR_FRA:
+		_lang = 1;
+		break;
+
+	case Common::DE_DEU:
+		_lang = 2;
+		break;
+
+	case Common::JA_JPN:
+		_lang = 0;
+		break;
+
+	default:
+		warning("unsupported language, switching back to English");
+		_lang = 0;
+	}
+
+	_chargenFrameTable = _flags.isTalkie ? _chargenFrameTableTalkie : _chargenFrameTableFloppy;
+	_chargenWSA = 0;
+	_lastUsedStringBuffer = 0;
+	_landsFile = 0;
+	_levelLangFile = 0;
+
+	_lastMusicTrack = -1;
+	_lastSfxTrack = -1;
+	_curTlkFile = -1;
+	_lastSpeaker = _lastSpeechId = _nextSpeechId = _nextSpeaker = -1;
+
+	memset(_moneyColumnHeight, 0, sizeof(_moneyColumnHeight));
+	_credits = 0;
+
+	_itemsInPlay = 0;
+	_itemProperties = 0;
+	_itemInHand = 0;
+	memset(_inventory, 0, sizeof(_inventory));
+	memset(_charStatusFlags, 0, sizeof(_charStatusFlags));
+	_inventoryCurItem = 0;
+	_lastCharInventory = -1;
+	_emcLastItem = -1;
+
+	_itemIconShapes = _itemShapes = _gameShapes = _thrownShapes = _effectShapes = _fireballShapes = _healShapes = _healiShapes = 0;
+	_levelShpList = _levelDatList = 0;
+	_gameShapeMap = 0;
+	memset(_monsterAnimType, 0, 3);
+	_healOverlay = 0;
+	_swarmSpellStatus = 0;
+
+	_ingameMT32SoundIndex = _ingameGMSoundIndex = _ingamePCSpeakerSoundIndex = 0;
+
+	_charSelection = -1;
+	_characters = 0;
+	_spellProperties = 0;
+	_selectedSpell = 0;
+	_updateCharNum = _portraitSpeechAnimMode = _textColorFlag = 0;
+	_palUpdateTimer = _updatePortraitNext = 0;
+	_lampStatusTimer = 0xFFFFFFFF;
+
+	_weaponsDisabled = false;
+	_charInventoryUnk = 0;
+	_lastButtonShape = 0;
+	_buttonPressTimer = 0;
+	_selectedCharacter = 0;
+	_suspendScript = false;
+	_scriptDirection = 0;
+	_compassDirectionIndex = -1;
+	_compassStep = 0;
+
+	_smoothScrollModeNormal = 1;
+	_wllAutomapData = 0;
+	_sceneXoffset = 112;
+	_sceneShpDim = 13;
+	_monsters = 0;
+	_monsterProperties = 0;
+	_lvlShapeIndex = 0;
+	_partyAwake = true;
+	_transparencyTable2 = 0;
+	_transparencyTable1 = 0;
+	_specialGuiShape = 0;
+	_specialGuiShapeX = _specialGuiShapeY = _specialGuiShapeMirrorFlag = 0;
+	memset(_characterFaceShapes, 0, sizeof(_characterFaceShapes));
+
+	_lampEffect = _brightness = _lampOilStatus = 0;
+	_lampStatusSuspended = false;
+	_tempBuffer5120 = 0;
+	_flyingObjects = 0;
+	_monsters = 0;
+	_lastMouseRegion = 0;
+	_objectLastDirection = 0;
+	_monsterCurBlock = 0;
+	_seqWindowX1 = _seqWindowY1 = _seqWindowX2 = _seqWindowY2 = _seqTrigger = 0;
+	_spsWindowX = _spsWindowY = _spsWindowW = _spsWindowH = 0;
+
+	_dscWalls = 0;
+	_dscOvlMap = 0;
+	_dscShapeScaleW = 0;
+	_dscShapeScaleH = 0;
+	_dscShapeY = 0;
+	_dscShapeOvlIndex = 0;
+	_dscDoorMonsterX = _dscDoorMonsterY = 0;
+	_dscDoor4 = 0;
+
+	_ingameSoundList = 0;
+	_ingameSoundIndex = 0;
+	_ingameSoundListSize = 0;
+	_musicTrackMap = 0;
+	_curMusicTheme = -1;
+	_curMusicFileExt = 0;
+	_curMusicFileIndex = -1;
+	_envSfxUseQueue = false;
+	_envSfxNumTracksInQueue = 0;
+	memset(_envSfxQueuedTracks, 0, sizeof(_envSfxQueuedTracks));
+	memset(_envSfxQueuedBlocks, 0, sizeof(_envSfxQueuedBlocks));
+
+	_partyPosX = _partyPosY = 0;
+	_shpDmX = _shpDmY = _dmScaleW = _dmScaleH = 0;
+
+	_floatingCursorControl = _currentFloatingCursor = 0;
+
+	memset(_activeTim, 0, sizeof(_activeTim));
+	memset(&_activeSpell, 0, sizeof(_activeSpell));
+
+	_pageBuffer1 = _pageBuffer2 = 0;
+
+	memset(_charStatsTemp, 0, sizeof(_charStatsTemp));
+
+	_compassBroken = _drainMagic = 0;
+
+	_buttonData = 0;
+	_preserveEvents = false;
+	_buttonList1 = _buttonList2 = _buttonList3 = _buttonList4 = _buttonList5 = _buttonList6 = _buttonList7 = _buttonList8 = 0;
+
+	_mapOverlay = 0;
+	_automapShapes = 0;
+	_defaultLegendData = 0;
+	_mapCursorOverlay = 0;
+
+	_lightningProps = 0;
+	_lightningCurSfx = -1;
+	_lightningDiv = 0;
+	_lightningFirstSfx = 0;
+	_lightningSfxFrame = 0;
+
+	_compassTimer = 0;
+	_scriptCharacterCycle = 0;
+	_partyDamageFlags = -1;
+
+	memset(&_itemScript, 0, sizeof(_itemScript));
+}
+
+LoLEngine::~LoLEngine() {
+	setupPrologueData(false);
+	releaseTempData();
+
+	delete[] _landsFile;
+	delete[] _levelLangFile;
+
+	delete _screen;
+	_screen = 0;
+	delete _gui;
+	_gui = 0;
+	delete _tim;
+	_tim = 0;
+	delete _txt;
+	_txt = 0;
+
+	delete[] _itemsInPlay;
+	delete[] _itemProperties;
+	delete[] _characters;
+
+	delete[] _pageBuffer1;
+	delete[] _pageBuffer2;
+
+	if (_itemIconShapes) {
+		for (int i = 0; i < _numItemIconShapes; i++)
+			delete[]  _itemIconShapes[i];
+		delete[] _itemIconShapes;
+	}
+
+	if (_itemShapes) {
+		for (int i = 0; i < _numItemShapes; i++)
+			delete[]  _itemShapes[i];
+		delete[] _itemShapes;
+	}
+
+	if (_gameShapes) {
+		for (int i = 0; i < _numGameShapes; i++)
+			delete[]  _gameShapes[i];
+		delete[] _gameShapes;
+	}
+
+	if (_thrownShapes) {
+		for (int i = 0; i < _numThrownShapes; i++)
+			delete[]  _thrownShapes[i];
+		delete[] _thrownShapes;
+	}
+
+	if (_effectShapes) {
+		for (int i = 0; i < _numEffectShapes; i++)
+			delete[]  _effectShapes[i];
+		delete[] _effectShapes;
+	}
+
+	if (_fireballShapes) {
+		for (int i = 0; i < _numFireballShapes; i++)
+			delete[]  _fireballShapes[i];
+		delete[] _fireballShapes;
+	}
+
+	if (_healShapes) {
+		for (int i = 0; i < _numHealShapes; i++)
+			delete[]  _healShapes[i];
+		delete[] _healShapes;
+	}
+
+	if (_healiShapes) {
+		for (int i = 0; i < _numHealiShapes; i++)
+			delete[]  _healiShapes[i];
+		delete[] _healiShapes;
+	}
+
+	if (_monsterDecorationShapes) {
+		for (int i = 0; i < 3; i++)
+			releaseMonsterShapes(i);
+
+		delete[] _monsterShapes;
+		_monsterShapes = 0;
+		delete[] _monsterPalettes;
+		_monsterPalettes = 0;
+		delete[] _monsterDecorationShapes;
+		_monsterDecorationShapes = 0;
+	}
+
+	for (int i = 0; i < 6; i++) {
+		delete[] _doorShapes[i];
+		_doorShapes[i] = 0;
+	}
+
+	releaseDecorations();
+
+	delete[] _automapShapes;
+
+	for (Common::Array<const TIMOpcode *>::iterator i = _timIntroOpcodes.begin(); i != _timIntroOpcodes.end(); ++i)
+		delete *i;
+	_timIntroOpcodes.clear();
+
+	for (Common::Array<const TIMOpcode *>::iterator i = _timOutroOpcodes.begin(); i != _timOutroOpcodes.end(); ++i)
+		delete *i;
+	_timOutroOpcodes.clear();
+
+	for (Common::Array<const TIMOpcode *>::iterator i = _timIngameOpcodes.begin(); i != _timIngameOpcodes.end(); ++i)
+		delete *i;
+	_timIngameOpcodes.clear();
+
+	delete[] _wllAutomapData;
+	delete[] _tempBuffer5120;
+	delete[] _flyingObjects;
+	delete[] _monsters;
+	delete[] _monsterProperties;
+
+	delete[] _transparencyTable2;
+	delete[] _transparencyTable1;
+	delete[] _lightningProps;
+
+	delete _lvlShpFileHandle;
+
+	if (_ingameSoundList) {
+		for (int i = 0; i < _ingameSoundListSize; i++)
+			delete[] _ingameSoundList[i];
+		delete[] _ingameSoundList;
+	}
+
+	for (int i = 0; i < 3; i++) {
+		for (int ii = 0; ii < 40; ii++)
+			delete[] _characterFaceShapes[ii][i];
+	}
+
+	delete[] _healOverlay;
+
+	delete[] _defaultLegendData;
+	delete[] _mapCursorOverlay;
+	delete[] _mapOverlay;
+
+	for (Common::Array<const SpellProc *>::iterator i = _spellProcs.begin(); i != _spellProcs.end(); ++i)
+		delete *i;
+	_spellProcs.clear();
+
+	for (SpeechList::iterator i = _speechList.begin(); i != _speechList.end(); ++i)
+		delete *i;
+	_speechList.clear();
+
+	_emc->unload(&_itemScript);
+	_emc->unload(&_scriptData);
+}
+
+Screen *LoLEngine::screen() {
+	return _screen;
+}
+
+GUI *LoLEngine::gui() const {
+	return _gui;
+}
+
+Common::Error LoLEngine::init() {
+	_screen = new Screen_LoL(this, _system);
+	assert(_screen);
+	_screen->setResolution();
+
+	_debugger = new Debugger_LoL(this);
+	assert(_debugger);
+
+	KyraEngine_v1::init();
+	initStaticResource();
+
+	_gui = new GUI_LoL(this);
+	assert(_gui);
+	_gui->initStaticData();
+
+	_txt = new TextDisplayer_LoL(this, _screen);
+
+	_screen->setAnimBlockPtr(10000);
+	_screen->setScreenDim(0);
+
+	_pageBuffer1 = new uint8[0xFA00];
+	memset(_pageBuffer1, 0, 0xFA00);
+	_pageBuffer2 = new uint8[0xFA00];
+	memset(_pageBuffer2, 0, 0xFA00);
+
+	_itemsInPlay = new LoLItem[400];
+	memset(_itemsInPlay, 0, sizeof(LoLItem) * 400);
+
+	_characters = new LoLCharacter[4];
+	memset(_characters, 0, sizeof(LoLCharacter) * 4);
+
+	if (!_sound->init())
+		error("Couldn't init sound");
+
+	KyraRpgEngine::init();
+
+	_wllAutomapData = new uint8[80];
+	memset(_wllAutomapData, 0, 80);
+
+	_monsters = new LoLMonster[30];
+	memset(_monsters, 0, 30 * sizeof(LoLMonster));
+	_monsterProperties = new LoLMonsterProperty[5];
+	memset(_monsterProperties, 0, 5 * sizeof(LoLMonsterProperty));
+
+	_tempBuffer5120 = new uint8[5120];
+	memset(_tempBuffer5120, 0, 5120);
+
+	_flyingObjects = new FlyingObject[_numFlyingObjects];
+	_flyingObjectsPtr = _flyingObjects;
+	_flyingObjectStructSize = sizeof(FlyingObject);
+	memset(_flyingObjects, 0, _numFlyingObjects * sizeof(FlyingObject));
+
+	memset(_globalScriptVars, 0, sizeof(_globalScriptVars));
+
+	_lvlShpFileHandle = 0;
+
+	_sceneDrawPage1 = 2;
+	_sceneDrawPage2 = 6;
+
+	_clickedShapeXOffs = 136;
+	_clickedShapeYOffs = 8;
+	_clickedSpecialFlag = 0x40;
+
+	_monsterShapes = new uint8*[48];
+	memset(_monsterShapes, 0, 48 * sizeof(uint8 *));
+	_monsterPalettes = new uint8*[48];
+	memset(_monsterPalettes, 0, 48 * sizeof(uint8 *));
+	_monsterDecorationShapes = new uint8*[576];
+	memset(_monsterDecorationShapes, 0, 576 * sizeof(uint8 *));
+	memset(&_scriptData, 0, sizeof(EMCData));
+
+	_activeMagicMenu = -1;
+
+	_automapShapes = new const uint8*[109];
+	_mapOverlay = new uint8[256];
+
+	memset(_availableSpells, -1, 8);
+
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castSpark));
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castHeal));
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castIce));
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castFireball));
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castHandOfFate));
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castMistOfDoom));
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castLightning));
+	_spellProcs.push_back(new SpellProc(this, 0));
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castFog));
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castSwarm));
+	_spellProcs.push_back(new SpellProc(this, 0));
+	_spellProcs.push_back(new SpellProc(this, 0));
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castVaelansCube));
+	_spellProcs.push_back(new SpellProc(this, 0));
+	_spellProcs.push_back(new SpellProc(this, 0));
+	_spellProcs.push_back(new SpellProc(this, 0));
+	_spellProcs.push_back(new SpellProc(this, &LoLEngine::castGuardian));
+
+#ifdef ENABLE_KEYMAPPER
+	_eventMan->getKeymapper()->pushKeymap(kKeymapName, true);
+#endif
+
+	return Common::kNoError;
+}
+
+void LoLEngine::initKeymap() {
+#ifdef ENABLE_KEYMAPPER
+	Common::Keymapper *const mapper = _eventMan->getKeymapper();
+
+	// Do not try to recreate same keymap over again
+	if (mapper->getKeymap(kKeymapName) != 0)
+		return;
+
+	Common::Keymap *const engineKeyMap = new Common::Keymap(kKeymapName);
+
+	const Common::KeyActionEntry keyActionEntries[] = {
+		{Common::KeyState(Common::KEYCODE_F1, Common::ASCII_F1), "AT1", _("Attack 1")},
+		{Common::KeyState(Common::KEYCODE_F2, Common::ASCII_F2), "AT2", _("Attack 2")},
+		{Common::KeyState(Common::KEYCODE_F3, Common::ASCII_F3), "AT3", _("Attack 3")},
+		{Common::KeyState(Common::KEYCODE_UP), "MVF", _("Move Forward")},
+		{Common::KeyState(Common::KEYCODE_DOWN), "MVB", _("Move Back")},
+		{Common::KeyState(Common::KEYCODE_LEFT), "SLL", _("Slide Left")},
+		{Common::KeyState(Common::KEYCODE_RIGHT), "SLR", _("Slide Right")},
+		{Common::KeyState(Common::KEYCODE_HOME), "TL", _("Turn Left")},
+		{Common::KeyState(Common::KEYCODE_PAGEUP), "TR", _("Turn Right")},
+		{Common::KeyState(Common::KEYCODE_r), "RST", _("Rest")},
+		{Common::KeyState(Common::KEYCODE_o), "OPT", _("Options")},
+		{Common::KeyState(Common::KEYCODE_SLASH), "SPL", _("Choose Spell")},
+		{Common::KeyState(), 0, 0}
+	};
+
+	for (const Common::KeyActionEntry *entry = keyActionEntries; entry->id; ++entry) {
+		Common::Action *const act = new Common::Action(engineKeyMap, entry->id, entry->description);
+		act->addKeyEvent(entry->ks);
+	}
+
+	mapper->addGameKeymap(engineKeyMap);
+#endif
+}
+
+void LoLEngine::pauseEngineIntern(bool pause) {
+	KyraEngine_v1::pauseEngineIntern(pause);
+	pauseDemoPlayer(pause);
+}
+
+Common::Error LoLEngine::go() {
+	int action = -1;
+
+	if (_gameToLoad == -1) {
+		action = processPrologue();
+		if (action == -1)
+			return Common::kNoError;
+	}
+
+	if (_flags.isTalkie && !_flags.isDemo) {
+		if (!_res->loadFileList("FILEDATA.FDT"))
+			error("Couldn't load file list: 'FILEDATA.FDT'");
+	} else if (_pakFileList) {
+		_res->loadFileList(_pakFileList, _pakFileListSize);
+	}
+
+	// Usually fonts etc. would be setup by the prologue code, if we skip
+	// the prologue code we need to setup them manually here.
+	if (_gameToLoad != -1 && action != 3) {
+		preInit();
+		_screen->setFont((_flags.lang == Common::JA_JPN && _flags.use16ColorMode) ? Screen::FID_SJIS_FNT : Screen::FID_9_FNT);
+	}
+
+	// We have three sound.dat files, one for the intro, one for the
+	// end sequence and one for ingame, each contained in a different
+	// PAK file. Therefore a new call to loadSoundFile() is required
+	// whenever the PAK file configuration changes.
+	if (_flags.platform == Common::kPlatformPC98)
+		_sound->loadSoundFile("sound.dat");
+
+	_sound->selectAudioResourceSet(kMusicIngame);
+	if (_flags.platform != Common::kPlatformDOS)
+		_sound->loadSoundFile(0);
+
+	_tim = new TIMInterpreter_LoL(this, _screen, _system);
+	assert(_tim);
+
+	if (shouldQuit())
+		return Common::kNoError;
+
+	startup();
+
+	if (action == 0) {
+		startupNew();
+	} else if (_gameToLoad != -1) {
+		// FIXME: Instead of throwing away the error returned by
+		// loadGameState, we should use it / augment it.
+		if (loadGameState(_gameToLoad).getCode() != Common::kNoError)
+			error("Couldn't load game slot %d on startup", _gameToLoad);
+		_gameToLoad = -1;
+	}
+
+	_screen->_fadeFlag = 3;
+	_sceneUpdateRequired = true;
+	enableSysTimer(1);
+	runLoop();
+
+	return Common::kNoError;
+}
+
+#pragma mark - Initialization
+
+void LoLEngine::preInit() {
+	_res->loadPakFile("GENERAL.PAK");
+	if (_flags.isTalkie)
+		_res->loadPakFile("STARTUP.PAK");
+
+	_screen->loadFont(Screen::FID_9_FNT, "FONT9P.FNT");
+	_screen->loadFont(Screen::FID_6_FNT, "FONT6P.FNT");
+
+	loadTalkFile(0);
+
+	Common::String filename;
+	filename = Common::String::format("LANDS.%s", _languageExt[_lang]);
+	_res->exists(filename.c_str(), true);
+	delete[] _landsFile;
+	_landsFile = _res->fileData(filename.c_str(), 0);
+	loadItemIconShapes();
+}
+
+void LoLEngine::loadItemIconShapes() {
+	if (_itemIconShapes) {
+		for (int i = 0; i < _numItemIconShapes; i++)
+			delete[]  _itemIconShapes[i];
+		delete[] _itemIconShapes;
+	}
+
+	_screen->loadBitmap("ITEMICN.SHP", 3, 3, 0);
+	const uint8 *shp = _screen->getCPagePtr(3);
+	_numItemIconShapes = READ_LE_UINT16(shp);
+	_itemIconShapes = new uint8*[_numItemIconShapes];
+	for (int i = 0; i < _numItemIconShapes; i++)
+		_itemIconShapes[i] = _screen->makeShapeCopy(shp, i);
+
+	_screen->setMouseCursor(0, 0, _itemIconShapes[0]);
+
+	if (!_gameShapes) {
+		_screen->loadBitmap("GAMESHP.SHP", 3, 3, 0);
+		shp = _screen->getCPagePtr(3);
+		_numGameShapes = READ_LE_UINT16(shp);
+		_gameShapes = new uint8*[_numGameShapes];
+		for (int i = 0; i < _numGameShapes; i++)
+			_gameShapes[i] = _screen->makeShapeCopy(shp, i);
+	}
+}
+
+void LoLEngine::setMouseCursorToIcon(int icon) {
+	_flagsTable[31] |= 0x02;
+	int i = _itemProperties[_itemsInPlay[_itemInHand].itemPropertyIndex].shpIndex;
+	if (i == icon)
+		return;
+	_screen->setMouseCursor(0, 0, _itemIconShapes[icon]);
+}
+
+void LoLEngine::setMouseCursorToItemInHand() {
+	_flagsTable[31] &= 0xFD;
+	int o = (_itemInHand == 0) ? 0 : 10;
+	_screen->setMouseCursor(o, o, getItemIconShapePtr(_itemInHand));
+}
+
+void LoLEngine::checkFloatingPointerRegions() {
+	if (!_floatingCursorsEnabled)
+		return;
+
+	int t = -1;
+
+	Common::Point p = getMousePos();
+
+	if (!(_updateFlags & 4) & !_floatingCursorControl) {
+		if (posWithinRect(p.x, p.y, 96, 0, 303, 136)) {
+			if (!posWithinRect(p.x, p.y, 128, 16, 271, 119)) {
+				if (posWithinRect(p.x, p.y, 112, 0, 287, 15))
+					t = 0;
+				if (posWithinRect(p.x, p.y, 272, 88, 303, 319))
+					t = 1;
+				if (posWithinRect(p.x, p.y, 112, 110, 287, 135))
+					t = 2;
+				if (posWithinRect(p.x, p.y, 96, 88, 127, 119))
+					t = 3;
+				if (posWithinRect(p.x, p.y, 96, 16, 127, 87))
+					t = 4;
+				if (posWithinRect(p.x, p.y, 272, 16, 303, 87))
+					t = 5;
+
+				if (t < 4) {
+					int d = (_currentDirection + t) & 3;
+					if (!checkBlockPassability(calcNewBlockPosition(_currentBlock, d), d))
+						t = 6;
+				}
+			}
+		}
+	}
+
+	if (t == _currentFloatingCursor)
+		return;
+
+	if (t == -1) {
+		setMouseCursorToItemInHand();
+	} else {
+		static const uint8 floatingPtrX[] = { 7, 13, 7, 0, 0, 15, 7 };
+		static const uint8 floatingPtrY[] = { 0, 7, 12, 7, 6, 6, 7 };
+		_screen->setMouseCursor(floatingPtrX[t], floatingPtrY[t], _gameShapes[10 + t]);
+	}
+
+	_currentFloatingCursor = t;
+}
+
+uint8 *LoLEngine::getItemIconShapePtr(int index) {
+	int ix = _itemProperties[_itemsInPlay[index].itemPropertyIndex].shpIndex;
+	if (_itemProperties[_itemsInPlay[index].itemPropertyIndex].flags & 0x200)
+		ix += (_itemsInPlay[index].shpCurFrame_flg & 0x1FFF) - 1;
+
+	return _itemIconShapes[ix];
+}
+
+int LoLEngine::mainMenu() {
+	bool hasSave = saveFileLoadable(0);
+
+	MainMenu::StaticData data[] = {
+		// 256 color ASCII mode
+		{
+			{ 0, 0, 0, 0, 0 },
+			{ 0x01, 0x04, 0x0C, 0x04, 0x00, 0x3D, 0x9F },
+			{ 0x2C, 0x19, 0x48, 0x2C },
+			Screen::FID_9_FNT, 1
+		},
+		// 16 color SJIS mode
+		{
+			{ 0, 0, 0, 0, 0 },
+			{ 0x01, 0x04, 0x0C, 0x04, 0x00, 0xC1, 0xE1 },
+			{ 0xCC, 0xDD, 0xDD, 0xDD },
+			Screen::FID_SJIS_FNT, 1
+		}
+	};
+
+	int dataIndex = _flags.use16ColorMode ? 1 : 0;
+
+	if (!_flags.isTalkie)
+		--data[dataIndex].menuTable[3];
+
+	if (hasSave)
+		++data[dataIndex].menuTable[3];
+
+	static const uint16 mainMenuStrings[4][5] = {
+		{ 0x4248, 0x4249, 0x42DD, 0x424A, 0x0000 },
+		{ 0x4248, 0x4249, 0x42DD, 0x4001, 0x424A },
+		{ 0x4248, 0x4249, 0x424A, 0x0000, 0x0000 },
+		{ 0x4248, 0x4249, 0x4001, 0x424A, 0x0000 }
+	};
+
+	int tableOffs = _flags.isTalkie ? 0 : 2;
+
+	for (int i = 0; i < 5; ++i) {
+		if (hasSave)
+			data[dataIndex].strings[i] = getLangString(mainMenuStrings[1 + tableOffs][i]);
+		else
+			data[dataIndex].strings[i] = getLangString(mainMenuStrings[tableOffs][i]);
+	}
+
+	MainMenu *menu = new MainMenu(this);
+	assert(menu);
+	menu->init(data[dataIndex], MainMenu::Animation());
+
+	int selection = menu->handle(_flags.isTalkie ? (hasSave ? 19 : 6) : (hasSave ? 6 : 20));
+	delete menu;
+	_screen->setScreenDim(0);
+
+	if (!_flags.isTalkie && selection >= 2)
+		selection++;
+
+	if (!hasSave && selection == 3)
+		selection = 4;
+
+	return selection;
+}
+
+void LoLEngine::startup() {
+	_screen->clearPage(0);
+
+	Palette &pal = _screen->getPalette(0);
+	_screen->loadBitmap("PLAYFLD.CPS", 3, 3, &pal);
+
+	if (_flags.use16ColorMode) {
+		memset(_screen->_paletteOverlay1, 0, 256);
+		memset(_screen->_paletteOverlay2, 0, 256);
+
+		static const uint8 colTable1[] = { 0x00, 0xEE, 0xCC, 0xFF, 0x44, 0x66, 0x44, 0x88, 0xEE, 0xAA, 0x11, 0xCC, 0xDD, 0xEE, 0x44, 0xCC };
+		static const uint8 colTable2[] = { 0x00, 0xCC, 0xFF, 0xBB, 0xEE, 0xBB, 0x55, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xFF, 0xCC, 0xDD, 0xBB };
+		static const uint8 colTable3[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
+
+		for (int i = 0; i < 16; i++) {
+			_screen->_paletteOverlay1[colTable3[i]] = colTable1[i];
+			_screen->_paletteOverlay2[colTable3[i]] = colTable2[i];
+		}
+
+	} else {
+		_screen->copyPalette(1, 0);
+		pal.fill(0, 1, 0x3F);
+		pal.fill(2, 126, 0x3F);
+		pal.fill(192, 4, 0x3F);
+		_screen->generateOverlay(pal, _screen->_paletteOverlay1, 1, 96, 254);
+		_screen->generateOverlay(pal, _screen->_paletteOverlay2, 144, 65, 254);
+		_screen->copyPalette(0, 1);
+	}
+
+	_screen->getPalette(1).clear();
+	_screen->getPalette(2).clear();
+
+	loadItemIconShapes();
+	_screen->setMouseCursor(0, 0, _itemIconShapes[0x85]);
+
+	_screen->loadBitmap("ITEMSHP.SHP", 3, 3, 0);
+	const uint8 *shp = _screen->getCPagePtr(3);
+	_numItemShapes = READ_LE_UINT16(shp);
+	_itemShapes = new uint8*[_numItemShapes];
+	for (int i = 0; i < _numItemShapes; i++)
+		_itemShapes[i] = _screen->makeShapeCopy(shp, i);
+
+	_screen->loadBitmap("THROWN.SHP", 3, 3, 0);
+	shp = _screen->getCPagePtr(3);
+	_numThrownShapes = READ_LE_UINT16(shp);
+	_thrownShapes = new uint8*[_numThrownShapes];
+	for (int i = 0; i < _numThrownShapes; i++)
+		_thrownShapes[i] = _screen->makeShapeCopy(shp, i);
+
+	_screen->loadBitmap("ICE.SHP", 3, 3, 0);
+	shp = _screen->getCPagePtr(3);
+	_numEffectShapes = READ_LE_UINT16(shp);
+	_effectShapes = new uint8*[_numEffectShapes];
+	for (int i = 0; i < _numEffectShapes; i++)
+		_effectShapes[i] = _screen->makeShapeCopy(shp, i);
+
+	_screen->loadBitmap("FIREBALL.SHP", 3, 3, 0);
+	shp = _screen->getCPagePtr(3);
+	_numFireballShapes = READ_LE_UINT16(shp);
+	_fireballShapes = new uint8*[_numFireballShapes];
+	for (int i = 0; i < _numFireballShapes; i++)
+		_fireballShapes[i] = _screen->makeShapeCopy(shp, i);
+
+	_screen->loadBitmap("HEAL.SHP", 3, 3, 0);
+	shp = _screen->getCPagePtr(3);
+	_numHealShapes = READ_LE_UINT16(shp);
+	_healShapes = new uint8*[_numHealShapes];
+	for (int i = 0; i < _numHealShapes; i++)
+		_healShapes[i] = _screen->makeShapeCopy(shp, i);
+
+	_screen->loadBitmap("HEALI.SHP", 3, 3, 0);
+	shp = _screen->getCPagePtr(3);
+	_numHealiShapes = READ_LE_UINT16(shp);
+	_healiShapes = new uint8*[_numHealiShapes];
+	for (int i = 0; i < _numHealiShapes; i++)
+		_healiShapes[i] = _screen->makeShapeCopy(shp, i);
+
+	memset(_itemsInPlay, 0, 400 * sizeof(LoLItem));
+	for (int i = 0; i < 400; i++)
+		_itemsInPlay[i].shpCurFrame_flg |= 0x8000;
+
+	runInitScript("ONETIME.INF", 0);
+	_emc->load("ITEM.INF", &_itemScript, &_opcodes);
+
+	_transparencyTable1 = new uint8[256];
+	_transparencyTable2 = new uint8[5120];
+
+	_loadSuppFilesFlag = 1;
+
+	_sound->loadSfxFile("LORESFX");
+
+	setMouseCursorToItemInHand();
+}
+
+void LoLEngine::startupNew() {
+	_selectedSpell = 0;
+	_compassStep = 0;
+	_compassDirection = _compassDirectionIndex = -1;
+
+	_lastMouseRegion = -1;
+	_currentLevel = 1;
+
+	giveCredits(41, 0);
+	_inventory[0] = makeItem(216, 0, 0);
+	_inventory[1] = makeItem(217, 0, 0);
+	_inventory[2] = makeItem(218, 0, 0);
+
+	_availableSpells[0] = 0;
+	setupScreenDims();
+
+	Common::fill(_globalScriptVars2, ARRAYEND(_globalScriptVars2), 0x100);
+
+	static const int selectIds[] = { -9, -1, -8, -5 };
+	assert(_charSelection >= 0);
+	assert(_charSelection < ARRAYSIZE(selectIds));
+	addCharacter(selectIds[_charSelection]);
+
+	gui_enableDefaultPlayfieldButtons();
+
+	loadLevel(_currentLevel);
+
+	_screen->showMouse();
+}
+
+void LoLEngine::runLoop() {
+	// Initialize debugger since how it should be fully usable
+	_debugger->initialize();
+
+	enableSysTimer(2);
+
+	_flagsTable[73] |= 0x08;
+
+	while (!shouldQuit()) {
+		if (_gameToLoad != -1) {
+			// FIXME: Instead of throwing away the error returned by
+			// loadGameState, we should use it / augment it.
+			if (loadGameState(_gameToLoad).getCode() != Common::kNoError)
+				error("Couldn't load game slot %d", _gameToLoad);
+			_gameToLoad = -1;
+		}
+
+		if (_nextScriptFunc) {
+			runLevelScript(_nextScriptFunc, 2);
+			_nextScriptFunc = 0;
+		}
+
+		_timer->update();
+
+		checkFloatingPointerRegions();
+		gui_updateInput();
+
+		update();
+
+		if (_sceneUpdateRequired)
+			gui_drawScene(0);
+		else
+			updateEnvironmentalSfx(0);
+
+		if (_partyDamageFlags != -1) {
+			checkForPartyDeath();
+			_partyDamageFlags = -1;
+		}
+
+		delay(_tickLength);
+	}
+}
+
+void LoLEngine::registerDefaultSettings() {
+	KyraEngine_v1::registerDefaultSettings();
+
+	// Most settings already have sensible defaults. This one, however, is
+	// specific to the LoL engine.
+	ConfMan.registerDefault("floating_cursors", false);
+	ConfMan.registerDefault("smooth_scrolling", true);
+	ConfMan.registerDefault("monster_difficulty", 1);
+}
+
+void LoLEngine::writeSettings() {
+	ConfMan.setInt("monster_difficulty", _monsterDifficulty);
+	ConfMan.setBool("floating_cursors", _floatingCursorsEnabled);
+	ConfMan.setBool("smooth_scrolling", _smoothScrollingEnabled);
+
+	switch (_lang) {
+	case 1:
+		_flags.lang = Common::FR_FRA;
+		break;
+
+	case 2:
+		_flags.lang = Common::DE_DEU;
+		break;
+
+	case 0:
+	default:
+		if (_flags.platform == Common::kPlatformPC98 || _flags.platform == Common::kPlatformFMTowns)
+			_flags.lang = Common::JA_JPN;
+		else
+			_flags.lang = Common::EN_ANY;
+	}
+
+	if (_flags.lang == _flags.replacedLang && _flags.fanLang != Common::UNK_LANG)
+		_flags.lang = _flags.fanLang;
+
+	ConfMan.set("language", Common::getLanguageCode(_flags.lang));
+
+	KyraEngine_v1::writeSettings();
+}
+
+void LoLEngine::readSettings() {
+	_monsterDifficulty = ConfMan.getInt("monster_difficulty");
+	if (_monsterDifficulty < 0 || _monsterDifficulty > 2) {
+		_monsterDifficulty = CLIP(_monsterDifficulty, 0, 2);
+		warning("LoLEngine: Config file contains invalid difficulty setting.");
+	}
+	_smoothScrollingEnabled = ConfMan.getBool("smooth_scrolling");
+	_floatingCursorsEnabled = ConfMan.getBool("floating_cursors");
+
+	KyraEngine_v1::readSettings();
+}
+
+void LoLEngine::update() {
+	updateSequenceBackgroundAnimations();
+
+	if (_updateCharNum != -1 && _system->getMillis() > _updatePortraitNext)
+		updatePortraitSpeechAnim();
+
+	if (_flagsTable[31] & 0x08 || !(_updateFlags & 4))
+		updateLampStatus();
+
+	if (_flagsTable[31] & 0x40 && !(_updateFlags & 4) && (_compassDirection == -1 || (_currentDirection << 6) != _compassDirection || _compassStep))
+		updateCompass();
+
+	snd_updateCharacterSpeech();
+	fadeText();
+
+	updateInput();
+	_screen->updateScreen();
+}
+
+#pragma mark - Localization
+
+char *LoLEngine::getLangString(uint16 id) {
+	if (id == 0xFFFF)
+		return 0;
+
+	uint16 realId = id & 0x3FFF;
+	uint8 *buffer = 0;
+
+	if (id & 0x4000)
+		buffer = _landsFile;
+	else
+		buffer = _levelLangFile;
+
+	if (!buffer)
+		return 0;
+
+	char *string = (char *)getTableEntry(buffer, realId);
+
+	char *srcBuffer = _stringBuffer[_lastUsedStringBuffer];
+	if (_flags.lang == Common::JA_JPN) {
+		decodeSjis(string, srcBuffer);
+	} else if (_flags.lang == Common::RU_RUS && !_flags.isTalkie) {
+		decodeCyrillic(string, srcBuffer);
+		Util::decodeString2(srcBuffer, srcBuffer);
+	} else {
+		Util::decodeString1(string, srcBuffer);
+		Util::decodeString2(srcBuffer, srcBuffer);
+	}
+
+	++_lastUsedStringBuffer;
+	_lastUsedStringBuffer %= ARRAYSIZE(_stringBuffer);
+
+	return srcBuffer;
+}
+
+uint8 *LoLEngine::getTableEntry(uint8 *buffer, uint16 id) {
+	if (!buffer)
+		return 0;
+
+	return buffer + READ_LE_UINT16(buffer + (id << 1));
+}
+
+void LoLEngine::decodeSjis(const char *src, char *dst) {
+	char s[2];
+	char d[3];
+	s[1] = 0;
+
+	uint8 cmd = 0;
+	while ((cmd = *src++) != 0) {
+		if (cmd == 27) {
+			cmd = *src++ & 0x7F;
+			memcpy(dst, src, cmd * 2);
+			dst += cmd * 2;
+			src += cmd * 2;
+		} else {
+			s[0] = cmd;
+			int size = Util::decodeString1(s, d);
+			memcpy(dst, d, size);
+			dst += size;
+		}
+	}
+
+	*dst = 0;
+}
+
+int LoLEngine::decodeCyrillic(const char *src, char *dst) {
+	static const uint8 decodeTable1[] = {
+		0x20, 0xAE, 0xA5, 0xA0, 0xE2, 0xAD, 0xA8, 0xE0, 0xE1, 0xAB, 0xA2,
+		0xA4, 0xAC, 0xAA, 0xE3, 0x2E
+	};
+
+	static const uint8 decodeTable2[] = {
+		0xAD, 0xAF, 0xA2, 0xE1, 0xAC, 0xAA, 0x20, 0xA4, 0xAB, 0x20,
+		0xE0, 0xE2, 0xA4, 0xA2, 0xA6, 0xAA, 0x20, 0xAD, 0xE2, 0xE0,
+		0xAB, 0xAC, 0xE1, 0xA1, 0x20, 0xAC, 0xE1, 0xAA, 0xAB, 0xE0,
+		0xE2, 0xAD, 0xAE, 0xEC, 0xA8, 0xA5, 0xA0, 0x20, 0xE0, 0xEB,
+		0xAE, 0xA0, 0xA8, 0xA5, 0xEB, 0xEF, 0x20, 0xE3, 0xE2, 0x20,
+		0xAD, 0xE7, 0xAB, 0xAC, 0xA5, 0xE0, 0xAE, 0xA0, 0xA5, 0xA8,
+		0xE3, 0xEB, 0xEF, 0xAA, 0xE2, 0xEF, 0xA5, 0xEC, 0xAB, 0xAE,
+		0xAA, 0xAF, 0xA8, 0xA0, 0xA5, 0xEF, 0xAE, 0xEE, 0xEC, 0xE3,
+		0xA0, 0xAE, 0xA5, 0xA8, 0xEB, 0x20, 0xE0, 0xE3, 0xA0, 0xA5,
+		0xAE, 0xA8, 0xE3, 0xE1, 0xAD, 0xAB, 0x20, 0xAE, 0xA5, 0xA0,
+		0xA8, 0xAD, 0x2E, 0xE3, 0xAE, 0xA0, 0xA8, 0x20, 0xE0, 0xE3,
+		0xAB, 0xE1, 0x20, 0xA4, 0xAD, 0xE2, 0xA1, 0xA6, 0xAC, 0xE1,
+		0x0D, 0x20, 0x2E, 0x09, 0xA0, 0xA1, 0x9D, 0xA5
+	};
+
+	int size = 0;
+	uint cChar = 0;
+	while ((cChar = *src++) != 0) {
+		if (cChar & 0x80) {
+			cChar &= 0x7F;
+			int index = (cChar & 0x78) >> 3;
+			*dst++ = decodeTable1[index];
+			++size;
+			assert(cChar < sizeof(decodeTable2));
+			cChar = decodeTable2[cChar];
+		} else if (cChar >= 0x70) {
+			cChar = *src++;
+		} else if (cChar >= 0x30) {
+			if (cChar < 0x60)
+				cChar -= 0x30;
+			cChar |= 0x80;
+		}
+
+		*dst++ = cChar;
+		++size;
+	}
+
+	*dst++ = 0;
+	return size;
+}
+
+bool LoLEngine::addCharacter(int id) {
+	const uint16 *cdf[] = {
+		_charDefsMan, _charDefsMan, _charDefsMan, _charDefsWoman,
+		_charDefsMan, _charDefsMan, _charDefsWoman, _charDefsKieran, _charDefsAkshel
+	};
+
+	int numChars = countActiveCharacters();
+	if (numChars == 4)
+		return false;
+
+	int i = 0;
+	for (; i < _charDefaultsSize; i++) {
+		if (_charDefaults[i].id == id) {
+			memcpy(&_characters[numChars], &_charDefaults[i], sizeof(LoLCharacter));
+			_characters[numChars].defaultModifiers = cdf[i];
+			break;
+		}
+	}
+	if (i == _charDefaultsSize)
+		return false;
+
+	loadCharFaceShapes(numChars, id);
+
+	_characters[numChars].nextAnimUpdateCountdown = rollDice(1, 12) + 6;
+
+	for (i = 0; i < 11; i++) {
+		if (_characters[numChars].items[i]) {
+			_characters[numChars].items[i] = makeItem(_characters[numChars].items[i], 0, 0);
+			runItemScript(numChars, _characters[numChars].items[i], 0x80, 0, 0);
+		}
+	}
+
+	calcCharPortraitXpos();
+	if (numChars > 0)
+		setTemporaryFaceFrame(numChars, 2, 6, 0);
+
+	return true;
+}
+
+void LoLEngine::setTemporaryFaceFrame(int charNum, int frame, int updateDelay, int redraw) {
+	_characters[charNum].tempFaceFrame = frame;
+	if (frame || updateDelay)
+		setCharacterUpdateEvent(charNum, 6, updateDelay, 1);
+	if (redraw)
+		gui_drawCharPortraitWithStats(charNum);
+}
+
+void LoLEngine::setTemporaryFaceFrameForAllCharacters(int frame, int updateDelay, int redraw) {
+	for (int i = 0; i < 4; i++)
+		setTemporaryFaceFrame(i, frame, updateDelay, 0);
+	if (redraw)
+		gui_drawAllCharPortraitsWithStats();
+}
+
+void LoLEngine::setCharacterUpdateEvent(int charNum, int updateType, int updateDelay, int overwrite) {
+	LoLCharacter *l = &_characters[charNum];
+	for (int i = 0; i < 5; i++) {
+		if (l->characterUpdateEvents[i] && (!overwrite || l->characterUpdateEvents[i] != updateType))
+			continue;
+
+		l->characterUpdateEvents[i] = updateType;
+		l->characterUpdateDelay[i] = updateDelay;
+		_timer->setNextRun(3, _system->getMillis());
+		_timer->resetNextRun();
+		_timer->enable(3);
+		break;
+	}
+}
+
+int LoLEngine::countActiveCharacters() {
+	int i = 0;
+	while (_characters[i].flags & 1)
+		i++;
+	return i;
+}
+
+void LoLEngine::loadCharFaceShapes(int charNum, int id) {
+	if (id < 0)
+		id = -id;
+
+	Common::String file = Common::String::format("FACE%02d.SHP", id);
+	_screen->loadBitmap(file.c_str(), 3, 3, 0);
+
+	const uint8 *p = _screen->getCPagePtr(3);
+	for (int i = 0; i < 40; i++) {
+		delete[] _characterFaceShapes[i][charNum];
+		_characterFaceShapes[i][charNum] = _screen->makeShapeCopy(p, i);
+	}
+}
+
+void LoLEngine::updatePortraitSpeechAnim() {
+	int x = 0;
+	int y = 0;
+	bool redraw = false;
+
+	if (_portraitSpeechAnimMode == 0) {
+		x = _activeCharsXpos[_updateCharNum];
+		y = 144;
+		redraw = true;
+	} else if (_portraitSpeechAnimMode == 1) {
+		if (textEnabled()) {
+			x = 90;
+			y = 130;
+		} else {
+			x = _activeCharsXpos[_updateCharNum];
+			y = 144;
+		}
+	} else if (_portraitSpeechAnimMode == 2) {
+		if (textEnabled()) {
+			x = 16;
+			y = 134;
+		} else {
+			x = _activeCharsXpos[_updateCharNum] + 10;
+			y = 145;
+		}
+	}
+
+	int f = rollDice(1, 6) - 1;
+	if (f == _characters[_updateCharNum].curFaceFrame)
+		f++;
+	if (f > 5)
+		f -= 5;
+	f += 7;
+
+	if (speechEnabled()) {
+		if (snd_updateCharacterSpeech() == 2)
+			// WORKAROUND for portrait speech animations which would "freeze" in some situations
+			if (_resetPortraitAfterSpeechAnim == 2)
+				_resetPortraitAfterSpeechAnim = 1;
+			else
+				_updatePortraitSpeechAnimDuration = 2;
+		else
+			_updatePortraitSpeechAnimDuration = 1;
+	} else if (_resetPortraitAfterSpeechAnim == 2) {
+		_resetPortraitAfterSpeechAnim = 1;
+	}
+
+	_updatePortraitSpeechAnimDuration--;
+
+	if (_updatePortraitSpeechAnimDuration) {
+		setCharFaceFrame(_updateCharNum, f);
+		if (redraw)
+			gui_drawCharPortraitWithStats(_updateCharNum);
+		else
+			gui_drawCharFaceShape(_updateCharNum, x, y, 0);
+		_updatePortraitNext = _system->getMillis() + 10 * _tickLength;
+	} else if (_resetPortraitAfterSpeechAnim != 0) {
+		faceFrameRefresh(_updateCharNum);
+		if (redraw) {
+			gui_drawCharPortraitWithStats(_updateCharNum);
+			initTextFading(0, 0);
+		} else {
+			gui_drawCharFaceShape(_updateCharNum, x, y, 0);
+		}
+		_updateCharNum = -1;
+	}
+}
+
+void LoLEngine::stopPortraitSpeechAnim() {
+	if (_updateCharNum == -1)
+		return;
+
+	_updatePortraitSpeechAnimDuration = 1;
+	// WORKAROUND for portrait speech animations which would "freeze" in some situations
+	_resetPortraitAfterSpeechAnim = 2;
+	updatePortraitSpeechAnim();
+	_updatePortraitSpeechAnimDuration = 1;
+	_updateCharNum = -1;
+
+	if (!_portraitSpeechAnimMode)
+		initTextFading(0, 0);
+}
+
+void LoLEngine::initTextFading(int textType, int clearField) {
+	if (_textColorFlag == textType || !textType) {
+		_fadeText = true;
+		_palUpdateTimer = _system->getMillis();
+	}
+
+	if (!clearField)
+		return;
+
+	stopPortraitSpeechAnim();
+	if (_needSceneRestore)
+		_screen->setScreenDim(_txt->clearDim(3));
+
+	_fadeText = false;
+	_timer->disable(11);
+}
+
+void LoLEngine::setCharFaceFrame(int charNum, int frameNum) {
+	_characters[charNum].curFaceFrame = frameNum;
+}
+
+void LoLEngine::faceFrameRefresh(int charNum) {
+	if (_characters[charNum].curFaceFrame == 1)
+		setTemporaryFaceFrame(charNum, 0, 0, 0);
+	else if (_characters[charNum].curFaceFrame == 6)
+		if (_characters[charNum].tempFaceFrame != 5)
+			setTemporaryFaceFrame(charNum, 0, 0, 0);
+		else
+			_characters[charNum].curFaceFrame = 5;
+	else
+		_characters[charNum].curFaceFrame = 0;
+}
+
+void LoLEngine::recalcCharacterStats(int charNum) {
+	for (int i = 0; i < 5; i++)
+		_charStatsTemp[i] = calculateCharacterStats(charNum, i);
+}
+
+int LoLEngine::calculateCharacterStats(int charNum, int index) {
+	if (index == 0) {
+		// Might
+		int c = 0;
+		for (int i = 0; i < 8; i++)
+			c += _characters[charNum].itemsMight[i];
+		if (c)
+			c += _characters[charNum].might;
+		else
+			c = _characters[charNum].defaultModifiers[8];
+
+		c = (c * _characters[charNum].defaultModifiers[1]) >> 8;
+		c = (c * _characters[charNum].totalMightModifier) >> 8;
+
+		return c;
+
+	} else if (index == 1) {
+		// Protection
+		return calculateProtection(charNum);
+
+	} else if (index > 4) {
+		return -1;
+
+	} else {
+		// Fighter
+		// Rogue
+		// Mage
+		index -= 2;
+		return _characters[charNum].skillLevels[index] + _characters[charNum].skillModifiers[index];
+	}
+
+	//return 1;
+}
+
+int LoLEngine::calculateProtection(int index) {
+	int c = 0;
+	if (index & 0x8000) {
+		// Monster
+		index &= 0x7FFF;
+		c = (_monsters[index].properties->itemProtection * _monsters[index].properties->fightingStats[2]) >> 8;
+	} else {
+		// Character
+		c = _characters[index].itemProtection + _characters[index].protection;
+		c = (c * _characters[index].defaultModifiers[2]) >> 8;
+		c = (c * _characters[index].totalProtectionModifier) >> 8;
+	}
+
+	return c;
+}
+
+void LoLEngine::setCharacterMagicOrHitPoints(int charNum, int type, int points, int mode) {
+	static const uint16 barData[4][5] = {
+		// xPos, bar color, text color, flag, string id
+		{ 0x27, 0x9A, 0x98, 0x01, 0x4254 },
+		{ 0x21, 0xA2, 0xA0, 0x00, 0x4253 },
+		// 16 color mode
+		{ 0x27, 0x66, 0x55, 0x01, 0x4254 },
+		{ 0x21, 0xAA, 0x99, 0x00, 0x4253 }
+	};
+
+	if (charNum > 2)
+		return;
+
+	LoLCharacter *c = &_characters[charNum];
+	if (!(c->flags & 1))
+		return;
+
+	int pointsMax = type ? c->magicPointsMax : c->hitPointsMax;
+	int pointsCur = type ? c->magicPointsCur : c->hitPointsCur;
+
+	int newVal = (mode == 2) ? (pointsMax + points) : (mode ? (pointsCur + points) : points);
+	newVal = CLIP(newVal, 0, pointsMax);
+
+	if (type) {
+		c->magicPointsCur = newVal;
+	} else {
+		c->hitPointsCur = newVal;
+		if (c->hitPointsCur < 1)
+			c->flags |= 8;
+	}
+
+	if (_updateFlags & 2)
+		return;
+
+	Screen::FontId cf = _screen->setFont(Screen::FID_6_FNT);
+	int cp = _screen->setCurPage(0);
+
+	int s = 8192 / pointsMax;
+	pointsMax = (s * pointsMax) >> 8;
+	pointsCur = (s * pointsCur) >> 8;
+	newVal = (s * newVal) >> 8;
+	int newValScl = CLIP(newVal, 0, pointsMax);
+
+	int step = (newVal > pointsCur) ? 2 : -2;
+	newVal = CLIP(newVal + step, 0, pointsMax);
+
+	if (_flags.use16ColorMode)
+		type += 2;
+
+	if (newVal != pointsCur) {
+		step = (newVal >= pointsCur) ? 2 : -2;
+
+		for (int i = pointsCur; i != newVal || newVal != newValScl;) {
+			if (ABS(i - newVal) < ABS(step))
+				step >>= 1;
+
+			i += step;
+
+			uint32 delayTimer = _system->getMillis() + _tickLength;
+
+			gui_drawLiveMagicBar(barData[type][0] + _activeCharsXpos[charNum], 175, i, 0, pointsMax, 5, 32, barData[type][1], _flags.use16ColorMode ? 0x44 : 1, barData[type][3]);
+			_screen->printText(getLangString(barData[type][4]), barData[type][0] + _activeCharsXpos[charNum], 144, barData[type][2], 0);
+			_screen->updateScreen();
+
+			if (i == newVal) {
+				newVal = newValScl;
+				step = -step;
+			}
+
+			delayUntil(delayTimer);
+		}
+	}
+
+	_screen->setFont(cf);
+	_screen->setCurPage(cp);
+}
+
+void LoLEngine::increaseExperience(int charNum, int skill, uint32 points) {
+	if (charNum & 0x8000)
+		return;
+
+	if (_characters[charNum].flags & 8)
+		return;
+
+	_characters[charNum].experiencePts[skill] += points;
+
+	bool loop = true;
+	while (loop) {
+		if (_characters[charNum].experiencePts[skill] < _expRequirements[_characters[charNum].skillLevels[skill]])
+			break;
+
+		_characters[charNum].skillLevels[skill]++;
+		_characters[charNum].flags |= (0x200 << skill);
+		int inc = 0;
+
+		switch (skill) {
+		case 0:
+			_txt->printMessage(0x8003, getLangString(0x4023), _characters[charNum].name);
+			inc = rollDice(4, 6);
+			_characters[charNum].hitPointsCur += inc;
+			_characters[charNum].hitPointsMax += inc;
+			break;
+
+		case 1:
+			_txt->printMessage(0x8003, getLangString(0x4025), _characters[charNum].name);
+			inc = rollDice(2, 6);
+			_characters[charNum].hitPointsCur += inc;
+			_characters[charNum].hitPointsMax += inc;
+			break;
+
+		case 2:
+			_txt->printMessage(0x8003, getLangString(0x4024), _characters[charNum].name);
+			inc = (_characters[charNum].defaultModifiers[6] * (rollDice(1, 8) + 17)) >> 8;
+			_characters[charNum].magicPointsCur += inc;
+			_characters[charNum].magicPointsMax += inc;
+			inc = rollDice(1, 6);
+			_characters[charNum].hitPointsCur += inc;
+			_characters[charNum].hitPointsMax += inc;
+			break;
+
+		default:
+			break;
+		}
+
+		snd_playSoundEffect(118, -1);
+		gui_drawCharPortraitWithStats(charNum);
+	}
+}
+
+void LoLEngine::increaseCharacterHitpoints(int charNum, int points, bool ignoreDeath) {
+	if (_characters[charNum].hitPointsCur <= 0 && !ignoreDeath)
+		return;
+
+	if (points <= 1)
+		points = 1;
+
+	_characters[charNum].hitPointsCur = CLIP<int16>(_characters[charNum].hitPointsCur + points, 1, _characters[charNum].hitPointsMax);
+	_characters[charNum].flags &= 0xFFF7;
+}
+
+void LoLEngine::setupScreenDims() {
+	if (textEnabled()) {
+		_screen->modifyScreenDim(4, 11, 124, 28, 45);
+		_screen->modifyScreenDim(5, 85, 123, 233, 54);
+	} else {
+		_screen->modifyScreenDim(4, 11, 124, 28, 9);
+		_screen->modifyScreenDim(5, 85, 123, 233, 18);
+	}
+}
+
+void LoLEngine::initSceneWindowDialogue(int controlMode) {
+	resetPortraitsAndDisableSysTimer();
+	gui_prepareForSequence(112, 0, 176, 120, controlMode);
+
+	_updateFlags |= 3;
+
+	_txt->setupField(true);
+	_txt->expandField();
+	setupScreenDims();
+	gui_disableControls(controlMode);
+}
+
+void LoLEngine::toggleSelectedCharacterFrame(bool mode) {
+	if (countActiveCharacters() == 1)
+		return;
+
+	int col = mode ? 212 : 1;
+
+	int cp = _screen->setCurPage(0);
+	int x = _activeCharsXpos[_selectedCharacter];
+
+	_screen->drawBox(x, 143, x + 65, 176, col);
+	_screen->setCurPage(cp);
+}
+
+void LoLEngine::gui_prepareForSequence(int x, int y, int w, int h, int buttonFlags) {
+	setSequenceButtons(x, y, w, h, buttonFlags);
+
+	_seqWindowX1 = x;
+	_seqWindowY1 = y;
+	_seqWindowX2 = x + w;
+	_seqWindowY2 = y + h;
+
+	int mouseOffs = _itemInHand ? 10 : 0;
+	_screen->setMouseCursor(mouseOffs, mouseOffs, getItemIconShapePtr(_itemInHand));
+
+	_lastMouseRegion = -1;
+
+	if (w == 320) {
+		setLampMode(false);
+		_lampStatusSuspended = true;
+	}
+}
+
+void LoLEngine::gui_specialSceneSuspendControls(int controlMode) {
+	if (controlMode) {
+		_updateFlags |= 4;
+		setLampMode(false);
+	}
+	_updateFlags |= 1;
+	_specialSceneFlag = 1;
+	_currentControlMode = controlMode;
+	calcCharPortraitXpos();
+	checkFloatingPointerRegions();
+}
+
+void LoLEngine::gui_specialSceneRestoreControls(int restoreLamp) {
+	if (restoreLamp) {
+		_updateFlags &= 0xFFFA;
+		resetLampStatus();
+	}
+	_updateFlags &= 0xFFFE;
+	_specialSceneFlag = 0;
+	checkFloatingPointerRegions();
+}
+
+void LoLEngine::restoreAfterSceneWindowDialogue(int redraw) {
+	gui_enableControls();
+	_txt->setupField(false);
+	_updateFlags &= 0xFFDF;
+
+	setDefaultButtonState();
+
+	for (int i = 0; i < 6; i++)
+		_tim->freeAnimStruct(i);
+
+	_updateFlags = 0;
+
+	if (redraw) {
+		if (_screen->_fadeFlag != 2)
+			_screen->fadeClearSceneWindow(10);
+		gui_drawPlayField();
+		setPaletteBrightness(_screen->getPalette(0), _brightness, _lampEffect);
+		_screen->_fadeFlag = 0;
+	}
+
+	_needSceneRestore = 0;
+	enableSysTimer(2);
+}
+
+void LoLEngine::initDialogueSequence(int controlMode, int pageNum) {
+	if (controlMode) {
+		_timer->disable(11);
+		_fadeText = false;
+		int cp = _screen->setCurPage(pageNum);
+
+		if (_flags.use16ColorMode) {
+			_screen->fillRect(0, 128, 319, 199, 0x44);
+			gui_drawBox(0, 129, 320, 71, 0xEE, 0xCC, -1);
+			gui_drawBox(1, 130, 318, 69, 0xEE, 0xCC, 0x11);
+		} else {
+			_screen->fillRect(0, 128, 319, 199, 1);
+			gui_drawBox(0, 129, 320, 71, 136, 251, -1);
+			gui_drawBox(1, 130, 318, 69, 136, 251, 252);
+		}
+
+		_screen->modifyScreenDim(5, 8, 131, 306, 66);
+		_screen->modifyScreenDim(4, 1, 133, 38, 60);
+		_txt->clearDim(4);
+
+		_updateFlags |= 2;
+		_currentControlMode = controlMode;
+		calcCharPortraitXpos();
+
+		if (!textEnabled() && (!(controlMode & 2))) {
+			int nc = countActiveCharacters();
+			for (int i = 0; i < nc; i++) {
+				_portraitSpeechAnimMode = 2;
+				_updateCharNum = i;
+				_screen->drawShape(0, _gameShapes[88], _activeCharsXpos[_updateCharNum] + 8, 142, 0, 0);
+				stopPortraitSpeechAnim();
+			}
+		}
+
+		_screen->setCurPage(cp);
+
+	} else {
+		_txt->setupField(true);
+		_txt->expandField();
+		setupScreenDims();
+		_txt->clearDim(4);
+	}
+
+	_currentControlMode = controlMode;
+	_dialogueField = true;
+}
+
+void LoLEngine::restoreAfterDialogueSequence(int controlMode) {
+	if (!_dialogueField)
+		return;
+
+	stopPortraitSpeechAnim();
+	_currentControlMode = controlMode;
+	calcCharPortraitXpos();
+
+	if (_currentControlMode) {
+		_screen->modifyScreenDim(4, 11, 124, 28, 45);
+		_screen->modifyScreenDim(5, 85, 123, 233, 54);
+		_updateFlags &= 0xFFFD;
+	} else {
+		const ScreenDim *d = _screen->getScreenDim(5);
+		_screen->fillRect(d->sx, d->sy, d->sx + d->w - (_flags.use16ColorMode ? 3 : 2), d->sy + d->h - 2, d->unkA);
+		_txt->clearDim(4);
+		_txt->setupField(false);
+	}
+
+	_dialogueField = false;
+}
+
+void LoLEngine::resetPortraitsAndDisableSysTimer() {
+	_needSceneRestore = 1;
+	if (!textEnabled() || (!(_currentControlMode & 2)))
+		timerUpdatePortraitAnimations(1);
+
+	disableSysTimer(2);
+}
+
+void LoLEngine::fadeText() {
+	if (!_fadeText)
+		return;
+
+	if (_screen->fadeColor(192, 252, (_system->getMillis() - _palUpdateTimer) / _tickLength, 60))
+		return;
+
+	if (_needSceneRestore)
+		return;
+
+	_screen->setScreenDim(_txt->clearDim(3));
+
+	_timer->disable(11);
+
+	_fadeText = false;
+}
+
+void LoLEngine::setPaletteBrightness(const Palette &srcPal, int brightness, int modifier) {
+	generateBrightnessPalette(srcPal, _screen->getPalette(1), brightness, modifier);
+	_screen->fadePalette(_screen->getPalette(1), 5, 0);
+	_screen->_fadeFlag = 0;
+}
+
+void LoLEngine::generateBrightnessPalette(const Palette &src, Palette &dst, int brightness, int16 modifier) {
+	dst.copy(src);
+	if (_flags.use16ColorMode) {
+		if (!brightness)
+			modifier = 0;
+		else if (modifier < 0 || modifier > 7 || !(_flagsTable[31] & 0x08))
+			modifier = 8;
+
+		modifier >>= 1;
+		if (modifier)
+			modifier--;
+		if (modifier > 3)
+			modifier = 3;
+		_blockBrightness = modifier << 4;
+		_sceneUpdateRequired = true;
+
+	} else {
+		_screen->loadSpecialColors(dst);
+
+		brightness = (8 - brightness) << 5;
+		if (modifier >= 0 && modifier < 8 && (_flagsTable[31] & 0x08)) {
+			brightness = 256 - ((((modifier & 0xFFFE) << 5) * (256 - brightness)) >> 8);
+			if (brightness < 0)
+				brightness = 0;
+		}
+
+		for (int i = 0; i < 384; i++) {
+			uint16 c = (dst[i] * brightness) >> 8;
+			dst[i] = c & 0xFF;
+		}
+	}
+}
+
+void LoLEngine::generateFlashPalette(const Palette &src, Palette &dst, int colorFlags) {
+	dst.copy(src, 0, 2);
+
+	for (int i = 2; i < 128; i++) {
+		for (int ii = 0; ii < 3; ii++) {
+			uint8 t = src[i * 3 + ii] & 0x3F;
+			if (colorFlags & (1 << ii))
+				t += ((0x3F - t) >> 1);
+			else
+				t -= (t >> 1);
+			dst[i * 3 + ii] = t;
+		}
+	}
+
+	dst.copy(src, 128);
+}
+
+void LoLEngine::createTransparencyTables() {
+	if (_flags.isTalkie || _loadSuppFilesFlag)
+		return;
+
+	uint8 *tpal = new uint8[768];
+
+	if (_flags.use16ColorMode) {
+		static const uint8 colTbl[] = {
+			0x00, 0x00, 0x11, 0x00, 0x22, 0x00, 0x33, 0x00, 0x44, 0x00, 0x55, 0x00, 0x66, 0x00, 0x77, 0x00,
+			0x88, 0x00, 0x99, 0x00, 0xAA, 0x00, 0xBB, 0x00, 0xCC, 0x00, 0xDD, 0x00, 0xEE, 0x00, 0xFF, 0x00
+		};
+
+		memset(tpal, 0xFF, 768);
+		_res->loadFileToBuf("LOL.NOL", tpal, 48);
+
+		for (int i = 15; i > -1; i--) {
+			int s = colTbl[i << 1] * 3;
+			tpal[s] = tpal[i * 3];
+			tpal[s + 1] = tpal[i * 3 + 1];
+			tpal[s + 2] = tpal[i * 3 + 2];
+			tpal[i * 3 + 2] = tpal[i * 3 + 1] = tpal[i * 3] = 0xFF;
+		}
+
+		_screen->createTransparencyTablesIntern(colTbl, 16, tpal, tpal,  _transparencyTable1, _transparencyTable2, 80);
+
+	} else {
+		_res->loadFileToBuf("fxpal.col", tpal, 768);
+		_screen->loadBitmap("fxpal.shp", 3, 3, 0);
+		const uint8 *shpPal = _screen->getPtrToShape(_screen->getCPagePtr(2), 0) + 11;
+
+		_screen->createTransparencyTablesIntern(shpPal, 20, tpal, _screen->getPalette(1).getData(), _transparencyTable1, _transparencyTable2, 70);
+	}
+
+	delete[] tpal;
+	_loadSuppFilesFlag = 1;
+}
+
+void LoLEngine::updateSequenceBackgroundAnimations() {
+	if (_updateFlags & 8 || !_tim)
+		return;
+	if (!_tim->animator())
+		return;
+
+	for (int i = 0; i < 6; i++)
+		_tim->animator()->update(i);
+}
+
+void LoLEngine::loadTalkFile(int index) {
+	if (index == _curTlkFile)
+		return;
+
+	if (_curTlkFile > 0 && index > 0)
+		_res->unloadPakFile(Common::String::format("%02d.TLK", _curTlkFile));
+
+	if (index > 0)
+		_curTlkFile = index;
+
+	_res->loadPakFile(Common::String::format("%02d.TLK", index));
+}
+
+int LoLEngine::characterSays(int track, int charId, bool redraw) {
+	if (charId == 1) {
+		charId = _selectedCharacter;
+	} if (charId <= 0) {
+		charId = 0;
+	} else {
+		int i = 0;
+		for (; i < 4; i++) {
+			if (charId != _characters[i].id || !(_characters[i].flags & 1))
+				continue;
+			charId = i;
+			break;
+		}
+
+		if (i == 4)
+			return 0;
+	}
+
+	bool r = snd_playCharacterSpeech(track, charId, 0);
+
+	if (r && redraw) {
+		stopPortraitSpeechAnim();
+		_updateCharNum = charId;
+		_portraitSpeechAnimMode = 0;
+		_resetPortraitAfterSpeechAnim = 1;
+		_fadeText = false;
+		updatePortraitSpeechAnim();
+	}
+
+	return r ? (textEnabled() ? 1 : 0) : 1;
+}
+
+int LoLEngine::playCharacterScriptChat(int charId, int mode, int restorePortrait, char *str, EMCState *script, const uint16 *paramList, int16 paramIndex) {
+	int ch = 0;
+	bool skipAnim = false;
+
+	if ((charId == -1) || (!(charId & 0x70)))
+		charId = ch = (charId == 1) ? (_selectedCharacter ? _characters[_selectedCharacter].id : 0) : charId;
+	else
+		charId ^= 0x70;
+
+	stopPortraitSpeechAnim();
+
+	if (charId < 0) {
+		charId = ch = _rnd.getRandomNumber(countActiveCharacters() - 1);
+	} else if (charId > 0) {
+		int i = 0;
+
+		for (; i < 3; i++) {
+			if (_characters[i].id != charId || !(_characters[i].flags & 1))
+				continue;
+			if (charId == ch)
+				ch = i;
+			charId = i;
+			break;
+		}
+
+		if (i == 4) {
+			if (charId == 8)
+				skipAnim = true;
+			else
+				return 0;
+		}
+	}
+
+	if (!skipAnim) {
+		_updateCharNum = charId;
+		_portraitSpeechAnimMode = mode;
+		_updatePortraitSpeechAnimDuration = strlen(str) >> 1;
+		_resetPortraitAfterSpeechAnim = restorePortrait;
+	}
+
+	if (script)
+		snd_playCharacterSpeech(script->stack[script->sp + 2], ch, 0);
+	else if (paramList)
+		snd_playCharacterSpeech(paramList[2], ch, 0);
+
+	if (textEnabled()) {
+		if (mode == 0) {
+			_txt->printDialogueText(3, str, script, paramList, paramIndex);
+
+		} else if (mode == 1) {
+			_txt->clearDim(4);
+			_screen->modifyScreenDim(4, 16, 123, 23, 47);
+			_txt->printDialogueText(4, str, script, paramList, paramIndex);
+			_screen->modifyScreenDim(4, 11, 123, 28, 47);
+
+		} else if (mode == 2) {
+			_txt->clearDim(4);
+			_screen->modifyScreenDim(4, 9, 133, 30, 60);
+			_txt->printDialogueText(4, str, script, paramList, 3);
+			_screen->modifyScreenDim(4, 1, 133, 37, 60);
+		}
+	}
+
+	_fadeText = false;
+	if (!skipAnim)
+		updatePortraitSpeechAnim();
+
+	return 1;
+}
+
+void LoLEngine::setupDialogueButtons(int numStr, const char *s1, const char *s2, const char *s3) {
+	screen()->setScreenDim(5);
+
+	if (numStr == 1 && speechEnabled()) {
+		_dialogueNumButtons = 0;
+		_dialogueButtonString[0] = _dialogueButtonString[1] = _dialogueButtonString[2] = 0;
+	} else {
+		_dialogueNumButtons = numStr;
+		_dialogueButtonString[0] = s1;
+		_dialogueButtonString[1] = s2;
+		_dialogueButtonString[2] = s3;
+		_dialogueHighlightedButton = 0;
+
+		const ScreenDim *d = screen()->getScreenDim(5);
+
+		static uint16 posX[3];
+		static uint8 posY[3];
+
+		memset(posY, d->sy + d->h - 9, 3);
+
+		_dialogueButtonPosX = posX;
+		_dialogueButtonPosY = posY;
+
+		if (numStr == 1) {
+			posX[0] = posX[1] = posX[2] = d->sx + d->w - (_dialogueButtonWidth + 3);
+		} else {
+			int xOffs = d->w / numStr;
+			posX[0] = d->sx + (xOffs >> 1) - 37;
+			posX[1] = posX[0] + xOffs;
+			posX[2] = posX[1] + xOffs;
+		}
+
+		drawDialogueButtons();
+	}
+
+	if (!shouldQuit())
+		removeInputTop();
+}
+
+void LoLEngine::giveItemToMonster(LoLMonster *monster, Item item) {
+	uint16 *c = &monster->assignedItems;
+	while (*c)
+		c = &_itemsInPlay[*c].nextAssignedObject;
+	*c = (uint16)item;
+	_itemsInPlay[item].nextAssignedObject = 0;
+}
+
+const uint16 *LoLEngine::getCharacterOrMonsterStats(int id) {
+	return (id & 0x8000) ? (const uint16 *)_monsters[id & 0x7FFF].properties->fightingStats : _characters[id].defaultModifiers;
+}
+
+uint16 *LoLEngine::getCharacterOrMonsterItemsMight(int id) {
+	return (id & 0x8000) ? _monsters[id & 0x7FFF].properties->itemsMight : _characters[id].itemsMight;
+}
+
+uint16 *LoLEngine::getCharacterOrMonsterProtectionAgainstItems(int id) {
+	return (id & 0x8000) ? _monsters[id & 0x7FFF].properties->protectionAgainstItems : _characters[id].protectionAgainstItems;
+}
+
+void LoLEngine::delay(uint32 millis, bool doUpdate, bool) {
+	while (millis && !shouldQuit()) {
+		if (doUpdate)
+			update();
+		else
+			updateInput();
+
+		uint32 step = MIN<uint32>(millis, _tickLength);
+		_system->delayMillis(step);
+		millis -= step;
+	}
+}
+
+const KyraRpgGUISettings *LoLEngine::guiSettings() {
+	return &_guiSettings;
+}
+
+// spells
+
+int LoLEngine::castSpell(int charNum, int spellType, int spellLevel) {
+	_activeSpell.charNum = charNum;
+	_activeSpell.spell = spellType;
+	_activeSpell.p = &_spellProperties[spellType];
+
+	_activeSpell.level = ABS(spellLevel);
+
+	if ((_spellProperties[spellType].flags & 0x100) && testWallFlag(calcNewBlockPosition(_currentBlock, _currentDirection), _currentDirection, 1)) {
+		_txt->printMessage(2, "%s", getLangString(0x4257));
+		return 0;
+	}
+
+	if (charNum < 0) {
+		_activeSpell.charNum = (charNum * -1) - 1;
+		if (_spellProcs[spellType]->isValid())
+			return (*_spellProcs[spellType])(&_activeSpell);
+	} else {
+		if (_activeSpell.p->mpRequired[spellLevel] > _characters[charNum].magicPointsCur)
+			return 0;
+
+		if (_activeSpell.p->hpRequired[spellLevel] >= _characters[charNum].hitPointsCur)
+			return 0;
+
+		setCharacterMagicOrHitPoints(charNum, 1, -_activeSpell.p->mpRequired[spellLevel], 1);
+		setCharacterMagicOrHitPoints(charNum, 0, -_activeSpell.p->hpRequired[spellLevel], 1);
+		gui_drawCharPortraitWithStats(charNum);
+
+		if (_spellProcs[spellType]->isValid())
+			(*_spellProcs[spellType])(&_activeSpell);
+	}
+
+	return 1;
+}
+
+int LoLEngine::castSpark(ActiveSpell *a) {
+	processMagicSpark(a->charNum, a->level);
+	return 1;
+}
+
+int LoLEngine::castHeal(ActiveSpell *a) {
+	if (a->level < 3)
+		processMagicHealSelectTarget();
+	else
+		processMagicHeal(-1, a->level);
+
+	return 1;
+}
+
+int LoLEngine::castIce(ActiveSpell *a) {
+	processMagicIce(a->charNum, a->level);
+	return 1;
+}
+
+int LoLEngine::castFireball(ActiveSpell *a) {
+	processMagicFireball(a->charNum, a->level);
+	return 1;
+}
+
+int LoLEngine::castHandOfFate(ActiveSpell *a) {
+	processMagicHandOfFate(a->level);
+	return 1;
+}
+
+int LoLEngine::castMistOfDoom(ActiveSpell *a) {
+	processMagicMistOfDoom(a->charNum, a->level);
+	return 1;
+}
+
+int LoLEngine::castLightning(ActiveSpell *a) {
+	processMagicLightning(a->charNum, a->level);
+	return 1;
+}
+
+int LoLEngine::castFog(ActiveSpell *a) {
+	processMagicFog();
+	return 1;
+}
+
+int LoLEngine::castSwarm(ActiveSpell *a) {
+	processMagicSwarm(a->charNum, 10);
+	return 1;
+}
+
+int LoLEngine::castVaelansCube(ActiveSpell *a) {
+	return processMagicVaelansCube();
+}
+
+int LoLEngine::castGuardian(ActiveSpell *a) {
+	return processMagicGuardian(a->charNum);
+}
+
+int LoLEngine::castHealOnSingleCharacter(ActiveSpell *a) {
+	processMagicHeal(a->target, a->level);
+	return 1;
+}
+
+int LoLEngine::processMagicSpark(int charNum, int spellLevel) {
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+	_screen->copyPage(0, 12);
+
+	mov->open("spark1.wsa", 0, 0);
+	if (!mov->opened())
+		error("SPARK: Unable to load SPARK1.WSA");
+	snd_playSoundEffect(72, -1);
+	playSpellAnimation(mov, 0, 7, 4, _activeCharsXpos[charNum] - 2, 138, 0, 0, 0, 0, false);
+	mov->close();
+
+	_screen->copyPage(12, 0);
+	_screen->updateScreen();
+
+	uint16 targetBlock = 0;
+	int dist = getSpellTargetBlock(_currentBlock, _currentDirection, 4, targetBlock);
+	uint16 target = getNearestMonsterFromCharacterForBlock(targetBlock, charNum);
+
+	static const uint8 dmg[] = { 7, 15, 25, 60 };
+	if (target != 0xFFFF) {
+		inflictMagicalDamage(target, charNum, dmg[spellLevel], 5, 0);
+		updateDrawPage2();
+		gui_drawScene(0);
+		_screen->copyPage(0, 12);
+	}
+
+	int numFrames = mov->open("spark2.wsa", 0, 0);
+	if (!mov->opened())
+		error("SPARK: Unable to load SPARK2.WSA");
+
+	uint16 wX[6];
+	uint16 wY[6];
+	uint16 wFrames[6];
+	const uint16 width = mov->width();
+	const uint16 height = mov->height();
+
+	for (int i = 0; i < 6; i++) {
+		wX[i] = (_rnd.getRandomNumber(0x7FFF) % 64) + ((176 - width) >> 1) + 80;
+		wY[i] = (_rnd.getRandomNumber(0x7FFF) % 32) + ((120 - height) >> 1) - 16;
+		wFrames[i] = i << 1;
+	}
+
+	for (int i = 0, d = ((spellLevel << 1) + 12); i < d; i++) {
+		uint32 delayTimer = _system->getMillis() + 4 * _tickLength;
+		_screen->copyPage(12, 2);
+
+		for (int ii = 0; ii <= spellLevel; ii++) {
+			if (wFrames[ii] >= i || wFrames[ii] + 13 <= i)
+				continue;
+
+			if ((i - wFrames[ii]) == 1)
+				snd_playSoundEffect(162, -1);
+
+			mov->displayFrame(((i - wFrames[ii]) + (dist << 4)) % numFrames, 2, wX[ii], wY[ii], 0x5000, _transparencyTable1, _transparencyTable2);
+			_screen->copyRegion(wX[ii], wY[ii], wX[ii], wY[ii], width, height, 2, 0, Screen::CR_NO_P_CHECK);
+			_screen->updateScreen();
+		}
+
+		if (i < d - 1)
+			delayUntil(delayTimer);
+	}
+
+	mov->close();
+
+	_screen->copyPage(12, 2);
+	updateDrawPage2();
+
+	_sceneUpdateRequired = true;
+
+	delete mov;
+	return 1;
+}
+
+int LoLEngine::processMagicHealSelectTarget() {
+	_txt->printMessage(0, "%s", getLangString(0x4040));
+	gui_resetButtonList();
+	gui_setFaceFramesControlButtons(81, 0);
+	gui_initButtonsFromList(_buttonList8);
+	return 1;
+}
+
+int LoLEngine::processMagicHeal(int charNum, int spellLevel) {
+	if (!_healOverlay) {
+		_healOverlay = new uint8[256];
+		Palette tpal(256);
+		tpal.copy(_screen->getPalette(1));
+
+		if (_flags.use16ColorMode) {
+			tpal.fill(16, 240, 0xFF);
+			uint8 *dst = tpal.getData();
+			for (int i = 1; i < 16; i++) {
+				int s = ((i << 4) | i) * 3;
+				SWAP(dst[s], dst[i]);
+				SWAP(dst[s + 1], dst[i + 1]);
+				SWAP(dst[s + 2], dst[i + 2]);
+			}
+		}
+
+		_screen->generateGrayOverlay(tpal, _healOverlay, 52, 22, 20, 0, 256, true);
+	}
+
+	const uint8 *healShpFrames = 0;
+	const uint8 *healiShpFrames = 0;
+	bool curePoison = false;
+	int points = 0;
+
+	if (spellLevel == 0) {
+		points = 25;
+		healShpFrames = _healShapeFrames;
+		healiShpFrames = _healShapeFrames + 32;
+
+	} else if (spellLevel == 1) {
+		points = 45;
+		healShpFrames = _healShapeFrames + 16;
+		healiShpFrames = _healShapeFrames + 48;
+
+	} else if (spellLevel > 3) {
+		curePoison = true;
+		points = spellLevel;
+		healShpFrames = _healShapeFrames + 16;
+		healiShpFrames = _healShapeFrames + 64;
+
+	} else {
+		curePoison = true;
+		points = 10000;
+		healShpFrames = _healShapeFrames + 16;
+		healiShpFrames = _healShapeFrames + 64;
+	}
+
+	int ch = 0;
+	int n = 4;
+
+	if (charNum != -1) {
+		ch = charNum;
+		n = charNum + 1;
+	}
+
+	charNum = ch;
+
+	uint16 pX[4];
+	uint16 pY = 138;
+	uint16 diff[4];
+	uint16 pts[4];
+	memset(pts, 0, sizeof(pts));
+
+	while (charNum < n) {
+		if (!(_characters[charNum].flags & 1)) {
+			charNum++;
+			continue;
+		}
+
+		pX[charNum] = _activeCharsXpos[charNum] - 6;
+		_characters[charNum].damageSuffered = 0;
+		int dmg = _characters[charNum].hitPointsMax - _characters[charNum].hitPointsCur;
+		diff[charNum] = (dmg < points) ? dmg : points;
+		_screen->copyRegion(pX[charNum], pY, charNum * 77, 32, 77, 44, 0, 2, Screen::CR_NO_P_CHECK);
+		charNum++;
+	}
+
+	int cp = _screen->setCurPage(2);
+	snd_playSoundEffect(68, -1);
+
+	for (int i = 0; i < 16; i++) {
+		uint32 delayTimer = _system->getMillis() + 4 * _tickLength;
+
+		for (charNum = ch; charNum < n; charNum++) {
+			if (!(_characters[charNum].flags & 1))
+				continue;
+
+			_screen->copyRegion(charNum * 77, 32, pX[charNum], pY, 77, 44, 2, 2, Screen::CR_NO_P_CHECK);
+
+			pts[charNum] &= 0xFF;
+			pts[charNum] += ((diff[charNum] << 8) / 16);
+			increaseCharacterHitpoints(charNum, pts[charNum] / 256, true);
+			gui_drawCharPortraitWithStats(charNum);
+
+			_screen->drawShape(2, _healShapes[healShpFrames[i]], pX[charNum], pY, 0, 0x1000, _transparencyTable1, _transparencyTable2);
+			_screen->fillRect(0, 0, 31, 31, 0);
+
+			_screen->drawShape(_screen->_curPage, _healiShapes[healiShpFrames[i]], 0, 0, 0, 0);
+			_screen->applyOverlaySpecial(_screen->_curPage, 0, 0, 2, pX[charNum] + 7, pY + 6, 32, 32, 0, 0, _healOverlay);
+
+			_screen->copyRegion(pX[charNum], pY, pX[charNum], pY, 77, 44, 2, 0, Screen::CR_NO_P_CHECK);
+			_screen->updateScreen();
+		}
+
+		delayUntil(delayTimer);
+	}
+
+	for (charNum = ch; charNum < n; charNum++) {
+		if (!(_characters[charNum].flags & 1))
+			continue;
+
+		_screen->copyRegion(charNum * 77, 32, pX[charNum], pY, 77, 44, 2, 2, Screen::CR_NO_P_CHECK);
+
+		if (curePoison)
+			removeCharacterEffects(&_characters[charNum], 4, 4);
+
+		gui_drawCharPortraitWithStats(charNum);
+		_screen->copyRegion(pX[charNum], pY, pX[charNum], pY, 77, 44, 2, 0, Screen::CR_NO_P_CHECK);
+		_screen->updateScreen();
+	}
+
+	_screen->setCurPage(cp);
+	updateDrawPage2();
+	return 1;
+}
+
+int LoLEngine::processMagicIce(int charNum, int spellLevel) {
+	int cp = _screen->setCurPage(2);
+
+	disableSysTimer(2);
+
+	gui_drawScene(0);
+	_screen->copyPage(0, 12);
+
+	Palette tpal(256), swampCol(256);
+
+	if (_currentLevel == 11 && !(_flagsTable[52] & 0x04)) {
+		uint8 *sc = _screen->getPalette(0).getData();
+		uint8 *dc = _screen->getPalette(2).getData();
+		for (int i = 1; i < (_screen->getPalette(0).getNumColors() * 3); i++)
+			SWAP(sc[i], dc[i]);
+
+		_flagsTable[52] |= 0x04;
+		static const uint8 freezeTimes[] =  { 20, 28, 40, 60 };
+		setCharacterUpdateEvent(charNum, 8, freezeTimes[spellLevel], 1);
+	}
+
+	Palette s(256);
+	s.copy(_screen->getPalette(1));
+	if (_flags.use16ColorMode) {
+		_screen->loadPalette("LOLICE.NOL", swampCol);
+		for (int i = 1; i < 16; i++) {
+			uint16 v = (s[i * 3] + s[i * 3 + 1] + s[i * 3 + 2]) / 3;
+			tpal[i * 3] = 0;
+			tpal[i * 3 + 1] = v;
+			tpal[i * 3 + 2] = v << 1;
+
+			if (tpal[i * 3 + 2] > 29)
+				tpal[i * 3 + 2] = 29;
+		}
+
+	} else {
+		_screen->loadPalette("SWAMPICE.COL", swampCol);
+		tpal.copy(s, 128);
+		swampCol.copy(s, 128);
+
+		for (int i = 1; i < 128; i++) {
+			tpal[i * 3] = 0;
+			uint16 v = (s[i * 3] + s[i * 3 + 1] + s[i * 3 + 2]) / 3;
+			tpal[i * 3 + 1] = v;
+			tpal[i * 3 + 2] = v << 1;
+
+			if (tpal[i * 3 + 2] > 0x3F)
+				tpal[i * 3 + 2] = 0x3F;
+		}
+	}
+
+	generateBrightnessPalette(tpal, tpal, _brightness, _lampEffect);
+	generateBrightnessPalette(swampCol, swampCol, _brightness, _lampEffect);
+	swampCol[0] = swampCol[1] = swampCol[2] = tpal[0] = tpal[1] = tpal[2] = 0;
+
+	generateBrightnessPalette(_screen->getPalette(0), s, _brightness, _lampEffect);
+
+	int sX = 112;
+	int sY = 0;
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+
+	if (spellLevel == 0) {
+		sX = 0;
+	} if (spellLevel == 1 || spellLevel == 2) {
+		mov->open("SNOW.WSA", 1, 0);
+		if (!mov->opened())
+			error("Ice: Unable to load snow.wsa");
+	} if (spellLevel == 3) {
+		mov->open("ICE.WSA", 1, 0);
+		if (!mov->opened())
+			error("Ice: Unable to load ice.wsa");
+		sX = 136;
+		sY = 12;
+	}
+
+	snd_playSoundEffect(71, -1);
+
+	playSpellAnimation(0, 0, 0, 2, 0, 0, 0, s.getData(), tpal.getData(), 40, false);
+
+	_screen->timedPaletteFadeStep(s.getData(), tpal.getData(), _system->getMillis(), _tickLength);
+	if (mov->opened()) {
+		int r = true;
+		if (spellLevel > 2) {
+			_levelBlockProperties[calcNewBlockPosition(_currentBlock, _currentDirection)].flags |= 0x10;
+			snd_playSoundEffect(165, -1);
+			r = false;
+		};
+
+		playSpellAnimation(mov, 0, mov->frames(), 2, sX, sY, 0, 0, 0, 0, r);
+		mov->close();
+	}
+
+	delete mov;
+	static const uint8 snowDamage[] = { 10, 20, 30, 55 };
+	static const uint8 iceDamageMax[] = {1, 2, 15, 20, 35};
+	static const uint8 iceDamageMin[] = {10, 10, 3, 4, 4};
+	static const uint8 iceDamageAdd[] = {5, 10, 30, 10, 10};
+
+	bool breakWall = false;
+
+	if (spellLevel < 3) {
+		inflictMagicalDamageForBlock(calcNewBlockPosition(_currentBlock, _currentDirection), charNum, snowDamage[spellLevel], 3);
+	} else {
+		uint16 o = _levelBlockProperties[calcNewBlockPosition(_currentBlock, _currentDirection)].assignedObjects;
+		while (o & 0x8000) {
+			int might = rollDice(iceDamageMin[spellLevel], iceDamageMax[spellLevel]) + iceDamageAdd[spellLevel];
+			int dmg = calcInflictableDamagePerItem(charNum, 0, might, 3, 2);
+
+			LoLMonster *m = &_monsters[o & 0x7FFF];
+			if (m->hitPoints <= dmg) {
+				increaseExperience(charNum, 2, m->hitPoints);
+				o = m->nextAssignedObject;
+
+				if (m->flags & 0x20) {
+					m->mode = 0;
+					monsterDropItems(m);
+					if (_currentLevel != 29)
+						setMonsterMode(m, 14);
+					runLevelScriptCustom(0x404, -1, o, o, 0, 0);
+					checkSceneUpdateNeed(m->block);
+					if (m->mode != 14)
+						placeMonster(m, 0, 0);
+
+				} else {
+					killMonster(m);
+				}
+
+			} else {
+				breakWall = true;
+				inflictDamage(o, dmg, charNum, 2, 3);
+				m->damageReceived = 0;
+				o = m->nextAssignedObject;
+			}
+
+			if (m->flags & 0x20)
+				break;
+		}
+	}
+
+	updateDrawPage2();
+	gui_drawScene(0);
+	enableSysTimer(2);
+
+	if (_currentLevel != 11)
+		generateBrightnessPalette(_screen->getPalette(0), swampCol, _brightness, _lampEffect);
+
+	playSpellAnimation(0, 0, 0, 2, 0, 0, 0, tpal.getData(), swampCol.getData(), 40, 0);
+
+	_screen->timedPaletteFadeStep(tpal.getData(), swampCol.getData(), _system->getMillis(), _tickLength);
+
+	if (breakWall)
+		breakIceWall(tpal.getData(), swampCol.getData());
+
+	_screen->setCurPage(cp);
+	return 1;
+}
+
+int LoLEngine::processMagicFireball(int charNum, int spellLevel) {
+	int fbCnt = 0;
+	int d = 1;
+
+	if (spellLevel == 0) {
+		fbCnt = 4;
+	} else if (spellLevel == 1) {
+		fbCnt = 5;
+	} else if (spellLevel == 2) {
+		fbCnt = 6;
+	} else if (spellLevel == 3) {
+		d = 0;
+		fbCnt = 5;
+	}
+
+	int drawPage1 = 2;
+	int drawPage2 = 4;
+
+	int bl = _currentBlock;
+	int fireballItem = makeItem(9, 0, 0);
+
+	int i = 0;
+	for (; i < 3; i++) {
+		runLevelScriptCustom(bl, 0x200, -1, fireballItem, 0, 0);
+		uint16 o = _levelBlockProperties[bl].assignedObjects;
+
+		if ((o & 0x8000) || (_wllWallFlags[_levelBlockProperties[bl].walls[_currentDirection ^ 2]] & 7)) {
+			while (o & 0x8000) {
+				static const uint8 fireballDamage[] = { 20, 40, 80, 100 };
+				int dmg = calcInflictableDamagePerItem(charNum, o, fireballDamage[spellLevel], 4, 1);
+				LoLMonster *m = &_monsters[o & 0x7FFF];
+				o = m->nextAssignedObject;
+				_envSfxUseQueue = true;
+				inflictDamage(m->id | 0x8000, dmg, charNum, 2, 4);
+				_envSfxUseQueue = false;
+			}
+			break;
+		}
+
+		bl = calcNewBlockPosition(bl, _currentDirection);
+	}
+
+	d += i;
+	if (d > 3)
+		d = 3;
+
+	deleteItem(fireballItem);
+
+	snd_playSoundEffect(69, -1);
+
+	int cp = _screen->setCurPage(2);
+	_screen->copyPage(0, 12);
+
+	int fireBallWH = (d << 4) * -1;
+	int numFireballs = 1;
+	if (fbCnt > 3)
+		numFireballs = fbCnt - 3;
+
+	FireballState *fireballState[3];
+	memset(&fireballState, 0, sizeof(fireballState));
+	for (i = 0; i < numFireballs; i++)
+		fireballState[i] = new FireballState(i);
+
+	_screen->copyPage(12, drawPage1);
+
+	for (i = 0; i < numFireballs;) {
+		_screen->setCurPage(drawPage1);
+		uint32 ctime = _system->getMillis();
+
+		for (int ii = 0; ii < MIN(fbCnt, 3); ii++) {
+			FireballState *fb = fireballState[ii];
+			if (!fb)
+				continue;
+			if (!fb->active)
+				continue;
+
+			static const int8 finShpIndex1[] = { 5, 6, 7, 7, 6, 5 };
+			static const int8 finShpIndex2[] = { -1, 1, 2, 3, 4, -1 };
+			uint8 *shp = fb->finalize ? _fireballShapes[finShpIndex1[fb->finProgress]] : _fireballShapes[0];
+
+			int fX = (((fb->progress * _fireBallCoords[fb->tblIndex & 0xFF]) >> 16) + fb->destX) - ((fb->progress / 8 + shp[3] + fireBallWH) >> 1);
+			int fY = (((fb->progress * _fireBallCoords[(fb->tblIndex + 64) & 0xFF]) >> 16) + fb->destY) - ((fb->progress / 8 + shp[2] + fireBallWH) >> 1);
+			int sW = ((fb->progress / 8 + shp[3] + fireBallWH) << 8) / shp[3];
+			int sH = ((fb->progress / 8 + shp[2] + fireBallWH) << 8) / shp[2];
+
+			if (fb->finalize) {
+				if (_flags.use16ColorMode)
+					_screen->drawShape(_screen->_curPage, shp, fX, fY, 0, 4, sW, sH);
+				else
+					_screen->drawShape(_screen->_curPage, shp, fX, fY, 0, 0x1004, _transparencyTable1, _transparencyTable2, sW, sH);
+
+				if (finShpIndex2[fb->finProgress] != -1) {
+					shp = _fireballShapes[finShpIndex2[fb->finProgress]];
+					fX = (((fb->progress * _fireBallCoords[fb->tblIndex & 0xFF]) >> 16) + fb->destX) - ((fb->progress / 8 + shp[3] + fireBallWH) >> 1);
+					fY = (((fb->progress * _fireBallCoords[(fb->tblIndex + 64) & 0xFF]) >> 16) + fb->destY) - ((fb->progress / 8 + shp[2] + fireBallWH) >> 1);
+					sW = ((fb->progress / 8 + shp[3] + fireBallWH) << 8) / shp[3];
+					sH = ((fb->progress / 8 + shp[2] + fireBallWH) << 8) / shp[2];
+					_screen->drawShape(_screen->_curPage, shp, fX, fY, 0, 4, sW, sH);
+				}
+
+			} else {
+				if (_flags.use16ColorMode)
+					_screen->drawShape(_screen->_curPage, shp, fX, fY, 0, 4, sW, sH);
+				else
+					_screen->drawShape(_screen->_curPage, shp, fX, fY, 0, 0x1004, _transparencyTable1, _transparencyTable2, sW, sH);
+			}
+
+			if (fb->finalize) {
+				if (++fb->finProgress >= 6) {
+					fb->active = false;
+					i++;
+				}
+			} else {
+				if (fb->step < 40)
+					fb->step += 2;
+				else
+					fb->step = 40;
+
+				if (fb->progress < fb->step) {
+					if (ii < 1) {
+						fb->progress = fb->step = fb->finProgress = 0;
+						fb->finalize = true;
+					} else {
+						fb->active = false;
+						i++;
+					}
+
+					static const uint8 fireballSfx[] = { 98, 167, 167, 168 };
+					snd_playSoundEffect(fireballSfx[d], -1);
+
+				} else {
+					fb->progress -= fb->step;
+				}
+			}
+		}
+
+		int del = _tickLength - (_system->getMillis() - ctime);
+		if (del > 0)
+			delay(del);
+
+		_screen->checkedPageUpdate(drawPage1, drawPage2);
+		_screen->updateScreen();
+		SWAP(drawPage1, drawPage2);
+		_screen->copyPage(12, drawPage1);
+	}
+
+	for (i = 0; i < numFireballs; i++)
+		delete fireballState[i];
+
+	_screen->setCurPage(cp);
+	_screen->copyPage(12, 0);
+	_screen->updateScreen();
+	updateDrawPage2();
+	snd_playQueuedEffects();
+	runLevelScriptCustom(bl, 0x20, charNum, 3, 0, 0);
+	return 1;
+}
+
+int LoLEngine::processMagicHandOfFate(int spellLevel) {
+	int cp = _screen->setCurPage(2);
+	_screen->copyPage(0, 12);
+
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+	mov->open("hand.wsa", 1, 0);
+	if (!mov->opened())
+		error("Hand: Unable to load HAND.WSA");
+
+	static const uint8 frames[] = { 17, 26, 11, 16, 27, 35, 27, 35, 0, 75 };
+
+	snd_playSoundEffect(173, -1);
+	playSpellAnimation(mov, 0, 10, 3, 112, 0, 0, 0, 0, 0, false);
+	snd_playSoundEffect(151, -1);
+	playSpellAnimation(mov, frames[spellLevel * 2] , frames[spellLevel * 2 + 1], 3, 112, 0, 0, 0, 0, 0, false);
+	snd_playSoundEffect(18, -1);
+	playSpellAnimation(mov, 10, 0, 3, 112, 0, 0, 0, 0, 0, false);
+
+	mov->close();
+	delete mov;
+
+	_screen->setCurPage(cp);
+	_screen->copyPage(12, 2);
+	gui_drawScene(2);
+
+	if (spellLevel < 2) {
+		uint16 b1 = calcNewBlockPosition(_currentBlock, _currentDirection);
+		uint16 b2 = calcNewBlockPosition(b1, _currentDirection);
+
+		if (!testWallFlag(b2, 0, 4)) {
+			if (!(_levelBlockProperties[b2].assignedObjects & 0x8000)) {
+				checkSceneUpdateNeed(b1);
+
+				uint16 dir = (_currentDirection << 1);
+				uint16 o = _levelBlockProperties[b1].assignedObjects;
+				while (o & 0x8000) {
+					uint16 o2 = o;
+					LoLMonster *m = &_monsters[o & 0x7FFF];
+					o = findObject(o)->nextAssignedObject;
+					int nX = 0;
+					int nY = 0;
+
+					getNextStepCoords(m->x, m->y, nX, nY, dir);
+					for (int i = 0; i < 7; i++)
+						getNextStepCoords(nX, nY, nX, nY, dir);
+
+					placeMonster(m, nX, nY);
+					runLevelScriptCustom(b2, 0x800, -1, o2, 0, 0);
+				}
+			}
+		}
+
+	} else {
+		uint16 b1 = calcNewBlockPosition(_currentBlock, _currentDirection);
+		checkSceneUpdateNeed(b1);
+
+		static const uint16 damage[] = { 75, 125, 175 };
+		uint16 o = _levelBlockProperties[b1].assignedObjects;
+
+		while (o & 0x8000) {
+			uint16 t = o;
+			o = findObject(o)->nextAssignedObject;
+			// This might be a bug in the original code, but using
+			// the hand of fate spell won't give any experience points
+			int dmg = calcInflictableDamagePerItem(-1, t, damage[spellLevel - 2], 0x80, 1);
+			inflictDamage(t, dmg, 0xFFFF, 3, 0x80);
+		}
+	}
+
+	if (_currentLevel == 29)
+		_screen->copyPage(12, 2);
+
+	_screen->copyPage(2, 0);
+	_screen->updateScreen();
+
+	gui_drawScene(2);
+	updateDrawPage2();
+	return 1;
+}
+
+int LoLEngine::processMagicMistOfDoom(int charNum, int spellLevel) {
+	static const uint8 mistDamage[] = { 30, 70, 110, 200 };
+
+	_envSfxUseQueue = true;
+	inflictMagicalDamageForBlock(calcNewBlockPosition(_currentBlock, _currentDirection), charNum, mistDamage[spellLevel], 0x80);
+	_envSfxUseQueue = false;
+
+	int cp = _screen->setCurPage(2);
+	_screen->copyPage(0, 2);
+	gui_drawScene(2);
+	_screen->copyPage(2, 12);
+
+	snd_playSoundEffect(155, -1);
+
+	Common::String wsafile = Common::String::format("mists%0d.wsa", spellLevel + 1);
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+	mov->open(wsafile.c_str(), 1, 0);
+	if (!mov->opened())
+		error("Mist: Unable to load %s", wsafile.c_str());
+
+	snd_playSoundEffect(_mistAnimData[spellLevel].sound, -1);
+	playSpellAnimation(mov, _mistAnimData[spellLevel].part1First, _mistAnimData[spellLevel].part1Last, 7, 112, 0, 0, 0, 0, 0, false);
+	playSpellAnimation(mov, _mistAnimData[spellLevel].part2First, _mistAnimData[spellLevel].part2Last, 14, 112, 0, 0, 0, 0, 0, false);
+
+	mov->close();
+	delete mov;
+
+	_screen->setCurPage(cp);
+	_screen->copyPage(12, 0);
+
+	updateDrawPage2();
+	snd_playQueuedEffects();
+	return 1;
+}
+
+int LoLEngine::processMagicLightning(int charNum, int spellLevel) {
+	_screen->hideMouse();
+	_screen->copyPage(0, 2);
+	gui_drawScene(2);
+	_screen->copyPage(2, 12);
+
+	_lightningCurSfx = _lightningProps[spellLevel].sfxId;
+	_lightningDiv = _lightningProps[spellLevel].frameDiv;
+	_lightningFirstSfx = 0;
+
+	Common::String wsafile = Common::String::format("litning%d.wsa", spellLevel + 1);
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+	mov->open(wsafile.c_str(), 1, 0);
+	if (!mov->opened())
+		error("Litning: Unable to load %s", wsafile.c_str());
+
+	for (int i = 0; i < 4; i++)
+		playSpellAnimation(mov, 0, _lightningProps[spellLevel].lastFrame, 3, 93, 0, &LoLEngine::callbackProcessMagicLightning, 0, 0, 0, false);
+
+	mov->close();
+	delete mov;
+
+	_screen->setScreenPalette(_screen->getPalette(1));
+	_screen->copyPage(12, 2);
+	_screen->copyPage(12, 0);
+	updateDrawPage2();
+
+	static const uint8 lightningDamage[] = { 18, 35, 50, 72 };
+	inflictMagicalDamageForBlock(calcNewBlockPosition(_currentBlock, _currentDirection), charNum, lightningDamage[spellLevel], 5);
+
+	_sceneUpdateRequired = true;
+	gui_drawScene(0);
+	_screen->showMouse();
+	return 1;
+}
+
+int LoLEngine::processMagicFog() {
+	int cp = _screen->setCurPage(2);
+	_screen->copyPage(0, 12);
+
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+	int numFrames = mov->open("fog.wsa", 0, 0);
+	if (!mov->opened())
+		error("Fog: Unable to load fog.wsa");
+
+	snd_playSoundEffect(145, -1);
+
+	for (int curFrame = 0; curFrame < numFrames; curFrame++) {
+		uint32 delayTimer = _system->getMillis() + 3 * _tickLength;
+		_screen->copyPage(12, 2);
+		mov->displayFrame(curFrame % numFrames, 2, 112, 0, 0x5000, _transparencyTable1, _transparencyTable2);
+		_screen->copyRegion(112, 0, 112, 0, 176, 120, 2, 0, Screen::CR_NO_P_CHECK);
+		_screen->updateScreen();
+		delayUntil(delayTimer);
+	}
+
+	mov->close();
+	delete mov;
+
+	_screen->copyPage(12, 2);
+	_screen->setCurPage(cp);
+	updateDrawPage2();
+
+	uint16 o = _levelBlockProperties[calcNewBlockPosition(_currentBlock, _currentDirection)].assignedObjects;
+	while (o & 0x8000) {
+		inflictMagicalDamage(o, -1, 15, 6, 0);
+		o = _monsters[o & 0x7FFF].nextAssignedObject;
+	}
+
+	gui_drawScene(0);
+	return 1;
+}
+
+int LoLEngine::processMagicSwarm(int charNum, int damage) {
+	createTransparencyTables();
+
+	int cp = _screen->setCurPage(2);
+	_screen->copyPage(0, 12);
+	snd_playSoundEffect(74, -1);
+
+	uint16 destIds[6];
+	uint8 destModes[6];
+	int8 destTicks[6];
+
+	memset(destIds, 0, sizeof(destIds));
+	memset(destModes, 8, sizeof(destModes));
+	memset(destTicks, 0, sizeof(destTicks));
+
+	int t = 0;
+	uint16 o = _levelBlockProperties[calcNewBlockPosition(_currentBlock, _currentDirection)].assignedObjects;
+	while (o & 0x8000) {
+		o &= 0x7FFF;
+		if (_monsters[o].mode != 13) {
+			destIds[t++] = o;
+
+			if (!(_monsters[o].flags & 0x2000)) {
+				_envSfxUseQueue = true;
+				inflictMagicalDamage(o | 0x8000, charNum, damage, 0, 0);
+				_envSfxUseQueue = false;
+				_monsters[o].flags &= 0xFFEF;
+			}
+		}
+		o = _monsters[o].nextAssignedObject;
+	}
+
+	for (int i = 0; i < t; i++) {
+		SWAP(destModes[i], _monsters[destIds[i]].mode);
+		SWAP(destTicks[i], _monsters[destIds[i]].fightCurTick);
+	}
+
+	gui_drawScene(_screen->_curPage);
+	_screen->copyRegion(112, 0, 112, 0, 176, 120, _screen->_curPage, 7);
+
+	for (int i = 0; i < t; i++) {
+		_monsters[destIds[i]].mode = destModes[i];
+		_monsters[destIds[i]].fightCurTick = destTicks[i];
+	}
+
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+
+	mov->open("swarm.wsa", 0, 0);
+	if (!mov->opened())
+		error("Swarm: Unable to load SWARM.WSA");
+	_screen->hideMouse();
+	playSpellAnimation(mov, 0, 37, 2, 0, 0, 0, 0, 0, 0, false);
+	playSpellAnimation(mov, 38, 41, 8, 0, 0, &LoLEngine::callbackProcessMagicSwarm, 0, 0, 0, false);
+	_screen->showMouse();
+	mov->close();
+
+	_screen->copyPage(12, 0);
+	_screen->updateScreen();
+	updateDrawPage2();
+
+	snd_playQueuedEffects();
+
+	_screen->setCurPage(cp);
+	delete mov;
+	return 1;
+}
+
+int LoLEngine::processMagicVaelansCube() {
+	uint8 *sp1 = _screen->getPalette(1).getData();
+	int len = _screen->getPalette(1).getNumColors() * 3;
+
+	uint8 *tmpPal1 = new uint8[len];
+	uint8 *tmpPal2 = new uint8[len];
+
+	memcpy(tmpPal1, sp1, len);
+	memcpy(tmpPal2, sp1, len);
+
+	if (_flags.use16ColorMode) {
+		for (int i = 0; i < 16; i++) {
+			uint16 a = sp1[i * 3 + 1] + 16;
+			tmpPal2[i * 3 + 1] = (a > 58) ? 58 : a;
+			tmpPal2[i * 3] = sp1[i * 3];
+			a = sp1[i * 3 + 2] + 16;
+			tmpPal2[i * 3 + 2] = (a > 63) ? 63 : a;
+		}
+	} else {
+		for (int i = 0; i < 128; i++) {
+			uint16 a = sp1[i * 3] + 16;
+			tmpPal2[i * 3] = (a > 60) ? 60 : a;
+			tmpPal2[i * 3 + 1] = sp1[i * 3 + 1];
+			a = sp1[i * 3 + 2] + 19;
+			tmpPal2[i * 3 + 2] = (a > 60) ? 60 : a;
+		}
+	}
+
+	snd_playSoundEffect(146, -1);
+
+	uint32 ctime = _system->getMillis();
+	uint32 endTime = _system->getMillis() + 70 * _tickLength;
+
+	while (_system->getMillis() < endTime) {
+		_screen->timedPaletteFadeStep(tmpPal1, tmpPal2, _system->getMillis() - ctime, 70 * _tickLength);
+		updateInput();
+	}
+
+	uint16 bl = calcNewBlockPosition(_currentBlock, _currentDirection);
+	uint8 s = _levelBlockProperties[bl].walls[_currentDirection ^ 2];
+	uint8 flg = _wllWallFlags[s];
+
+	int res = (s == 47 && (_currentLevel == 17 || _currentLevel == 24)) ? 1 : 0;
+	if ((_wllVmpMap[s] == 1 || _wllVmpMap[s] == 2) && (!(flg & 1)) && (_currentLevel != 22)) {
+		memset(_levelBlockProperties[bl].walls, 0, 4);
+		gui_drawScene(0);
+		res = 1;
+	}
+
+	uint16 o = _levelBlockProperties[bl].assignedObjects;
+	while (o & 0x8000) {
+		LoLMonster *m = &_monsters[o & 0x7FFF];
+		if (m->properties->flags & 0x1000) {
+			inflictDamage(o, 100, 0xFFFF, 0, 0x80);
+			res = 1;
+		}
+		o = m->nextAssignedObject;
+	}
+
+	ctime = _system->getMillis();
+	endTime = _system->getMillis() + 70 * _tickLength;
+
+	while (_system->getMillis() < endTime) {
+		_screen->timedPaletteFadeStep(tmpPal2, tmpPal1, _system->getMillis() - ctime, 70 * _tickLength);
+		updateInput();
+	}
+
+	delete[] tmpPal1;
+	delete[] tmpPal2;
+
+	return res;
+}
+
+int LoLEngine::processMagicGuardian(int charNum) {
+	int cp = _screen->setCurPage(2);
+	_screen->copyPage(0, 2);
+	_screen->copyPage(2, 12);
+
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+	mov->open("guardian.wsa", 0, 0);
+	if (!mov->opened())
+		error("Guardian: Unable to load guardian.wsa");
+	snd_playSoundEffect(156, -1);
+	playSpellAnimation(mov, 0, 37, 2, 112, 0, 0, 0, 0, 0, false);
+
+	_screen->copyPage(2, 12);
+
+	uint16 bl = calcNewBlockPosition(_currentBlock, _currentDirection);
+	int res = (_levelBlockProperties[bl].assignedObjects & 0x8000) ? 1 : 0;
+	inflictMagicalDamageForBlock(bl, charNum, 200, 0x80);
+
+	_screen->copyPage(12, 2);
+	updateDrawPage2();
+	gui_drawScene(2);
+
+	_screen->copyPage(2, 12);
+	snd_playSoundEffect(176, -1);
+	playSpellAnimation(mov, 38, 48, 8, 112, 0, 0, 0, 0, 0, false);
+
+	mov->close();
+	delete mov;
+
+	_screen->setCurPage(cp);
+	gui_drawPlayField();
+	updateDrawPage2();
+	return res;
+}
+
+void LoLEngine::callbackProcessMagicSwarm(WSAMovie_v2 *mov, int x, int y) {
+	if (_swarmSpellStatus)
+		_screen->copyRegion(112, 0, 112, 0, 176, 120, 6, _screen->_curPage);
+	_swarmSpellStatus ^= 1;
+}
+
+void LoLEngine::callbackProcessMagicLightning(WSAMovie_v2 *mov, int x, int y) {
+	if (_lightningDiv == 2)
+		shakeScene(1, 2, 3, 0);
+
+	const Palette &p1 = _screen->getPalette(1);
+
+	if (_lightningSfxFrame % _lightningDiv) {
+		_screen->setScreenPalette(p1);
+	} else {
+		Palette tpal(p1.getNumColors());
+		tpal.copy(p1);
+
+		int start = 6;
+		int end = 384;
+
+		if (_flags.use16ColorMode) {
+			start = 3;
+			end = 48;
+		}
+
+		for (int i = start; i < end; i++) {
+			uint16 v = (tpal[i] * 120) / 64;
+			tpal[i] = (v < 64) ? v : 63;
+		}
+
+		_screen->setScreenPalette(tpal);
+	}
+
+	if (_lightningDiv == 2) {
+		if (!_lightningFirstSfx) {
+			snd_playSoundEffect(_lightningCurSfx, -1);
+			_lightningFirstSfx = 1;
+		}
+	} else {
+		if (!(_lightningSfxFrame & 7))
+			snd_playSoundEffect(_lightningCurSfx, -1);
+	}
+
+	_lightningSfxFrame++;
+}
+
+void LoLEngine::drinkBezelCup(int numUses, int charNum) {
+	createTransparencyTables();
+
+	int cp = _screen->setCurPage(2);
+	snd_playSoundEffect(73, -1);
+
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+	mov->open("bezel.wsa", 0, 0);
+	if (!mov->opened())
+		error("Bezel: Unable to load bezel.wsa");
+
+	int x = _activeCharsXpos[charNum] - 11;
+	int y = 124;
+	int w = mov->width();
+	int h = mov->height();
+
+	_screen->copyRegion(x, y, 0, 0, w, h, 0, 2, Screen::CR_NO_P_CHECK);
+
+	static const uint8 bezelAnimData[] = { 0, 26, 20, 27, 61, 55, 62, 92, 86, 93, 131, 125 };
+	int frm = bezelAnimData[numUses * 3];
+	int hpDiff = _characters[charNum].hitPointsMax - _characters[charNum].hitPointsCur;
+	uint16 step = 0;
+
+	do {
+		step = (step & 0xFF) + (hpDiff * 256) / (bezelAnimData[numUses * 3 + 1]);
+		increaseCharacterHitpoints(charNum, step / 256, true);
+		gui_drawCharPortraitWithStats(charNum);
+
+		uint32 etime = _system->getMillis() + 4 * _tickLength;
+
+		_screen->copyRegion(0, 0, x, y, w, h, 2, 2, Screen::CR_NO_P_CHECK);
+		mov->displayFrame(frm, 2, x, y, _flags.use16ColorMode ? 0x4000 : 0x5000, _transparencyTable1, _transparencyTable2);
+		_screen->copyRegion(x, y, x, y, w, h, 2, 0, Screen::CR_NO_P_CHECK);
+		_screen->updateScreen();
+
+		delayUntil(etime);
+	} while (++frm < bezelAnimData[numUses * 3 + 1]);
+
+	_characters[charNum].hitPointsCur = _characters[charNum].hitPointsMax;
+	_screen->copyRegion(0, 0, x, y, w, h, 2, 2, Screen::CR_NO_P_CHECK);
+	removeCharacterEffects(&_characters[charNum], 4, 4);
+	gui_drawCharPortraitWithStats(charNum);
+	_screen->copyRegion(x, y, x, y, w, h, 2, 0, Screen::CR_NO_P_CHECK);
+	_screen->updateScreen();
+
+	mov->close();
+	delete mov;
+
+	_screen->setCurPage(cp);
+}
+
+void LoLEngine::addSpellToScroll(int spell, int charNum) {
+	bool assigned = false;
+	int slot = 0;
+	for (int i = 0; i < 7; i++) {
+		if (!assigned && _availableSpells[i] == -1) {
+			assigned = true;
+			slot = i;
+		}
+
+		if (_availableSpells[i] == spell) {
+			_txt->printMessage(2, "%s", getLangString(0x42D0));
+			return;
+		}
+	}
+
+	if (spell > 1)
+		transferSpellToScollAnimation(charNum, spell, slot - 1);
+
+	_availableSpells[slot] = spell;
+	gui_enableDefaultPlayfieldButtons();
+}
+
+void LoLEngine::transferSpellToScollAnimation(int charNum, int spell, int slot)  {
+	int cX = 16 + _activeCharsXpos[charNum];
+
+	if (slot != 1) {
+		_screen->loadBitmap("playfld.cps", 3, 3, 0);
+		_screen->copyRegion(8, 0, 216, 0, 96, 120, 3, 3, Screen::CR_NO_P_CHECK);
+		_screen->copyPage(3, 10);
+		for (int i = 0; i < 9; i++) {
+			int h = (slot + 1) * 9 + i + 1;
+			uint32 delayTimer = _system->getMillis() + _tickLength;
+			_screen->copyPage(10, 3);
+			_screen->copyRegion(216, 0, 8, 0, 96, 120, 3, 3, Screen::CR_NO_P_CHECK);
+			_screen->copyRegion(112, 0, 12, 0, 87, 15, 2, 2, Screen::CR_NO_P_CHECK);
+			_screen->copyRegion(201, 1, 17, 15, 6, h, 2, 2, Screen::CR_NO_P_CHECK);
+			_screen->copyRegion(208, 1, 89, 15, 6, h, 2, 2, Screen::CR_NO_P_CHECK);
+			int cp = _screen->setCurPage(2);
+			_screen->fillRect(21, 15, 89, h + 15, _flags.use16ColorMode ? 0xBB : 206);
+			_screen->copyRegion(112, 16, 12, h + 15, 87, 14, 2, 2, Screen::CR_NO_P_CHECK);
+
+			int y = 15;
+			Screen::FontId of = _screen->setFont(Screen::FID_9_FNT);
+			for (int ii = 0; ii < 7; ii++) {
+				if (_availableSpells[ii] == -1)
+					continue;
+				uint8 col = (ii == _selectedSpell) ? 132 : 1;
+				if (_flags.use16ColorMode)
+					col = (ii == _selectedSpell) ? 0x88 : 0x44;
+				_screen->fprintString("%s", 24, y, col, 0, 0, getLangString(_spellProperties[_availableSpells[ii]].spellNameCode));
+				y += 9;
+			}
+			_screen->setFont(of);
+
+			_screen->setCurPage(cp);
+			_screen->copyRegion(8, 0, 8, 0, 96, 120, 3, 0, Screen::CR_NO_P_CHECK);
+			_screen->updateScreen();
+
+			delayUntil(delayTimer);
+		}
+	}
+
+	_screen->hideMouse();
+
+	_screen->copyPage(0, 12);
+	int vX = _updateSpellBookCoords[slot << 1] + 32;
+	int vY = _updateSpellBookCoords[(slot << 1) + 1] + 5;
+
+	Common::String wsaFile = Common::String::format("write%0d", spell);
+	if (_flags.isTalkie)
+		wsaFile += (_lang == 1) ? 'f' : (_lang == 0 ? 'e' : 'g');
+	wsaFile += ".wsa";
+	snd_playSoundEffect(_updateSpellBookAnimData[(spell << 2) + 3], -1);
+	snd_playSoundEffect(95, -1);
+
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+
+	mov->open("getspell.wsa", 0, 0);
+	if (!mov->opened())
+		error("SpellBook: Unable to load getspell anim");
+	snd_playSoundEffect(128, -1);
+	playSpellAnimation(mov, 0, 25, 5, _activeCharsXpos[charNum], 148, 0, 0, 0, 0, true);
+	snd_playSoundEffect(128, -1);
+	playSpellAnimation(mov, 26, 52, 5, _activeCharsXpos[charNum], 148, 0, 0, 0, 0, true);
+
+	for (int i = 16; i > 0; i--) {
+		uint32 delayTimer = _system->getMillis() + _tickLength;
+		_screen->copyPage(12, 2);
+
+		int wsaX = vX + (((((cX - vX) << 8) / 16) * i) >> 8) - 16;
+		int wsaY = vY + (((((160 - vY) << 8) / 16) * i) >> 8) - 16;
+
+		mov->displayFrame(51, 2, wsaX, wsaY, 0x5000, _transparencyTable1, _transparencyTable2);
+
+		_screen->copyRegion(wsaX, wsaY, wsaX, wsaY, mov->width() + 48, mov->height() + 48, 2, 0, Screen::CR_NO_P_CHECK);
+		_screen->updateScreen();
+
+		delayUntil(delayTimer);
+	}
+
+	mov->close();
+
+	mov->open("spellexp.wsa", 0, 0);
+	if (!mov->opened())
+		error("SpellBook: Unable to load spellexp anim");
+	snd_playSoundEffect(168, -1);
+	playSpellAnimation(mov, 0, 8, 3, vX - 44, vY - 38, 0, 0, 0, 0, true);
+	mov->close();
+
+	mov->open("writing.wsa", 0, 0);
+	if (!mov->opened())
+		error("SpellBook: Unable to load writing anim");
+	playSpellAnimation(mov, 0, 6, 5, _updateSpellBookCoords[slot << 1], _updateSpellBookCoords[(slot << 1) + 1], 0, 0, 0, 0, false);
+	mov->close();
+
+	mov->open(wsaFile.c_str(), 0, 0);
+	if (!mov->opened())
+		error("SpellBook: Unable to load spellbook anim");
+	snd_playSoundEffect(_updateSpellBookAnimData[(spell << 2) + 3], -1);
+	playSpellAnimation(mov, _updateSpellBookAnimData[(spell << 2) + 1], _updateSpellBookAnimData[(spell << 2) + 2], _updateSpellBookAnimData[spell << 2], _updateSpellBookCoords[slot << 1], _updateSpellBookCoords[(slot << 1) + 1], 0, 0, 0, 0, false);
+	mov->close();
+
+	gui_drawScene(2);
+	updateDrawPage2();
+
+	_screen->showMouse();
+
+	delete mov;
+}
+
+void LoLEngine::playSpellAnimation(WSAMovie_v2 *mov, int firstFrame, int lastFrame, int frameDelay, int x, int y, SpellProcCallback callback, uint8 *pal1, uint8 *pal2, int fadeDelay, bool restoreScreen) {
+	int w = 0;
+	int h = 0;
+
+	if (mov) {
+		w = mov->width();
+		h = mov->height();
+	}
+
+	int w2 = w;
+	int h2 = h;
+	uint32 startTime = _system->getMillis();
+
+	if (x < 0)
+		w2 += x;
+	if (y < 0)
+		h2 += y;
+
+	int dir = lastFrame >= firstFrame ? 1 : -1;
+	int curFrame = firstFrame;
+
+	bool fin = false;
+
+	while (!fin) {
+		uint32 delayTimer = _system->getMillis() + _tickLength * frameDelay;
+
+		if (mov || callback)
+			_screen->copyPage(12, 2);
+
+		if (callback)
+			(this->*callback)(mov, x, y);
+
+		if (mov)
+			mov->displayFrame(curFrame % mov->frames(), 2, x, y, _flags.use16ColorMode ? 0x4000 : 0x5000, _transparencyTable1, _transparencyTable2);
+
+		if (mov || callback) {
+			_screen->copyRegion(x, y, x, y, w2, h2, 2, 0, Screen::CR_NO_P_CHECK);
+			_screen->updateScreen();
+		}
+
+		uint32 tm = _system->getMillis();
+		uint32 del = (delayTimer > tm) ? (delayTimer - tm) : 0;
+
+		do {
+			uint32 step = del > _tickLength ? _tickLength : del;
+
+			if (!pal1 || !pal2) {
+				if (del) {
+					delay(step);
+					del -= step;
+				} else {
+					updateInput();
+				}
+				continue;
+			}
+
+			if (!_screen->timedPaletteFadeStep(pal1, pal2, _system->getMillis() - startTime, _tickLength * fadeDelay) && !mov)
+				return;
+
+			if (del) {
+				delay(step);
+				del -= step;
+			} else {
+				updateInput();
+			}
+		} while (del);
+
+		if (!mov)
+			continue;
+
+		curFrame += dir;
+		if ((dir > 0 && curFrame >= lastFrame) || (dir < 0 && curFrame < lastFrame))
+			fin = true;
+	}
+
+	if (restoreScreen && (mov || callback)) {
+		_screen->copyPage(12, 2);
+		_screen->copyRegion(x, y, x, y, w2, h2, 2, 0, Screen::CR_NO_P_CHECK);
+		_screen->updateScreen();
+	}
+}
+
+int LoLEngine::checkMagic(int charNum, int spellNum, int spellLevel) {
+	if (_spellProperties[spellNum].mpRequired[spellLevel] > _characters[charNum].magicPointsCur) {
+		if (characterSays(0x4043, _characters[charNum].id, true))
+			_txt->printMessage(6, getLangString(0x4043), _characters[charNum].name);
+		return 1;
+	} else if (_spellProperties[spellNum].hpRequired[spellLevel] >= _characters[charNum].hitPointsCur) {
+		_txt->printMessage(2, getLangString(0x4179), _characters[charNum].name);
+		return 1;
+	}
+
+	return 0;
+}
+
+int LoLEngine::getSpellTargetBlock(int currentBlock, int direction, int maxDistance, uint16 &targetBlock) {
+	targetBlock = 0xFFFF;
+	uint16 c = calcNewBlockPosition(currentBlock, direction);
+
+	int i = 0;
+	for (; i < maxDistance; i++) {
+		if (_levelBlockProperties[currentBlock].assignedObjects & 0x8000) {
+			targetBlock = currentBlock;
+			return i;
+		}
+
+		if (_wllWallFlags[_levelBlockProperties[c].walls[direction ^ 2]] & 7) {
+			targetBlock = c;
+			return i;
+		}
+
+		currentBlock = c;
+		c = calcNewBlockPosition(currentBlock, direction);
+	}
+
+	return i;
+}
+
+void LoLEngine::inflictMagicalDamage(int target, int attacker, int damage, int index, int hitType) {
+	hitType = hitType ? 1 : 2;
+	damage = calcInflictableDamagePerItem(attacker, target, damage, index, hitType);
+	inflictDamage(target, damage, attacker, 2, index);
+}
+
+void LoLEngine::inflictMagicalDamageForBlock(int block, int attacker, int damage, int index) {
+	uint16 o = _levelBlockProperties[block].assignedObjects;
+	while (o & 0x8000) {
+		inflictDamage(o, calcInflictableDamagePerItem(attacker, o, damage, index, 2), attacker, 2, index);
+		if ((_monsters[o & 0x7FFF].flags & 0x20) && (_currentLevel != 22))
+			break;
+		o = _monsters[o & 0x7FFF].nextAssignedObject;
+	}
+}
+
+// fight
+
+int LoLEngine::battleHitSkillTest(int16 attacker, int16 target, int skill) {
+	if (target == -1)
+		return 0;
+	if (attacker == -1)
+		return 1;
+
+	if (target & 0x8000) {
+		if (_monsters[target & 0x7FFF].mode >= 13)
+			return 0;
+	}
+
+	uint16 hitChanceModifier = 0;
+	uint16 evadeChanceModifier = 0;
+	int sk = 0;
+
+	if (attacker & 0x8000) {
+		hitChanceModifier = _monsters[target & 0x7FFF].properties->fightingStats[0];
+		sk = 100 - _monsters[target & 0x7FFF].properties->skillLevel;
+	} else {
+		hitChanceModifier = _characters[attacker].defaultModifiers[0];
+		int8 m = _characters[attacker].skillModifiers[skill];
+		if (skill == 1)
+			m *= 3;
+		sk = 100 - (_characters[attacker].skillLevels[skill] + m);
+	}
+
+	if (target & 0x8000) {
+		evadeChanceModifier = _monsters[target & 0x7FFF].properties->fightingStats[3];
+		if (_monsterModifiers4)
+			evadeChanceModifier = (evadeChanceModifier * _monsterModifiers4[_monsterDifficulty]) >> 8;
+		_monsters[target & 0x7FFF].flags |= 0x10;
+	} else {
+		evadeChanceModifier = _characters[target].defaultModifiers[3];
+	}
+
+	int r = rollDice(1, 100);
+	if (r >= sk)
+		return 2;
+
+	uint16 v = (evadeChanceModifier << 8) / hitChanceModifier;
+
+	if (r < v)
+		return 0;
+
+	return 1;
+}
+
+int LoLEngine::calcInflictableDamage(int16 attacker, int16 target, int hitType) {
+	const uint16 *s = getCharacterOrMonsterItemsMight(attacker);
+
+	// The original code looks somewhat like the commented out part of the next line.
+	// In the end the value is always set to zero. I do not know whether this is done on purpose or not.
+	// It might be a bug in the original code.
+	int res = 0/*attacker & 0x8000 ? 0 : _characters[attacker].might*/;
+	for (int i = 0; i < 8; i++)
+		res += calcInflictableDamagePerItem(attacker, target, s[i], i, hitType);
+
+	return res;
+}
+
+int LoLEngine::inflictDamage(uint16 target, int damage, uint16 attacker, int skill, int flags) {
+	LoLMonster *m = 0;
+	LoLCharacter *c = 0;
+
+	if (target & 0x8000) {
+		m = &_monsters[target & 0x7FFF];
+		if (m->mode >= 13)
+			return 0;
+
+		if (damage > 0) {
+			m->hitPoints -= damage;
+			m->damageReceived = 0x8000 | damage;
+			m->flags |= 0x10;
+			m->hitOffsX = rollDice(1, 24);
+			m->hitOffsX -= 12;
+			m->hitOffsY = rollDice(1, 24);
+			m->hitOffsY -= 12;
+			m->hitPoints = CLIP<int16>(m->hitPoints, 0, m->properties->hitPoints);
+
+			if (!(attacker & 0x8000))
+				applyMonsterDefenseSkill(m, attacker, flags, skill, damage);
+
+			snd_queueEnvironmentalSoundEffect(m->properties->sounds[2], m->block);
+			checkSceneUpdateNeed(m->block);
+
+			if (m->hitPoints <= 0) {
+				m->hitPoints = 0;
+				if (!(attacker & 0x8000))
+					increaseExperience(attacker, skill, m->properties->hitPoints);
+				setMonsterMode(m, 13);
+			}
+		} else {
+			m->hitPoints -= damage;
+			m->hitPoints = CLIP<int16>(m->hitPoints, 1, m->properties->hitPoints);
+		}
+
+	} else {
+		if (target > 3) {
+			// WORKAROUND for script bug
+			int i = 0;
+			for (; i < 4; i++) {
+				if (_characters[i].id == target) {
+					target = i;
+					break;
+				}
+			}
+			if (i == 4)
+				return 0;
+		}
+
+		c = &_characters[target];
+		if (!(c->flags & 1) || (c->flags & 8))
+			return 0;
+
+		if (!(c->flags & 0x1000))
+			snd_playSoundEffect(c->screamSfx, -1);
+
+		setTemporaryFaceFrame(target, 6, 4, 0);
+
+		// check for equipped cloud ring
+		if (flags == 4 && itemEquipped(target, 229))
+			damage >>= 2;
+
+		setCharacterMagicOrHitPoints(target, 0, -damage, 1);
+
+		if (c->hitPointsCur <= 0) {
+			characterHitpointsZero(target, flags);
+		} else {
+			_characters[target].damageSuffered = damage;
+			setCharacterUpdateEvent(target, 2, 4, 1);
+		}
+		gui_drawCharPortraitWithStats(target);
+	}
+
+	if (!(attacker & 0x8000)) {
+		if (!skill)
+			_characters[attacker].weaponHit = damage;
+		increaseExperience(attacker, skill, damage);
+	}
+
+	return damage;
+}
+
+void LoLEngine::characterHitpointsZero(int16 charNum, int flags) {
+	LoLCharacter *c = &_characters[charNum];
+	c->hitPointsCur = 0;
+	c->flags |= 8;
+	removeCharacterEffects(c, 1, 5);
+	_partyDamageFlags = flags;
+}
+
+void LoLEngine::removeCharacterEffects(LoLCharacter *c, int first, int last) {
+	for (int i = first; i <= last; i++) {
+		switch (i - 1) {
+		case 0:
+			c->flags &= 0xFFFB;
+			c->weaponHit = 0;
+			break;
+
+		case 1:
+			c->damageSuffered = 0;
+			break;
+
+		case 2:
+			c->flags &= 0xFFBF;
+			break;
+
+		case 3:
+			c->flags &= 0xFF7F;
+			break;
+
+		case 4:
+			c->flags &= 0xFEFF;
+			break;
+
+		case 6:
+			c->flags &= 0xEFFF;
+			break;
+
+		default:
+			break;
+		}
+
+		for (int ii = 0; ii < 5; ii++) {
+			if (i != c->characterUpdateEvents[ii])
+				continue;
+
+			c->characterUpdateEvents[ii] = 0;
+			c->characterUpdateDelay[ii] = 0;
+		}
+	}
+
+	_timer->enable(3);
+}
+
+int LoLEngine::calcInflictableDamagePerItem(int16 attacker, int16 target, uint16 itemMight, int index, int hitType) {
+	int dmg = (attacker == -1) ? 0x100 : getCharacterOrMonsterStats(attacker)[1];
+	const uint16 *st_t = getCharacterOrMonsterProtectionAgainstItems(target);
+
+	dmg = (dmg * itemMight) >> 8;
+	if (!dmg)
+		return 0;
+
+	if (!(attacker & 0x8000)) {
+		dmg = (dmg * _characters[attacker].totalMightModifier) >> 8;
+		if (!dmg)
+			return 0;
+	}
+
+	int d = (index & 0x80) ? st_t[7] : st_t[index];
+	int r = (dmg * ABS(d)) >> 8;
+	dmg = d < 0 ? -r : r;
+
+	if (hitType == 2 || !dmg)
+		return (dmg == 1) ? 2 : dmg;
+
+
+	int p = (calculateProtection(target) << 7) / dmg;
+	if (p > 217)
+		p = 217;
+
+	d = 256 - p;
+	r = (dmg * ABS(d)) >> 8;
+	dmg = d < 0 ? -r : r;
+
+	return (dmg < 2) ? 2 : dmg;
+}
+
+void LoLEngine::checkForPartyDeath() {
+	Button b;
+	b.data0Val2 = b.data1Val2 = b.data2Val2 = 0xFE;
+	b.data0Val3 = b.data1Val3 = b.data2Val3 = 0x01;
+
+	for (int i = 0; i < 4; i++) {
+		if (!(_characters[i].flags & 1) || _characters[i].hitPointsCur <= 0)
+			continue;
+		return;
+	}
+
+	if (_weaponsDisabled)
+		clickedExitCharInventory(&b);
+
+	gui_drawAllCharPortraitsWithStats();
+
+	if (_partyDamageFlags & 0x40) {
+		_screen->fadeToBlack(40);
+		for (int i = 0; i < 4; i++) {
+			if (_characters[i].flags & 1)
+				increaseCharacterHitpoints(i, 1, true);
+		}
+		gui_drawAllCharPortraitsWithStats();
+		_screen->fadeToPalette1(40);
+
+	} else {
+		if (!_flags.use16ColorMode)
+			_screen->fadeClearSceneWindow(10);
+		restoreAfterSpecialScene(0, 1, 1, 0);
+
+		snd_playTrack(325);
+		stopPortraitSpeechAnim();
+		initTextFading(0, 1);
+		setMouseCursorToIcon(0);
+		_updateFlags |= 4;
+		setLampMode(true);
+		disableSysTimer(2);
+
+		_gui->runMenu(_gui->_deathMenu);
+
+		setMouseCursorToItemInHand();
+		_updateFlags &= 0xFFFB;
+		resetLampStatus();
+
+		gui_enableDefaultPlayfieldButtons();
+		enableSysTimer(2);
+		updateDrawPage2();
+	}
+}
+
+void LoLEngine::applyMonsterAttackSkill(LoLMonster *monster, int16 target, int16 damage) {
+	if (rollDice(1, 100) > monster->properties->attackSkillChance)
+		return;
+
+	int t = 0;
+
+	switch (monster->properties->attackSkillType - 1) {
+	case 0:
+		t = removeCharacterItem(target, 0x7FF);
+		if (t) {
+			giveItemToMonster(monster, t);
+			if (characterSays(0x4019, _characters[target].id, true))
+				_txt->printMessage(6, "%s", getLangString(0x4019));
+		}
+		break;
+
+	case 1:
+		// poison character
+		paralyzePoisonCharacter(target, 0x80, 0x88, 100, 1);
+		break;
+
+	case 2:
+		t = removeCharacterItem(target, 0x20);
+		if (t) {
+			deleteItem(t);
+			if (characterSays(0x401B, _characters[target].id, true))
+				_txt->printMessage(6, "%s", getLangString(0x401B));
+		}
+		break;
+
+	case 3:
+		t = removeCharacterItem(target, 0x0F);
+		if (t) {
+			if (characterSays(0x401E, _characters[target].id, true))
+				_txt->printMessage(6, getLangString(0x401E), _characters[target].name);
+			setItemPosition(t, monster->x, monster->y, 0, 1);
+		}
+		break;
+
+	case 5:
+		if (_characters[target].magicPointsCur <= 0)
+			return;
+
+		monster->hitPoints += _characters[target].magicPointsCur;
+		_characters[target].magicPointsCur = 0;
+		gui_drawCharPortraitWithStats(target);
+		if (characterSays(0x4020, _characters[target].id, true))
+			_txt->printMessage(6, getLangString(0x4020), _characters[target].name);
+		break;
+
+	case 7:
+		stunCharacter(target);
+		break;
+
+	case 8:
+		monster->hitPoints += damage;
+		if (monster->hitPoints > monster->properties->hitPoints)
+			monster->hitPoints = monster->properties->hitPoints;
+		break;
+
+	case 9:
+		// paralyze party (spider web)
+		paralyzePoisonAllCharacters(0x40, 0x48, 100);
+		break;
+
+	default:
+		break;
+	}
+}
+
+void LoLEngine::applyMonsterDefenseSkill(LoLMonster *monster, int16 attacker, int flags, int skill, int damage) {
+	if (rollDice(1, 100) > monster->properties->defenseSkillChance)
+		return;
+
+	int itm = 0;
+
+	switch (monster->properties->defenseSkillType - 1) {
+	case 0:
+	case 1:
+		if ((flags & 0x3F) == 2 || skill)
+			return;
+
+		for (int i = 0; i < 3; i++) {
+			itm = _characters[attacker].items[i];
+			if (!itm)
+				continue;
+			if ((_itemProperties[_itemsInPlay[itm].itemPropertyIndex].protection & 0x3F) != flags)
+				continue;
+
+			removeCharacterItem(attacker, 0x7FFF);
+
+			if (monster->properties->defenseSkillType == 1) {
+				giveItemToMonster(monster, itm);
+				if (characterSays(0x401C, _characters[attacker].id, true))
+					_txt->printMessage(6, "%s", getLangString(0x401C));
+
+			} else {
+				deleteItem(itm);
+				if (characterSays(0x401D, _characters[attacker].id, true))
+					_txt->printMessage(6, "%s", getLangString(0x401D));
+			}
+		}
+		break;
+
+	case 2:
+		if (!(flags & 0x80))
+			return;
+		monster->flags |= 8;
+		monster->direction = calcMonsterDirection(monster->x, monster->y, _partyPosX, _partyPosY) ^ 4;
+		setMonsterMode(monster, 9);
+		monster->fightCurTick = 30;
+		break;
+
+	case 3:
+		if (flags != 3)
+			return;
+		monster->hitPoints += damage;
+		if (monster->hitPoints > monster->properties->hitPoints)
+			monster->hitPoints = monster->properties->hitPoints;
+		break;
+
+	case 4:
+		if (!(flags & 0x80))
+			return;
+		monster->hitPoints += damage;
+		if (monster->hitPoints > monster->properties->hitPoints)
+			monster->hitPoints = monster->properties->hitPoints;
+		break;
+
+	case 5:
+		if ((flags & 0x84) == 0x84)
+			monster->numDistAttacks++;
+		break;
+
+	default:
+		break;
+	}
+}
+
+int LoLEngine::removeCharacterItem(int charNum, int itemFlags) {
+	for (int i = 0; i < 11; i++) {
+		int s = _characters[charNum].items[i];
+		if (!((1 << i) & itemFlags) || !s)
+			continue;
+
+		_characters[charNum].items[i] = 0;
+		runItemScript(charNum, s, 0x100, 0, 0);
+
+		return s;
+	}
+
+	return 0;
+}
+
+int LoLEngine::paralyzePoisonCharacter(int charNum, int typeFlag, int immunityFlags, int hitChance, int redraw) {
+	if (!(_characters[charNum].flags & 1) || (_characters[charNum].flags & immunityFlags))
+		return 0;
+
+	if (rollDice(1, 100) > hitChance)
+		return 0;
+
+	int r = 0;
+
+	if (typeFlag == 0x40) {
+		_characters[charNum].flags |= 0x40;
+		setCharacterUpdateEvent(charNum, 3, 3600, 1);
+		r = 1;
+
+	// check for bezel ring
+	} else if (typeFlag == 0x80 && !itemEquipped(charNum, 225)) {
+		_characters[charNum].flags |= 0x80;
+		setCharacterUpdateEvent(charNum, 4, 10, 1);
+		if (characterSays(0x4021, _characters[charNum].id, true))
+			_txt->printMessage(6, getLangString(0x4021), _characters[charNum].name);
+		r = 1;
+
+	} else if (typeFlag == 0x1000) {
+		_characters[charNum].flags |= 0x1000;
+		setCharacterUpdateEvent(charNum, 7, 120, 1);
+		r = 1;
+	}
+
+	if (r && redraw)
+		gui_drawCharPortraitWithStats(charNum);
+
+	return r;
+}
+
+void LoLEngine::paralyzePoisonAllCharacters(int typeFlag, int immunityFlags, int hitChance) {
+	bool r = false;
+	for (int i = 0; i < 4; i++) {
+		if (paralyzePoisonCharacter(i, typeFlag, immunityFlags, hitChance, 0))
+			r = true;
+	}
+	if (r)
+		gui_drawAllCharPortraitsWithStats();
+}
+
+void LoLEngine::stunCharacter(int charNum) {
+	if (!(_characters[charNum].flags & 1) || (_characters[charNum].flags & 0x108))
+		return;
+
+	_characters[charNum].flags |= 0x100;
+
+	setCharacterUpdateEvent(charNum, 5, 20, 1);
+	gui_drawCharPortraitWithStats(charNum);
+
+	_txt->printMessage(6, getLangString(0x4026), _characters[charNum].name);
+}
+
+void LoLEngine::restoreSwampPalette() {
+	_flagsTable[52] &= 0xFB;
+	if (_currentLevel != 11)
+		return;
+
+	uint8 *s = _screen->getPalette(2).getData();
+	uint8 *d = _screen->getPalette(0).getData();
+	uint8 *d2 = _screen->getPalette(1).getData();
+
+	for (int i = 1; i < (_screen->getPalette(0).getNumColors() * 3); i++)
+		SWAP(s[i], d[i]);
+
+	generateBrightnessPalette(_screen->getPalette(0), _screen->getPalette(1), _brightness, _lampEffect);
+	_screen->loadSpecialColors(_screen->getPalette(2));
+	_screen->loadSpecialColors(_screen->getPalette(1));
+
+	playSpellAnimation(0, 0, 0, 2, 0, 0, 0, s, d2, 40, 0);
+}
+
+void LoLEngine::launchMagicViper() {
+	_partyAwake = true;
+
+	int d = 0;
+	for (uint16 b = _currentBlock; d < 3; d++) {
+		uint16 o = _levelBlockProperties[b].assignedObjects;
+		if (o & 0x8000)
+			break;
+		b = calcNewBlockPosition(b, _currentDirection);
+		if (_wllWallFlags[_levelBlockProperties[b].walls[_currentDirection ^ 2]] & 7)
+			break;
+	}
+
+	_screen->copyPage(0, 12);
+	snd_playSoundEffect(148, -1);
+
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+	int numFrames = mov->open("viper.wsa", 1, 0);
+	if (!mov->opened())
+		error("Viper: Unable to load viper.wsa");
+
+	static const uint8 viperAnimData[] = { 15, 25, 20, 10, 25, 20, 5, 25, 20, 0, 25, 20 };
+	const uint8 *v = &viperAnimData[d * 3];
+	int frm = v[0];
+
+	for (bool running = true; running;) {
+		uint32 etime = _system->getMillis() + 5 * _tickLength;
+		_screen->copyPage(12, 2);
+
+		if (frm == v[2])
+			snd_playSoundEffect(172, -1);
+
+		mov->displayFrame(frm++ % numFrames, 2, 112, 0, 0x5000, _transparencyTable1, _transparencyTable2);
+		_screen->copyRegion(112, 0, 112, 0, 176, 120, 2, 0, Screen::CR_NO_P_CHECK);
+		_screen->updateScreen();
+		delayUntil(etime);
+
+		if (frm > v[1])
+			running = false;
+	}
+
+	mov->close();
+	delete mov;
+
+	_screen->copyPage(12, 0);
+	_screen->copyPage(12, 2);
+
+	int t = rollDice(1, 4);
+
+	for (int i = 0; i < 4; i++) {
+		if (!(_characters[i].flags & 1)) {
+			t = t % 4;
+			continue;
+		}
+		inflictDamage(t, _currentLevel + 10, 0x8000, 2, 0x86);
+	}
+}
+
+void LoLEngine::breakIceWall(uint8 *pal1, uint8 *pal2) {
+	_screen->hideMouse();
+	uint16 bl = calcNewBlockPosition(_currentBlock, _currentDirection);
+	_levelBlockProperties[bl].flags &= 0xEF;
+	_screen->copyPage(0, 2);
+	gui_drawScene(2);
+	_screen->copyPage(2, 10);
+
+	WSAMovie_v2 *mov = new WSAMovie_v2(this);
+	int numFrames = mov->open("shatter.wsa", 1, 0);
+	if (!mov->opened())
+		error("Shatter: Unable to load shatter.wsa");
+	snd_playSoundEffect(166, -1);
+	playSpellAnimation(mov, 0, numFrames, 1, 58, 0, 0, pal1, pal2, 20, true);
+	mov->close();
+	delete mov;
+
+	_screen->copyPage(10, 0);
+	updateDrawPage2();
+	gui_drawScene(0);
+	_screen->showMouse();
+}
+
+uint16 LoLEngine::getNearestMonsterFromCharacter(int charNum) {
+	return getNearestMonsterFromCharacterForBlock(calcNewBlockPosition(_currentBlock, _currentDirection), charNum);
+}
+
+uint16 LoLEngine::getNearestMonsterFromCharacterForBlock(uint16 block, int charNum) {
+	uint16 cX = 0;
+	uint16 cY = 0;
+
+	uint16 id = 0xFFFF;
+	int minDist = 0x7FFF;
+
+	if (block == 0xFFFF)
+		return id;
+
+	calcCoordinatesForSingleCharacter(charNum, cX, cY);
+
+	int o = _levelBlockProperties[block].assignedObjects;
+
+	while (o & 0x8000) {
+		LoLMonster *m = &_monsters[o & 0x7FFF];
+		if (m->mode >= 13) {
+			o = m->nextAssignedObject;
+			continue;
+		}
+
+		int d = ABS(cX - m->x) + ABS(cY - m->y);
+		if (d < minDist) {
+			minDist = d;
+			id = o;
+		}
+
+		o = m->nextAssignedObject;
+	}
+
+	return id;
+}
+
+uint16 LoLEngine::getNearestMonsterFromPos(int x, int y) {
+	uint16 id = 0xFFFF;
+	int minDist = 0x7FFF;
+
+	for (int i = 0; i < 30; i++) {
+		if (_monsters[i].mode > 13)
+			continue;
+
+		int d = ABS(x - _monsters[i].x) + ABS(y - _monsters[i].y);
+		if (d < minDist) {
+			minDist = d;
+			id = 0x8000 | i;
+		}
+	}
+
+	return id;
+}
+
+uint16 LoLEngine::getNearestPartyMemberFromPos(int x, int y) {
+	uint16 id = 0xFFFF;
+	int minDist = 0x7FFF;
+
+	for (int i = 0; i < 4; i++) {
+		if (!(_characters[i].flags & 1) || _characters[i].hitPointsCur <= 0)
+			continue;
+
+		uint16 charX = 0;
+		uint16 charY = 0;
+		calcCoordinatesForSingleCharacter(i, charX, charY);
+
+		int d = ABS(x - charX) + ABS(y - charY);
+		if (d < minDist) {
+			minDist = d;
+			id = i;
+		}
+	}
+
+	return id;
+}
+
+// magic atlas
+
+void LoLEngine::displayAutomap() {
+	snd_playSoundEffect(105, -1);
+	gui_toggleButtonDisplayMode(_flags.isTalkie ? 78 : 76, 1);
+
+	_currentMapLevel = _currentLevel;
+	uint8 *tmpWll = new uint8[80];
+	memcpy(tmpWll, _wllAutomapData, 80);
+
+	_screen->loadBitmap("parch.cps", 2, 2, &_screen->getPalette(3));
+	_screen->loadBitmap("autobut.shp", 3, 5, 0);
+	const uint8 *shp = _screen->getCPagePtr(5);
+
+	for (int i = 0; i < 109; i++)
+		_automapShapes[i] = _screen->getPtrToShape(shp, i + 11);
+
+	if (_flags.use16ColorMode) {
+		static const uint8 ovlSrc[] = { 0x00, 0xEE, 0xCC, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0x22, 0x11, 0xDD, 0xEE, 0xCC };
+		memset(_mapOverlay, 0, 256);
+		for (int i = 0; i < 16; i++)
+			_mapOverlay[(i << 4) | i] = ovlSrc[i];
+	} else
+		_screen->generateGrayOverlay(_screen->getPalette(3), _mapOverlay, 52, 0, 0, 0, 256, false);
+
+	_screen->loadFont(Screen::FID_9_FNT, "FONT9PN.FNT");
+	_screen->loadFont(Screen::FID_6_FNT, "FONT6PN.FNT");
+
+	for (int i = 0; i < 11; i++)
+		_defaultLegendData[i].enable = false;
+
+	disableSysTimer(2);
+	generateTempData();
+	resetItems(1);
+	disableMonsters();
+
+	bool exitAutomap = false;
+	_mapUpdateNeeded = false;
+
+	restoreBlockTempData(_currentMapLevel);
+	loadMapLegendData(_currentMapLevel);
+	_screen->fadeToBlack(10);
+	drawMapPage(2);
+
+	_screen->copyPage(2, 0);
+	_screen->updateScreen();
+	_screen->fadePalette(_screen->getPalette(3), 10);
+	uint32 delayTimer = _system->getMillis() + 8 * _tickLength;
+
+	while (!exitAutomap && !shouldQuit()) {
+		if (_mapUpdateNeeded) {
+			drawMapPage(2);
+			_screen->copyPage(2, 0);
+			_screen->updateScreen();
+			_mapUpdateNeeded = false;
+		}
+
+		if (_system->getMillis() >= delayTimer) {
+			redrawMapCursor();
+			delayTimer = _system->getMillis() + 8 * _tickLength;
+		}
+
+		int f = checkInput(0) & 0xFF;
+		removeInputTop();
+
+		if (f) {
+			exitAutomap = automapProcessButtons(f);
+			gui_notifyButtonListChanged();
+		}
+
+		if (f == _keyMap[Common::KEYCODE_c]) {
+			for (int i = 0; i < 1024; i++)
+				_levelBlockProperties[i].flags |= 7;
+			_mapUpdateNeeded = true;
+		} else if (f == _keyMap[Common::KEYCODE_ESCAPE]) {
+			exitAutomap = true;
+		}
+
+		delay(_tickLength);
+	}
+
+	_screen->loadFont(Screen::FID_9_FNT, "FONT9P.FNT");
+	_screen->loadFont(Screen::FID_6_FNT, "FONT6P.FNT");
+
+	if (_flags.use16ColorMode)
+		_screen->clearPage(2);
+
+	_screen->fadeToBlack(10);
+	loadLevelWallData(_currentLevel, false);
+	memcpy(_wllAutomapData, tmpWll, 80);
+	delete[] tmpWll;
+	restoreBlockTempData(_currentLevel);
+	addLevelItems();
+	gui_notifyButtonListChanged();
+	enableSysTimer(2);
+}
+
+void LoLEngine::updateAutoMap(uint16 block) {
+	if (!(_flagsTable[31] & 0x10))
+		return;
+	_levelBlockProperties[block].flags |= 7;
+
+	uint16 x = block & 0x1F;
+	uint16 y = block >> 5;
+
+	updateAutoMapIntern(block, x, y, -1, -1);
+	updateAutoMapIntern(block, x, y, 1, -1);
+	updateAutoMapIntern(block, x, y, -1, 1);
+	updateAutoMapIntern(block, x, y, 1, 1);
+	updateAutoMapIntern(block, x, y, 0, -1);
+	updateAutoMapIntern(block, x, y, 0, 1);
+	updateAutoMapIntern(block, x, y, -1, 0);
+	updateAutoMapIntern(block, x, y, 1, 0);
+}
+
+bool LoLEngine::updateAutoMapIntern(uint16 block, uint16 x, uint16 y, int16 xOffs, int16 yOffs) {
+	static const int16 blockPosTable[] = { 1, -1, 3, 2, -1, 0, -1, 0, 1, -32, 0, 32 };
+	x += xOffs;
+	y += yOffs;
+
+	if ((x & 0xFFE0) || (y & 0xFFE0))
+		return false;
+
+	xOffs++;
+	yOffs++;
+
+	int16 fx = blockPosTable[xOffs];
+	uint16 b = block + blockPosTable[6 + xOffs];
+
+	if (fx != -1) {
+		if (_wllAutomapData[_levelBlockProperties[b].walls[fx]] & 0xC0)
+			return false;
+	}
+
+	int16 fy = blockPosTable[3 + yOffs];
+	b = block + blockPosTable[9 + yOffs];
+
+	if (fy != -1) {
+		if (_wllAutomapData[_levelBlockProperties[b].walls[fy]] & 0xC0)
+			return false;
+	}
+
+	b = block + blockPosTable[6 + xOffs] + blockPosTable[9 + yOffs];
+
+	if ((fx != -1) && (fy != -1) && (_wllAutomapData[_levelBlockProperties[b].walls[fx]] & 0xC0) && (_wllAutomapData[_levelBlockProperties[b].walls[fy]] & 0xC0))
+		return false;
+
+	_levelBlockProperties[b].flags |= 7;
+
+	return true;
+}
+
+void LoLEngine::loadMapLegendData(int level) {
+	uint16 *legendData = (uint16 *)_tempBuffer5120;
+	for (int i = 0; i < 32; i++) {
+		legendData[i * 6] = 0xFFFF;
+		legendData[i * 6 + 5] = 0xFFFF;
+	}
+
+	Common::String file = Common::String::format("level%d.xxx", level);
+	uint32 size = 0;
+	uint8 *data = _res->fileData(file.c_str(), &size);
+	uint8 *pos = data;
+	size = MIN<uint32>(size / 12, 32);
+
+	for (uint32 i = 0; i < size; i++) {
+		uint16 *l = &legendData[i * 6];
+		l[3] = READ_LE_UINT16(pos);
+		pos += 2;
+		l[4] = READ_LE_UINT16(pos);
+		pos += 2;
+		l[5] = READ_LE_UINT16(pos);
+		pos += 2;
+		l[0] = READ_LE_UINT16(pos);
+		pos += 2;
+		l[1] = READ_LE_UINT16(pos);
+		pos += 2;
+		l[2] = READ_LE_UINT16(pos);
+		pos += 2;
+	}
+
+	delete[] data;
+}
+
+void LoLEngine::drawMapPage(int pageNum) {
+	// WORKAROUND for French version. The text does not always properly fit the screen there.
+	const int8 xOffset = (_lang == 1) ? -2 : 0;
+
+	if (_flags.use16ColorMode)
+		_screen->clearPage(pageNum);
+
+	for (int i = 0; i < 2; i++) {
+		_screen->loadBitmap("parch.cps", pageNum, pageNum, &_screen->getPalette(3));
+		if (_lang == 1)
+			_screen->copyRegion(236, 16, 236 + xOffset, 16, -xOffset, 1, pageNum, pageNum, Screen::CR_NO_P_CHECK);
+
+		int cp = _screen->setCurPage(pageNum);
+		Screen::FontId of = _screen->setFont((_flags.lang == Common::JA_JPN && _flags.use16ColorMode) ? Screen::FID_SJIS_FNT : Screen::FID_9_FNT);
+		_screen->printText(getLangString(_autoMapStrings[_currentMapLevel]), 236 + xOffset, 8, 1, 0);
+		uint16 blX = mapGetStartPosX();
+		uint16 bl = (mapGetStartPosY() << 5) + blX;
+
+		int sx = _automapTopLeftX;
+		int sy = _automapTopLeftY;
+
+		for (; bl < 1024; bl++) {
+			uint8 *w = _levelBlockProperties[bl].walls;
+			if ((_levelBlockProperties[bl].flags & 7) == 7 && (!(_wllAutomapData[w[0]] & 0xC0)) && (!(_wllAutomapData[w[2]] & 0xC0)) && (!(_wllAutomapData[w[1]] & 0xC0)) && (!(_wllAutomapData[w[3]] & 0xC0))) {
+				uint16 b0 = calcNewBlockPosition(bl, 0);
+				uint16 b2 = calcNewBlockPosition(bl, 2);
+				uint16 b1 = calcNewBlockPosition(bl, 1);
+				uint16 b3 = calcNewBlockPosition(bl, 3);
+
+				uint8 w02 = _levelBlockProperties[b0].walls[2];
+				uint8 w20 = _levelBlockProperties[b2].walls[0];
+				uint8 w13 = _levelBlockProperties[b1].walls[3];
+				uint8 w31 = _levelBlockProperties[b3].walls[1];
+
+				// draw block
+				_screen->copyBlockAndApplyOverlay(_screen->_curPage, sx, sy, _screen->_curPage, sx, sy, 7, 6, 0, _mapOverlay);
+
+				// draw north wall
+				drawMapBlockWall(b3, w31, sx, sy, 3);
+				drawMapShape(w31, sx, sy, 3);
+				if (_wllAutomapData[w31] & 0xC0)
+					_screen->copyBlockAndApplyOverlay(_screen->_curPage, sx, sy, _screen->_curPage, sx, sy, 1, 6, 0, _mapOverlay);
+
+				// draw west wall
+				drawMapBlockWall(b1, w13, sx, sy, 1);
+				drawMapShape(w13, sx, sy, 1);
+				if (_wllAutomapData[w13] & 0xC0)
+					_screen->copyBlockAndApplyOverlay(_screen->_curPage, sx + 6, sy, _screen->_curPage, sx + 6, sy, 1, 6, 0, _mapOverlay);
+
+				// draw east wall
+				drawMapBlockWall(b0, w02, sx, sy, 0);
+				drawMapShape(w02, sx, sy, 0);
+				if (_wllAutomapData[w02] & 0xC0)
+					_screen->copyBlockAndApplyOverlay(_screen->_curPage, sx, sy, _screen->_curPage, sx, sy, 7, 1, 0, _mapOverlay);
+
+				//draw south wall
+				drawMapBlockWall(b2, w20, sx, sy, 2);
+				drawMapShape(w20, sx, sy, 2);
+				if (_wllAutomapData[w20] & 0xC0)
+					_screen->copyBlockAndApplyOverlay(_screen->_curPage, sx, sy + 5, _screen->_curPage, sx, sy + 5, 7, 1, 0, _mapOverlay);
+			}
+
+			sx += 7;
+			if (bl % 32 == 31) {
+				sx = _automapTopLeftX;
+				sy += 6;
+				bl += blX;
+			}
+		}
+
+		_screen->setFont(of);
+		_screen->setCurPage(cp);
+
+		of = _screen->setFont((_flags.lang == Common::JA_JPN && _flags.use16ColorMode) ? Screen::FID_SJIS_FNT : Screen::FID_6_FNT);
+
+		int tY = 0;
+		sx = mapGetStartPosX();
+		sy = mapGetStartPosY();
+
+		uint16 *legendData = (uint16 *)_tempBuffer5120;
+		uint8 yOffset = _flags.use16ColorMode ? 4 : 0;
+
+		for (int ii = 0; ii < 32; ii++)  {
+			uint16 *l = &legendData[ii * 6];
+			if (l[0] == 0xFFFF)
+				break;
+
+			uint16 cbl = l[0] + (l[1] << 5);
+			if ((_levelBlockProperties[cbl].flags & 7) != 7)
+				continue;
+
+			if (l[2] == 0xFFFF)
+				continue;
+
+			printMapText(l[2], 244 + xOffset, (tY << 3) + 22 + yOffset);
+
+			if (l[5] == 0xFFFF) {
+				tY++;
+				continue;
+			}
+
+			uint16 cbl2 = l[3] + (l[4] << 5);
+			_levelBlockProperties[cbl2].flags |= 7;
+			_screen->drawShape(2, _automapShapes[l[5] << 2], (l[3] - sx) * 7 + _automapTopLeftX - 3, (l[4] - sy) * 6 + _automapTopLeftY - 3, 0, 0);
+			_screen->drawShape(2, _automapShapes[l[5] << 2], 231 + xOffset, (tY << 3) + 19 + yOffset, 0, 0);
+			tY++;
+		}
+
+		cp = _screen->setCurPage(pageNum);
+
+		for (int ii = 0; ii < 11; ii++) {
+			if (!_defaultLegendData[ii].enable)
+				continue;
+			_screen->copyBlockAndApplyOverlay(_screen->_curPage, 235, (tY << 3) + 21 + yOffset, _screen->_curPage, 235 + xOffset, (tY << 3) + 21 + yOffset, 7, 6, 0, _mapOverlay);
+			_screen->drawShape(_screen->_curPage, _automapShapes[_defaultLegendData[ii].shapeIndex << 2], 232 + xOffset, (tY << 3) + 18 + yOffset + _defaultLegendData[ii].y, 0, 0);
+			printMapText(_defaultLegendData[ii].stringId, 244 + xOffset, (tY << 3) + 22 + yOffset);
+			tY++;
+		}
+
+		_screen->setFont(of);
+		_screen->setCurPage(cp);
+	}
+
+	printMapExitButtonText();
+}
+
+bool LoLEngine::automapProcessButtons(int inputFlag) {
+	int r = -1;
+	if (inputFlag == _keyMap[Common::KEYCODE_RIGHT] || inputFlag == _keyMap[Common::KEYCODE_KP6]) {
+		r = 0;
+	} else if (inputFlag == _keyMap[Common::KEYCODE_LEFT] || inputFlag == _keyMap[Common::KEYCODE_KP4]) {
+		r = 1;
+	} else if (inputFlag == 199) {
+		if (posWithinRect(_mouseX, _mouseY, 252, 175, 273, 200))
+			r = 0;
+		else if (posWithinRect(_mouseX, _mouseY, 231, 175, 252, 200))
+			r = 1;
+		else if (posWithinRect(_mouseX, _mouseY, 275, 175, 315, 197))
+			r = 2;
+
+		printMapExitButtonText();
+
+		while (inputFlag == 199 || inputFlag == 200) {
+			inputFlag = checkInput(0, false);
+			removeInputTop();
+			delay(_tickLength);
+		}
+	} else {
+		return false;
+	}
+
+	if (r == 0) {
+		automapForwardButton();
+		printMapExitButtonText();
+	} else if (r == 1) {
+		automapBackButton();
+		printMapExitButtonText();
+	} if (r == 2) {
+		return true;
+	}
+
+	return false;
+}
+
+void LoLEngine::automapForwardButton() {
+	int i = _currentMapLevel + 1;
+	while (!(_hasTempDataFlags & (1 << (i - 1))))
+		i = (i + 1) & 0x1F;
+	if (i == _currentMapLevel)
+		return;
+
+	for (int l = 0; l < 11; l++)
+		_defaultLegendData[l].enable = false;
+
+	_currentMapLevel = i;
+	loadLevelWallData(i, false);
+	restoreBlockTempData(i);
+	loadMapLegendData(i);
+	_mapUpdateNeeded = true;
+}
+
+void LoLEngine::automapBackButton() {
+	int i = _currentMapLevel - 1;
+	while (!(_hasTempDataFlags & (1 << (i - 1))))
+		i = (i - 1) & 0x1F;
+	if (i == _currentMapLevel)
+		return;
+
+	for (int l = 0; l < 11; l++)
+		_defaultLegendData[l].enable = false;
+
+	_currentMapLevel = i;
+	loadLevelWallData(i, false);
+	restoreBlockTempData(i);
+	loadMapLegendData(i);
+	_mapUpdateNeeded = true;
+}
+
+void LoLEngine::redrawMapCursor() {
+	int sx = mapGetStartPosX();
+	int sy = mapGetStartPosY();
+
+	if (_currentLevel != _currentMapLevel)
+		return;
+
+	int cx = _automapTopLeftX + (((_currentBlock - sx) % 32) * 7);
+	int cy = _automapTopLeftY + (((_currentBlock - (sy << 5)) / 32) * 6);
+
+	if (_flags.use16ColorMode) {
+		_screen->drawShape(0, _automapShapes[48 + _currentDirection], cx - 3, cy - 2, 0, 0);
+	} else {
+		_screen->fillRect(0, 0, 16, 16, 0, 2);
+		_screen->drawShape(2, _automapShapes[48 + _currentDirection], 0, 0, 0, 0);
+		_screen->copyRegion(cx, cy, cx, cy, 16, 16, 2, 0);
+		_screen->copyBlockAndApplyOverlay(2, 0, 0, 0, cx - 3, cy - 2, 16, 16, 0, _mapCursorOverlay);
+
+		_mapCursorOverlay[24] = _mapCursorOverlay[1];
+		for (int i = 1; i < 24; i++)
+			_mapCursorOverlay[i] = _mapCursorOverlay[i + 1];
+	}
+
+	_screen->updateScreen();
+}
+
+void LoLEngine::drawMapBlockWall(uint16 block, uint8 wall, int x, int y, int direction) {
+	if (((1 << direction) & _levelBlockProperties[block].flags) || ((_wllAutomapData[wall] & 0x1F) != 13))
+		return;
+
+	int cp = _screen->_curPage;
+	_screen->copyBlockAndApplyOverlay(cp, x + _mapCoords[0][direction], y + _mapCoords[1][direction], cp, x + _mapCoords[0][direction], y + _mapCoords[1][direction], _mapCoords[2][direction], _mapCoords[3][direction], 0, _mapOverlay);
+	_screen->copyBlockAndApplyOverlay(cp, x + _mapCoords[4][direction], y + _mapCoords[5][direction], cp, x + _mapCoords[4][direction], y + _mapCoords[5][direction], _mapCoords[8][direction], _mapCoords[9][direction], 0, _mapOverlay);
+	_screen->copyBlockAndApplyOverlay(cp, x + _mapCoords[6][direction], y + _mapCoords[7][direction], cp, x + _mapCoords[6][direction], y + _mapCoords[7][direction], _mapCoords[8][direction], _mapCoords[9][direction], 0, _mapOverlay);
+}
+
+void LoLEngine::drawMapShape(uint8 wall, int x, int y, int direction) {
+	int l = _wllAutomapData[wall] & 0x1F;
+	if (l == 0x1F)
+		return;
+
+	_screen->drawShape(_screen->_curPage, _automapShapes[(l << 2) + direction], x + _mapCoords[10][direction] - 2, y + _mapCoords[11][direction] - 2, 0, 0);
+	mapIncludeLegendData(l);
+}
+
+int LoLEngine::mapGetStartPosX() {
+	int c = 0;
+	int a = 32;
+
+	do {
+		for (a = 0; a < 32; a++) {
+			if (_levelBlockProperties[(a << 5) + c].flags)
+				break;
+		}
+		if (a == 32)
+			c++;
+	} while (c < 32 && a == 32);
+
+	int d = 31;
+	a = 32;
+
+	do {
+		for (a = 0; a < 32; a++) {
+			if (_levelBlockProperties[(a << 5) + d].flags)
+				break;
+		}
+		if (a == 32)
+			d--;
+	} while (d > 0 && a == 32);
+
+	_automapTopLeftX = (d > c) ? ((32 - (d - c)) >> 1) * 7 + 5 : 5;
+	return (d > c) ? c : 0;
+}
+
+int LoLEngine::mapGetStartPosY() {
+	int c = 0;
+	int a = 32;
+
+	do {
+		for (a = 0; a < 32; a++) {
+			if (_levelBlockProperties[(c << 5) + a].flags)
+				break;
+		}
+		if (a == 32)
+			c++;
+	} while (c < 32 && a == 32);
+
+	int d = 31;
+	a = 32;
+
+	do {
+		for (a = 0; a < 32; a++) {
+			if (_levelBlockProperties[(d << 5) + a].flags)
+				break;
+		}
+		if (a == 32)
+			d--;
+	} while (d > 0 && a == 32);
+
+	_automapTopLeftY = (d > c) ? ((32 - (d - c)) >> 1) * 6 + 4 : 4;
+	return (d > c) ? c : 0;
+}
+
+void LoLEngine::mapIncludeLegendData(int type) {
+	type &= 0x7F;
+	for (int i = 0; i < 11; i++) {
+		if (_defaultLegendData[i].shapeIndex != type)
+			continue;
+		_defaultLegendData[i].enable = true;
+		return;
+	}
+}
+
+void LoLEngine::printMapText(uint16 stringId, int x, int y) {
+	int cp = _screen->setCurPage(2);
+	if (_flags.use16ColorMode)
+		_screen->printText(getLangString(stringId), x & ~3, y & ~7, 1, 0);
+	else
+		_screen->printText(getLangString(stringId), x, y, 239, 0);
+	_screen->setCurPage(cp);
+}
+
+void LoLEngine::printMapExitButtonText() {
+	int cp = _screen->setCurPage(2);
+	Screen::FontId of = _screen->setFont(Screen::FID_9_FNT);
+	_screen->fprintString("%s", 295, 182, _flags.use16ColorMode ? 0xBB : 172, 0, 5, getLangString(0x4033));
+	_screen->setFont(of);
+	_screen->setCurPage(cp);
+}
+
+
+
+} // End of namespace Kyra
+
+#endif // ENABLE_LOL