/* 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_EOB

#include "engines/kyra/eobcommon.h"
#include "engines/kyra/screen_eob.h"
#include "engines/kyra/script_eob.h"
#include "engines/kyra/resource.h"
#include "engines/kyra/sound.h"

#include "common/system.h"

namespace Kyra {

void EoBCoreEngine::runLevelScript(int block, int flags) {
	_inf->run(block, flags);
}

void EoBCoreEngine::setScriptFlags(uint32 flags) {
	_inf->setFlags(flags);
}

void EoBCoreEngine::clearScriptFlags(uint32 flags) {
	_inf->clearFlags(flags);
}

bool EoBCoreEngine::checkScriptFlags(uint32 flags) {
	return _inf->checkFlags(flags);
}

const uint8 *EoBCoreEngine::initScriptTimers(const uint8 *pos) {
	_scriptTimersCount = 0;

	while (((int16)READ_LE_UINT16(pos)) != -1) {
		_scriptTimers[_scriptTimersCount].func = READ_LE_UINT16(pos);
		pos += 2;
		uint16 ticks = READ_LE_UINT16(pos) * 18;
		_scriptTimers[_scriptTimersCount].ticks = ticks;
		pos += 2;
		_scriptTimers[_scriptTimersCount++].next = _system->getMillis() + ticks * _tickLength;
	}

	return pos;
}

void EoBCoreEngine::updateScriptTimers() {
	bool timerUpdate = false;
	if ((_scriptTimersMode & 2) && _stepsUntilScriptCall && _stepCounter > _stepsUntilScriptCall) {
		_inf->run(0, 0x20);
		_stepCounter = 0;
		timerUpdate = true;
	}

	if (_scriptTimersMode & 1) {
		for (int i = 0; i < _scriptTimersCount; i++) {
			if (_scriptTimers[i].next < _system->getMillis()) {
				_inf->run(_scriptTimers[i].func, _flags.gameID == GI_EOB1 ? 0x20 : 0x80);
				_scriptTimers[i].next = _system->getMillis() + _scriptTimers[i].ticks * _tickLength;
				_sceneUpdateRequired = true;
				timerUpdate = true;
			}
		}
	}

	if (timerUpdate)
		updateScriptTimersExtra();
}

EoBInfProcessor::EoBInfProcessor(EoBCoreEngine *engine, Screen_EoB *screen) : _vm(engine), _screen(screen),
	_commandMin(engine->game() == GI_EOB1 ? -27 : -31) {

#define Opcode(x) _opcodes.push_back(new InfOpcode(new InfProc(this, &EoBInfProcessor::x), #x))
#define OpcodeAlt(x) if (_vm->game() == GI_EOB1) { Opcode(x##_v1); } else { Opcode(x##_v2); }
	Opcode(oeob_setWallType);
	Opcode(oeob_toggleWallState);
	Opcode(oeob_openDoor);
	Opcode(oeob_closeDoor);
	Opcode(oeob_replaceMonster);
	Opcode(oeob_movePartyOrObject);
	Opcode(oeob_moveInventoryItemToBlock);
	OpcodeAlt(oeob_printMessage);
	Opcode(oeob_setFlags);
	Opcode(oeob_playSoundEffect);
	Opcode(oeob_removeFlags);
	Opcode(oeob_modifyCharacterHitPoints);
	Opcode(oeob_calcAndInflictCharacterDamage);
	Opcode(oeob_jump);
	Opcode(oeob_end);
	Opcode(oeob_returnFromSubroutine);
	Opcode(oeob_callSubroutine);
	OpcodeAlt(oeob_eval);
	Opcode(oeob_deleteItem);
	Opcode(oeob_loadNewLevelOrMonsters);
	Opcode(oeob_increasePartyExperience);
	OpcodeAlt(oeob_createItem);
	Opcode(oeob_launchObject);
	Opcode(oeob_changeDirection);
	Opcode(oeob_identifyItems);
	Opcode(oeob_sequence);
	Opcode(oeob_delay);
	Opcode(oeob_drawScene);
	Opcode(oeob_dialogue);
	Opcode(oeob_specialEvent);
#undef Opcode
#undef OpcodeAlt

	_scriptData = 0;
	_scriptSize = 0;

	_abortScript = 0;
	_abortAfterSubroutine = 0;
	_dlgResult = 0;
	_preventRest = 0;

	_lastScriptFunc = 0;
	_lastScriptFlags = 0;

	_subroutineStack = new int8*[10];
	memset(_subroutineStack, 0, 10 * sizeof(int8 *));
	_subroutineStackPos = 0;

	_flagTable = new uint32[18];
	memset(_flagTable, 0, 18 * sizeof(uint32));

	_stack = new int16[30];
	memset(_stack, 0, 30 * sizeof(int16));
	_stackIndex = 0;

	_activeCharacter = -1;
}

EoBInfProcessor::~EoBInfProcessor() {
	delete[] _subroutineStack;
	delete[] _flagTable;
	delete[] _stack;
	delete[] _scriptData;

	for (Common::Array<const InfOpcode *>::const_iterator a = _opcodes.begin(); a != _opcodes.end(); ++a)
		delete *a;

	_opcodes.clear();
}

void EoBInfProcessor::loadData(const uint8 *data, uint32 dataSize) {
	delete[] _scriptData;
	_scriptSize = dataSize;
	_scriptData = new int8[_scriptSize];
	memcpy(_scriptData, data, _scriptSize);
}

void EoBInfProcessor::run(int func, int flags) {
	int o = _vm->_levelBlockProperties[func].assignedObjects;
	if (!o)
		return;

	uint16 f = _vm->_levelBlockProperties[func].flags;

	uint16 subFlags = ((f & 0xFFF8) >> 3) | 0xE0;
	if (!(flags & subFlags))
		return;

	_abortScript = 0;
	_abortAfterSubroutine = 0;
	_dlgResult = 0;
	_activeCharacter = -1;

	_lastScriptFunc = func;
	_lastScriptFlags = flags;

	int8 *pos = (int8 *)(_scriptData + o);

	do {
		int8 cmd = *pos++;
		if (cmd <= _commandMin || cmd >= 0)
			continue;
		debugC(3, kDebugLevelScript, "[0x%.04X] EoBInfProcessor::%s()", (uint32)(pos - _scriptData), _opcodes[-(cmd + 1)]->desc.c_str());
		pos += (*_opcodes[-(cmd + 1)]->proc)(pos);
	} while (!_abortScript && !_abortAfterSubroutine);
}

void EoBInfProcessor::setFlags(uint32 flags) {
	_flagTable[17] |= flags;
}

void EoBInfProcessor::clearFlags(uint32 flags) {
	_flagTable[17] &= ~flags;
}

bool EoBInfProcessor::checkFlags(uint32 flags) const {
	return ((_flagTable[17] & flags) == flags) ? true : false;
}

bool EoBInfProcessor::preventRest() const {
	return _preventRest ? true : false;
}

void EoBInfProcessor::loadState(Common::SeekableSubReadStreamEndian &in, bool origFile) {
	_preventRest = (_vm->game() == GI_EOB1 && origFile) ? 0 : in.readByte();
	int numFlags = (_vm->game() == GI_EOB1 && origFile) ? 12 : 18;
	for (int i = 0; i < numFlags; i++)
		_flagTable[i] = in.readUint32();
	if (_vm->game() == GI_EOB1 && origFile)
		setFlags(in.readUint32());
}

void EoBInfProcessor::saveState(Common::OutSaveFile *out, bool origFile) {
	if (_vm->game() == GI_EOB2 || !origFile)
		out->writeByte(_preventRest);
	int numFlags = (_vm->game() == GI_EOB1 && origFile) ? 12 : 18;
	for (int i = 0; i < numFlags; i++) {
		if (origFile)
			out->writeUint32LE(_flagTable[i]);
		else
			out->writeUint32BE(_flagTable[i]);
	}
	if (_vm->game() == GI_EOB1 && origFile)
		out->writeUint32LE(_flagTable[17]);
}

void EoBInfProcessor::reset() {
	_preventRest = 0;
	memset(_flagTable, 0, 18 * sizeof(uint32));
}

const char *EoBInfProcessor::getString(uint16 index) {
	if (index == 0xFFFF)
		return 0;

	int8 *res = _scriptData + READ_LE_UINT16(_scriptData);

	while (index) {
		if (*res++)
			continue;
		index--;
	}

	return (const char *)res;
}

int EoBInfProcessor::oeob_setWallType(int8 *data) {
	int8 *pos = data;

	uint16 block = 0;
	int8 dir = 0;

	switch (*pos++) {
	case -23:
		block = READ_LE_UINT16(pos);
		pos += 2;
		dir = *pos++;
		_vm->_levelBlockProperties[block].walls[dir] = *pos++;
		_vm->checkSceneUpdateNeed(block);
		break;

	case -19:
		_vm->_currentDirection = *pos++;
		break;

	case -9:
		block = READ_LE_UINT16(pos);
		pos += 2;
		dir = *pos++;
		memset(_vm->_levelBlockProperties[block].walls, dir, 4 * sizeof(uint8));
		_vm->checkSceneUpdateNeed(block);
		break;

	default:
		break;
	}

	return pos - data;
}

int EoBInfProcessor::oeob_toggleWallState(int8 *data) {
	int8 *pos = data;

	uint16 block = 0;
	int8 dir = 0;
	uint8 a = 0;
	uint8 b = 0;

	switch (*pos++) {
	case -23:
		block = READ_LE_UINT16(pos);
		pos += 2;
		dir = *pos++;
		a = (uint8)*pos++;
		b = (uint8)*pos++;
		a = (_vm->_levelBlockProperties[block].walls[dir] == a) ? b : a;
		_vm->_levelBlockProperties[block].walls[dir] = a;
		_vm->checkSceneUpdateNeed(block);
		break;

	case -22:
		_vm->processDoorSwitch(READ_LE_UINT16(pos), 0);
		pos += 2;
		break;

	case -9:
		block = READ_LE_UINT16(pos);
		pos += 2;
		a = (uint8)*pos++;
		b = (uint8)*pos++;
		a = (_vm->_levelBlockProperties[block].walls[dir] == a) ? b : a;
		memset(_vm->_levelBlockProperties[block].walls, a, 4 * sizeof(uint8));
		_vm->checkSceneUpdateNeed(block);
		break;

	default:
		break;
	}

	return pos - data;
}

int EoBInfProcessor::oeob_openDoor(int8 *data) {
	int8 *pos = data;
	_vm->openDoor(READ_LE_UINT16(pos));
	pos += 2;
	return pos - data;
}

int EoBInfProcessor::oeob_closeDoor(int8 *data) {
	int8 *pos = data;
	_vm->closeDoor(READ_LE_UINT16(pos));
	pos += 2;
	return pos - data;
}

int EoBInfProcessor::oeob_replaceMonster(int8 *data) {
	int8 *pos = data;
	_vm->replaceMonster(pos[1], READ_LE_UINT16(pos + 2), pos[4], pos[5], pos[6], pos[7], pos[8], pos[9], READ_LE_UINT16(pos + 10), READ_LE_UINT16(pos + 12));
	pos += 14;
	return pos - data;
}

int EoBInfProcessor::oeob_movePartyOrObject(int8 *data) {
	int8 *pos = data;

	int8 a = *pos++;
	uint16 b = 0xFFFF;
	uint16 c = 0;
	uint16 d = 0;

	if (_vm->game() == GI_EOB2 && a == -31) {
		b = READ_LE_UINT16(pos);
		pos += 2;
	}

	if (_vm->game() == GI_EOB1) {
		if (a != -15) {
			c = READ_LE_UINT16(pos);
			pos += 2;
		}
		d = READ_LE_UINT16(pos);
		pos += 2;
	}

	if (_vm->game() == GI_EOB2 && a != -31 && a != -11) {
		c = READ_LE_UINT16(pos);
		pos += 2;
		d = READ_LE_UINT16(pos);
		pos += 2;
	}

	if (a == -13) {
		// move monster from block c to block d
		for (int i = 0; i < 30; i++) {
			if (_vm->_monsters[i].block != c)
				continue;
			_vm->placeMonster(&_vm->_monsters[i], d, _vm->_monsters[i].pos);
		}
		debugC(5, kDebugLevelScript, "         - move monsters on block '0x%.04X' to block '0x%.04X'", c, d);

	} else if (a == -24) {
		// move party to block d
		int ba = _dlgResult;
		int bb = _lastScriptFunc;
		int bc = _lastScriptFlags;
		int bd = _abortScript;
		int be = _activeCharacter;
		int bf = _subroutineStackPos;

		_vm->moveParty(d);
		debugC(5, kDebugLevelScript, "         - move party to block '0x%.04X'", d);

		_dlgResult = ba;
		_lastScriptFunc = bb;
		_lastScriptFlags = bc;
		_abortScript = bd;
		_activeCharacter = be;
		if (!_abortAfterSubroutine)
			_subroutineStackPos = bf;
		_vm->_sceneDefaultUpdate = 0;

	} else if ((a == -31 && _vm->game() == GI_EOB2) || a == -11) {
		// move item
		int8 e = _vm->_currentLevel;
		int8 f = _vm->_currentLevel;

		if (_vm->game() == GI_EOB2) {
			e = (*pos++ == -21) ? _vm->_currentLevel : *pos++;
			c = READ_LE_UINT16(pos);
			pos += 2;
			f = (*pos++ == -21) ? _vm->_currentLevel : *pos++;
			d = READ_LE_UINT16(pos);
			pos += 2;
		}

		if (e == _vm->_currentLevel) {
			int i = _vm->countQueuedItems(_vm->_levelBlockProperties[c].drawObjects, -1, (int16)b, 0, 1);
			while (i) {
				int p = _vm->_items[i].pos;
				_vm->getQueuedItem((Item *)&_vm->_levelBlockProperties[c].drawObjects, 0, i);
				if (_vm->_currentLevel == f) {
					_vm->setItemPosition((Item *)&_vm->_levelBlockProperties[d].drawObjects, d, i, p);
				} else {
					_vm->_items[i].level = f;
					_vm->_items[i].block = d;
					if (p < 8)
						_vm->_items[i].pos = p & 3;
				}
				i = _vm->countQueuedItems(_vm->_levelBlockProperties[c].drawObjects, -1, (int16)b, 0, 1);
			}

			for (i = 0; i < 10; i++) {
				if (_vm->_flyingObjects[i].enable != 1 || _vm->_flyingObjects[i].curBlock != c)
					continue;
				if (f == _vm->_currentLevel || _vm->game() == GI_EOB1)
					_vm->_flyingObjects[i].curBlock = d;
				else
					_vm->_flyingObjects[i].enable = 0;
			}

		} else {
			for (int i = 0; i < 600; i++) {
				if (_vm->_items[i].level != e || _vm->_items[i].block != c)
					continue;
				_vm->_items[i].level = f;
				_vm->_items[i].block = d;
			}
		}
		debugC(5, kDebugLevelScript, "         - move items from level '%d', block '0x%.04X' to level '%d', block '0x%.04X'", c, e, d, f);
	}

	_vm->_sceneUpdateRequired = true;
	return pos - data;
}

int EoBInfProcessor::oeob_moveInventoryItemToBlock(int8 *data) {
	int8 *pos = data;
	int8 c = *pos++;
	uint16 block = READ_LE_UINT16(pos);
	pos += 2;
	int8 p = *pos++;

	if (c == -1)
		c = _vm->rollDice(1, 6, -1);

	while (!(_vm->_characters[c].flags & 1)) {
		if (++c == 5)
			c = 0;
	}

	if (_vm->_currentControlMode && (_vm->_updateCharNum == c))
		return pos - data;

	int slot = _vm->rollDice(1, 27, 0);
	int itm = 0;
	int i = 0;

	for (; i < 27; i++) {
		if ((!_vm->_currentControlMode && slot > 1) || slot == 16)
			continue;

		itm = _vm->_characters[c].inventory[slot];

		if (!itm)
			continue;

		if (_vm->_dscItemShapeMap[_vm->_items[itm].icon] >= 15)
			break;

		if (++slot == 27)
			slot = 0;
	}

	if (i < 27 && itm) {
		_vm->_characters[c].inventory[slot] = 0;
		_vm->setItemPosition((Item *)&_vm->_levelBlockProperties[block].drawObjects, block, itm, p);
	}

	return pos - data;
}

int EoBInfProcessor::oeob_printMessage_v1(int8 *data) {
	static const char colorConfig[] = "\x6\x21\x2\x21";
	char col[5];
	int8 *pos = data;

	strcpy(col, colorConfig);
	const char *str = (const char *)pos;
	pos += (strlen(str) + 1);

	col[1] = *pos++;
	col[3] = *pos++;
	_vm->txt()->printMessage(col);
	_vm->txt()->printMessage(str);

	col[1] = _screen->_curDim->unk8;
	col[3] = _screen->_curDim->unkA;
	_vm->txt()->printMessage(col);
	_vm->txt()->printMessage("\r");

	return pos - data;
}

int EoBInfProcessor::oeob_printMessage_v2(int8 *data) {
	int8 *pos = data;
	uint16 str = READ_LE_UINT16(pos);
	pos += 2;
	uint8 col = (uint8)*pos;
	pos += 2;

	int c = 0;
	if (_activeCharacter == -1) {
		c = _vm->rollDice(1, 6, -1);
		while (!_vm->testCharacter(c, 3))
			c = (c + 1) % 6;
	} else {
		c = _activeCharacter;
	}

	_vm->txt()->printMessage(getString(str), col, _vm->_characters[c].name);
	_vm->txt()->printMessage("\r");

	return pos - data;
}

int EoBInfProcessor::oeob_setFlags(int8 *data) {
	int8 *pos = data;
	int8 b = 0;

	switch (*pos++) {
	case -47:
		_preventRest = 0;
		debugC(5, kDebugLevelScript, "         - set preventRest to 0");
		break;

	case -28:
		_dlgResult = 1;
		debugC(5, kDebugLevelScript, "         - set dlgResult to 1");
		break;

	case -17:
		_flagTable[_vm->_currentLevel] |= (1 << (*pos++));
		debugC(5, kDebugLevelScript, "         - set level flag '%d' for current level (current level = '%d')", *(pos - 1), _vm->_currentLevel);
		break;

	case -16:
		_flagTable[17] |= (1 << (*pos++));
		debugC(5, kDebugLevelScript, "         - set global flag '%d'", *(pos - 1));
		break;

	case -13:
		b = *pos++;
		_vm->_monsters[b].flags |= (1 << (*pos++));
		_vm->_monsters[b].mode = 0;
		debugC(5, kDebugLevelScript, "         - set monster flag '%d' for monster '%d'", *(pos - 1), b);
		break;

	default:
		break;
	}

	return pos - data;
}

int EoBInfProcessor::oeob_playSoundEffect(int8 *data) {
	int8 *pos = data;
	uint16 block = READ_LE_UINT16(pos + 1);

	if (block) {
		_vm->snd_processEnvironmentalSoundEffect(pos[0], block);
	} else {
		_vm->snd_playSoundEffect(pos[0]);
	}

	pos += 3;
	return pos - data;
}

int EoBInfProcessor::oeob_removeFlags(int8 *data) {
	int8 *pos = data;
	int8 a = *pos++;

	switch (a) {
	case -47:
		_preventRest = 1;
		debugC(5, kDebugLevelScript, "         - set preventRest to 1");
		break;

	case -28:
		_dlgResult = 0;
		debugC(5, kDebugLevelScript, "         - set dlgResult to 0");
		break;

	case -17:
		_flagTable[_vm->_currentLevel] &= ~(1 << (*pos++));
		debugC(5, kDebugLevelScript, "         - clear level flag '%d' for current level (current level = '%d')", *(pos - 1), _vm->_currentLevel);
		break;

	case -16:
		_flagTable[17] &= ~(1 << (*pos++));
		debugC(5, kDebugLevelScript, "         - clear global flag '%d'", *(pos - 1));
		break;

	default:
		break;
	}

	return pos - data;
}

int EoBInfProcessor::oeob_modifyCharacterHitPoints(int8 *data) {
	int8 *pos = data;
	int8 c = *pos++;
	int8 p = *pos++;

	if (c == -1) {
		for (c = 0; c < 6; c++)
			_vm->modifyCharacterHitpoints(c, p);
	} else {
		_vm->modifyCharacterHitpoints(c, p);
	}

	return pos - data;
}

int EoBInfProcessor::oeob_calcAndInflictCharacterDamage(int8 *data) {
	int8 *pos = data;
	int charIndex = *pos++;
	int times = *pos++;
	int itemOrPips = *pos++;
	int useStrModifierOrBase = *pos++;

	int flg = (charIndex == -1) ? 4 : 0;
	int savingThrowType = 5;
	int savingThrowEffect = 1;

	if (_vm->game() == GI_EOB2) {
		flg = *pos++;
		savingThrowType = *pos++;
		savingThrowEffect = *pos++;
	} else if (!itemOrPips) {
		useStrModifierOrBase = times;
		times = 0;
	}

	if (charIndex == -1) {
		for (int i = 0; i < 6; i++)
			_vm->calcAndInflictCharacterDamage(i, times, itemOrPips, useStrModifierOrBase, flg, savingThrowType, savingThrowEffect);
	} else {
		_vm->calcAndInflictCharacterDamage(charIndex, times, itemOrPips, useStrModifierOrBase, flg, savingThrowType, savingThrowEffect);
	}
	return pos - data;
}

int EoBInfProcessor::oeob_jump(int8 *data) {
	int8 *pos = data;
	pos = _scriptData + READ_LE_UINT16(pos);
	return pos - data;
}

int EoBInfProcessor::oeob_end(int8 *data) {
	_abortScript = 1;
	_subroutineStackPos = 0;
	return 0;
}

int EoBInfProcessor::oeob_returnFromSubroutine(int8 *data) {
	int8 *pos = data;

	if (_subroutineStackPos)
		pos = _subroutineStack[--_subroutineStackPos];
	else
		_abortScript = 1;

	return pos - data;
}

int EoBInfProcessor::oeob_callSubroutine(int8 *data) {
	int8 *pos = data;
	uint16 offs = READ_LE_UINT16(pos);
	assert(offs < _scriptSize);
	pos += 2;

	if (_subroutineStackPos < 10) {
		_subroutineStack[_subroutineStackPos++] = pos;
		pos = _scriptData + offs;
	}

	return pos - data;
}

int EoBInfProcessor::oeob_eval_v1(int8 *data) {
	int8 *pos = data;
	int8 cmd = *pos++;

	int a = 0;
	int b = 0;
	int i = 0;
	EoBItem *itm = &_vm->_items[_vm->_itemInHand];
	Common::String tempString1;
	Common::String tempString2;

	while (cmd != -18) {
		switch (cmd + 38) {
		case 0:
			a = 1;
			for (i = 0; i < 6; i++) {
				if (!(_vm->_characters[i].flags & 1))
					continue;
				if (_vm->_characters[i].effectFlags & 0x40)
					continue;
				a = 0;
				break;
			}
			_stack[_stackIndex++] = a;
			debugC(5, kDebugLevelScript, "         - check if whole party is invisible - PUSH result: '%d'", a);
			break;

		case 1:
			_stack[_stackIndex++] = _vm->rollDice(pos[0], pos[1], pos[2]);
			debugC(9, kDebugLevelScript, "         - throw dice(s): num = '%d', pips = '%d', offset = '%d' - PUSH result: '%d'", pos[0], pos[1], pos[2], _stack[_stackIndex - 1]);
			pos += 3;
			break;

		case 2:
			cmd = *pos++;
			b = 0;
			for (i = 0; i < 6; i++) {
				if (!(_vm->_characters[i].flags & 1))
					continue;
				if (_vm->_classModifierFlags[_vm->_characters[i].cClass] & cmd) {
					b = 1;
					break;
				}
			}
			_stack[_stackIndex++] = b;
			debugC(5, kDebugLevelScript, "         - check if character with class flags '0x%.02X' is present - PUSH result: '%d'", cmd, b);
			break;

		case 3:
			cmd = *pos++;
			b = 0;
			for (i = 0; i < 6; i++) {
				if (!(_vm->_characters[i].flags & 1))
					continue;
				if ((_vm->_characters[i].raceSex >> 1) == cmd) {
					b = 1;
					break;
				}
			}
			_stack[_stackIndex++] = b;
			debugC(5, kDebugLevelScript, "         - check if character with race '%d' is present - PUSH result: '%d'", cmd, b);
			break;

		case 6:
			_stack[_stackIndex++] = _lastScriptFlags;
			debugC(5, kDebugLevelScript, "         - get script execution flags - PUSH result: '%d'", _lastScriptFlags);
			break;

		case 13:
			itm = &_vm->_items[_vm->_itemInHand];
			switch (*pos++) {
			case -31:
				_stack[_stackIndex++] = itm->type;
				debugC(5, kDebugLevelScript, "         - get hand item type (hand item number = '%d') - PUSH result: '%d'", _vm->_itemInHand, itm->type);
				break;

			case -11:
				_stack[_stackIndex++] = _vm->_itemInHand;
				debugC(5, kDebugLevelScript, "         - get hand item number - PUSH result: '%d'", _vm->_itemInHand);
				break;

			default:
				_stack[_stackIndex++] = itm->value;
				debugC(5, kDebugLevelScript, "         - get hand item value (hand item number = '%d') - PUSH result: '%d'", _vm->_itemInHand, itm->value);
				break;
			}
			break;

		case 15:
			_stack[_stackIndex++] = _vm->_levelBlockProperties[READ_LE_UINT16(pos + 1)].walls[pos[0]];
			debugC(5, kDebugLevelScript, "         - get wall index for block '0x%.04X', direction '%d' - PUSH result: '%d'", READ_LE_UINT16(pos + 1), pos[0], _stack[_stackIndex - 1]);
			pos += 3;
			break;

		case 19:
			_stack[_stackIndex++] = _vm->_currentDirection;
			debugC(5, kDebugLevelScript, "         - get current direction - PUSH result: '%d'", _vm->_currentDirection);
			break;

		case 21:
			_stack[_stackIndex++] = (_flagTable[_vm->_currentLevel] & (1 << (*pos++))) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - test level flag '%d' (current level = '%d') - PUSH result: '%d'", *(pos - 1), _vm->_currentLevel, _stack[_stackIndex - 1]);
			break;

		case 22:
			_stack[_stackIndex++] = (_flagTable[17] & (1 << (*pos++))) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - test global flag '%d' - PUSH result: '%d'", *(pos - 1), _stack[_stackIndex - 1]);
			break;

		case 23:
			_stack[_stackIndex++] = (_vm->_currentBlock == READ_LE_UINT16(pos)) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - compare current block with block '0x%.04X' (current block = '0x%.04X') - PUSH result: '%d'", _vm->_currentBlock, READ_LE_UINT16(pos), _stack[_stackIndex - 1]);
			pos += 2;
			break;

		case 24:
			a = (int16)READ_LE_UINT16(pos);
			pos += 2;
			b = READ_LE_UINT16(pos);
			pos += 2;
			_stack[_stackIndex++] = _vm->countQueuedItems(_vm->_levelBlockProperties[b].drawObjects, a, -1, 0, 1);
			debugC(5, kDebugLevelScript, "         - find item number '%d' on block '0x%.04X' - PUSH result: '%d'", a, b, _stack[_stackIndex - 1]);
			break;

		case 25:
			_stack[_stackIndex++] = (_vm->_levelBlockProperties[READ_LE_UINT16(pos)].flags & 1) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - test block flag '1' for block '0x%.04X' - PUSH result: '%d'", READ_LE_UINT16(pos), _stack[_stackIndex - 1]);
			pos += 2;
			break;

		case 27:
			b = *pos++;
			i = READ_LE_UINT16(pos);
			pos += 2;
			_stack[_stackIndex++] = _vm->countQueuedItems(_vm->_levelBlockProperties[i].drawObjects, -1, b, 1, 1);
			debugC(5, kDebugLevelScript, "         - count items of type '%d' on block '0x%.04X' - PUSH result: '%d'", b, i, _stack[_stackIndex - 1]);
			break;

		case 29:
			_stack[_stackIndex++] = _vm->_levelBlockProperties[READ_LE_UINT16(pos)].walls[0];
			debugC(5, kDebugLevelScript, "         - get wall index 0 for block '0x%.04X' - PUSH result: '%d'", READ_LE_UINT16(pos), _stack[_stackIndex - 1]);
			pos += 2;
			break;

		case 30:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a || b) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - evaluate: POP('%d') || POP('%d') - PUSH result: '%d'", a, b, _stack[_stackIndex - 1]);
			break;

		case 31:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a && b) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - evaluate: POP('%d') && POP('%d') - PUSH result: '%d'", a, b, _stack[_stackIndex - 1]);
			break;

		case 32:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a <= b) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - evaluate: POP('%d') <= POP('%d') - PUSH result: '%d'", a, b, _stack[_stackIndex - 1]);
			break;

		case 33:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a < b) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - evaluate: POP('%d') < POP('%d') - PUSH result: '%d'", a, b, _stack[_stackIndex - 1]);
			break;

		case 34:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a >= b) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - evaluate: POP('%d') >= POP('%d') - PUSH result: '%d'", a, b, _stack[_stackIndex - 1]);
			break;

		case 35:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a > b) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - evaluate: POP('%d') > POP('%d') - PUSH result: '%d'", a, b, _stack[_stackIndex - 1]);
			break;

		case 36:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a != b) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - evaluate: POP('%d') != POP('%d') - PUSH result: '%d'", a, b, _stack[_stackIndex - 1]);
			break;

		case 37:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a == b) ? 1 : 0;
			debugC(5, kDebugLevelScript, "         - evaluate: POP('%d') == POP('%d') - PUSH result: '%d'", a, b, _stack[_stackIndex - 1]);
			break;

		default:
			a = cmd;
			if (a >= 0 && a < 128)
				_stack[_stackIndex++] = a;
			debugC(5, kDebugLevelScript, "         - PUSH value: '%d'", a);
			break;
		}
		cmd = *pos++;
	}

	cmd = _stack[--_stackIndex];
	if (cmd)
		pos += 2;
	else
		pos = _scriptData + READ_LE_UINT16(pos);
	debugC(5, kDebugLevelScript, "         - conditional jump depending on POP('%d')", cmd);

	return pos - data;
}

int EoBInfProcessor::oeob_eval_v2(int8 *data) {
	int8 *pos = data;
	int8 cmd = *pos++;

	int a = 0;
	int b = 0;
	int i = 0;
	EoBItem *itm = (_vm->_itemInHand != -1) ? &_vm->_items[_vm->_itemInHand] : 0;
	Common::String tempString1;
	Common::String tempString2;

	while (cmd != -18) {
		switch (cmd + 50) {
		case 0:
			a = 0;
			b = *pos++;

			for (i = 0; i < 6; i++) {
				if (!_vm->testCharacter(i, 5))
					continue;

				if (_vm->_characters[i].portrait != b) {
					a = 1;
					_activeCharacter = i;
					break;
				}
			}

			_stack[_stackIndex++] = a;
			break;

		case 4:
			_stack[_stackIndex++] = (int16)READ_LE_UINT16(pos);
			pos += 2;
			break;

		case 9:
			switch (*pos++) {
			case -36:
				_stack[_stackIndex++] = _vm->_itemTypes[_vm->_items[_vm->_lastUsedItem].type].extraProperties & 0x7F;
				break;
			case -31:
				_stack[_stackIndex++] = _vm->_items[_vm->_lastUsedItem].type;
				break;
			case -11:
				_stack[_stackIndex++] = _vm->_lastUsedItem;
				break;
			case -10:
				_stack[_stackIndex++] = _vm->_items[_vm->_lastUsedItem].value;
				break;
			default:
				break;
			}
			break;

		case 12:
			a = 1;
			for (i = 0; i < 6; i++) {
				if (!(_vm->_characters[i].flags & 1))
					continue;
				if (_vm->_characters[i].effectFlags & 0x40)
					continue;
				a = 0;
				break;
			}
			_stack[_stackIndex++] = a;
			break;

		case 13:
			_stack[_stackIndex++] = _vm->rollDice(pos[0], pos[1], pos[2]);
			pos += 3;
			break;

		case 14:
			cmd = *pos++;
			a = _vm->rollDice(1, 6);
			b = 0;
			for (i = 0; i < 6 && b == 0; i++) {
				if (++a > 5)
					a = 0;
				if (_vm->testCharacter(a, 5)) {
					if (_vm->_classModifierFlags[_vm->_characters[a].cClass] & cmd) {
						_activeCharacter = a;
						b = 1;
					}
				}
			}
			_stack[_stackIndex++] = b;
			break;

		case 15:
			cmd = *pos++;
			a = _vm->rollDice(1, 6);
			b = 0;
			for (i = 0; i < 6; i++) {
				if (++a > 5)
					a = 0;
				if (_vm->testCharacter(a, 5)) {
					if ((_vm->_characters[a].raceSex >> 1) == cmd) {
						_activeCharacter = a;
						b = 1;
					}
				}
			}
			_stack[_stackIndex++] = b;
			break;

		case 17:
			_stack[_stackIndex++] = _vm->_activeSpell;
			break;

		case 18:
			_stack[_stackIndex++] = _lastScriptFlags;
			break;

		case 22:
			_stack[_stackIndex++] = _dlgResult;
			break;

		case 25:
			itm = &_vm->_items[_vm->_itemInHand];

			switch (*pos++) {
			case -49:
				a = *pos++;
				tempString1 = _vm->_itemNames[itm->nameId];
				tempString1.toUppercase();
				tempString2 = (const char *)pos;
				tempString2.toUppercase();
				pos += a;
				_stack[_stackIndex++] = tempString1.contains(tempString2) ? 1 : 0;
				break;

			case -48:
				a = *pos++;
				tempString1 = _vm->_itemNames[itm->nameUnid];
				tempString1.toUppercase();
				tempString2 = (const char *)pos;
				tempString2.toUppercase();
				pos += a;
				_stack[_stackIndex++] = tempString1.contains(tempString2) ? 1 : 0;
				break;

			case -31:
				_stack[_stackIndex++] = itm->type;
				break;

			case -11:
				_stack[_stackIndex++] = _vm->_itemInHand;
				break;

			case -10:
				_stack[_stackIndex++] = itm->value;
				break;

			default:
				break;
			}

			break;

		case 26:
			a = 0;
			for (i = 0; i < 6; i++) {
				if (_vm->testCharacter(i, 0x0F))
					a++;
			}
			_stack[_stackIndex++] = a;
			break;

		case 27:
			_stack[_stackIndex++] = _vm->_levelBlockProperties[READ_LE_UINT16(pos + 1)].walls[pos[0]];
			pos += 3;
			break;

		case 31:
			_stack[_stackIndex++] = _vm->_currentDirection;
			break;

		case 33:
			_stack[_stackIndex++] = (_flagTable[_vm->_currentLevel] & (1 << (*pos++))) ? 1 : 0;
			break;

		case 34:
			_stack[_stackIndex++] = (_flagTable[17] & (1 << (*pos++))) ? 1 : 0;
			break;

		case 35:
			if (*pos++ == -11) {
				a = (int16)READ_LE_UINT16(pos);
				pos += 2;
				b = (int16)READ_LE_UINT16(pos);
				pos += 2;
				_stack[_stackIndex++] = _vm->countCharactersWithSpecificItems(a, b);
			} else {
				_stack[_stackIndex++] = (_vm->_currentBlock == READ_LE_UINT16(pos)) ? 1 : 0;
				pos += 2;
			}
			break;

		case 36:
			a = (int16)READ_LE_UINT16(pos);
			pos += 2;
			b = READ_LE_UINT16(pos);
			pos += 2;
			_stack[_stackIndex++] = _vm->countQueuedItems(_vm->_levelBlockProperties[b].drawObjects, a, -1, 0, 0);
			break;

		case 37:
			if (*pos++ == -1) {
				_stack[_stackIndex++] = _vm->_levelBlockProperties[READ_LE_UINT16(pos)].flags & 7;
				pos += 2;
			} else {
				do {
					a += _vm->countSpecificMonsters(*pos++);
				} while (*pos != -1);
				pos++;
				_stack[_stackIndex++] = a;
			}
			break;

		case 39:
			a = *pos++;
			b = *pos++;
			i = READ_LE_UINT16(pos);
			pos += 2;
			_stack[_stackIndex++] = _vm->countQueuedItems(_vm->_levelBlockProperties[i].drawObjects, -1, b, 1, a);
			break;

		case 41:
			_stack[_stackIndex++] = _vm->_levelBlockProperties[READ_LE_UINT16(pos)].walls[0];
			pos += 2;
			break;

		case 42:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a || b) ? 1 : 0;
			break;

		case 43:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a && b) ? 1 : 0;
			break;

		case 44:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a <= b) ? 1 : 0;
			break;

		case 45:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a < b) ? 1 : 0;
			break;

		case 46:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a >= b) ? 1 : 0;
			break;

		case 47:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a > b) ? 1 : 0;
			break;

		case 48:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a != b) ? 1 : 0;
			break;

		case 49:
			a = _stack[--_stackIndex];
			b = _stack[--_stackIndex];
			_stack[_stackIndex++] = (a == b) ? 1 : 0;
			break;

		default:
			break;
		}
		cmd = *pos++;
	}

	cmd = _stack[--_stackIndex];
	if (cmd)
		pos += 2;
	else
		pos = _scriptData + READ_LE_UINT16(pos);

	return pos - data;
}

int EoBInfProcessor::oeob_deleteItem(int8 *data) {
	int8 *pos = data;
	int8 c = *pos++;

	if (c == -1) {
		_vm->deleteInventoryItem(0, -1);
		debugC(5, kDebugLevelScript, "         - delete hand item");
	} else {
		_vm->deleteBlockItem(READ_LE_UINT16(pos), (c == -2) ? -1 : c);
		debugC(5, kDebugLevelScript, "         - delete item(s) of type '%d' on block '0x%.04X'", (c == -2) ? -1 : c, READ_LE_UINT16(pos));
		pos += 2;
	}

	return pos - data;
}

int EoBInfProcessor::oeob_loadNewLevelOrMonsters(int8 *data) {
	int8 *pos = data;
	_vm->gui_updateControls();

	int8 cmd = *pos++;
	int8 index = *pos++;
	int res = 0;

	if (cmd == -27 || _vm->game() == GI_EOB1) {
		cmd = _vm->game() == GI_EOB2 ? *pos++ : 0;
		_vm->_currentBlock = READ_LE_UINT16(pos);
		pos += 2;
		uint8 dir = (uint8)*pos++;

		if (dir != 0xFF)
			_vm->_currentDirection = dir;

		for (int i = 0; i < 30; i++)
			_vm->_monsters[i].curAttackFrame = 0;

		for (int i = 0; i < 10; i++) {
			EoBFlyingObject *fo = &_vm->_flyingObjects[i];
			if (fo->enable == 1) {
				_vm->_items[fo->item].pos &= 3;
				run(_vm->_items[fo->item].block, 4);
			}
			fo->enable = 0;
		}

		_vm->completeDoorOperations();

		_vm->generateTempData();
		_vm->txt()->removePageBreakFlag();
		_screen->setScreenDim(7);

		_vm->loadLevel(index, cmd);
		debugC(5, kDebugLevelScript, "         - entering level '%d', sub level '%d', start block '0x%.04X', start direction '%d'", index, cmd, _vm->_currentBlock, _vm->_currentDirection);

		if (_vm->_dialogueField)
			_vm->restoreAfterDialogueSequence();

		_vm->moveParty(_vm->_currentBlock);

		_abortScript = 1;
		_abortAfterSubroutine = 1;
		_vm->_sceneUpdateRequired = true;

		_vm->gui_drawAllCharPortraitsWithStats();
		_subroutineStackPos = 0;

	} else {
		cmd = *pos++;
		_vm->releaseMonsterShapes(cmd * 18, 18);
		_vm->loadMonsterShapes((const char *)pos, cmd * 18, true, index * 18);
		debugC(5, kDebugLevelScript, "         - loading monster shapes '%s', monster number '%d', encode type '%d'", (const char *)pos, cmd, index);
		pos += 13;
		_vm->gui_restorePlayField();
		res = pos - data;
	}

	return res;
}

int EoBInfProcessor::oeob_increasePartyExperience(int8 *data) {
	int8 *pos = data;
	if (*pos++ == -30) {
		_vm->increasePartyExperience((int16)READ_LE_UINT16(pos));
		debugC(5, kDebugLevelScript, "         - award '%d' experience points", READ_LE_UINT16(pos));
		pos += 2;
	}
	return pos - data;
}

int EoBInfProcessor::oeob_createItem_v1(int8 *data) {
	int8 *pos = data;
	uint16 itm = _vm->duplicateItem(READ_LE_UINT16(pos));
	pos += 2;
	uint16 block = READ_LE_UINT16(pos);
	pos += 2;
	uint8 itmPos = *pos++;

	if (itm) {
		if (block == 0xFFFF && !_vm->_itemInHand) {
			_vm->setHandItem(itm);
			debugC(5, kDebugLevelScript, "         - create hand item '%d'", itm);
		} else if (block != 0xFFFF) {
			_vm->setItemPosition((Item *)&_vm->_levelBlockProperties[block & 0x3FF].drawObjects, block, itm, itmPos);
			debugC(5, kDebugLevelScript, "         - create item '%d' on block '0x%.04X', position '%d'", itm, block, itmPos);
		}
	}

	return pos - data;
}

int EoBInfProcessor::oeob_createItem_v2(int8 *data) {
	static const uint8 _itemPos[] = { 0, 1, 2, 3, 1, 3, 0, 2, 3, 2, 1, 0, 2, 0, 3, 1 };
	int8 *pos = data;

	uint16 itm = _vm->duplicateItem(READ_LE_UINT16(pos));
	pos += 2;
	uint16 block = READ_LE_UINT16(pos);
	pos += 2;
	uint8 itmPos = *pos++;
	uint8 flg = *pos++;

	if (flg & 1)
		_vm->_items[itm].value = *pos++;

	if (flg & 2)
		_vm->_items[itm].flags = *pos++;

	if (flg & 4)
		_vm->_items[itm].icon = *pos++;

	if (!itm)
		return pos - data;

	if (block == 0xFFFF) {
		if (!_vm->_itemInHand) {
			_vm->setHandItem(itm);
			debugC(5, kDebugLevelScript, "         - create hand item '%d' (value '%d', flags '0x%X', icon number '%d')", itm, _vm->_items[itm].value, _vm->_items[itm].flags, _vm->_items[itm].icon);
		} else {
			_vm->setItemPosition((Item *)&_vm->_levelBlockProperties[_vm->_currentBlock & 0x3FF].drawObjects, _vm->_currentBlock, itm, _itemPos[_vm->rollDice(1, 2, -1)]);
			debugC(5, kDebugLevelScript, "         - create item '%d' (value '%d', flags '0x%X', icon number '%d') on current block", itm, _vm->_items[itm].value, _vm->_items[itm].flags, _vm->_items[itm].icon);
		}
	} else if (block == 0xFFFE) {
		_vm->setItemPosition((Item *)&_vm->_levelBlockProperties[_vm->_currentBlock & 0x3FF].drawObjects, _vm->_currentBlock, itm, _itemPos[(_vm->_currentDirection << 2) + _vm->rollDice(1, 2, -1)]);
		debugC(5, kDebugLevelScript, "         - create item '%d' (value '%d', flags '0x%X', icon number '%d') on current block", itm, _vm->_items[itm].value, _vm->_items[itm].flags, _vm->_items[itm].icon);
	} else {
		_vm->setItemPosition((Item *)&_vm->_levelBlockProperties[block & 0x3FF].drawObjects, block, itm, itmPos);
		debugC(5, kDebugLevelScript, "         - create item '%d' (value '%d', flags '0x%X', icon number '%d') on block '0x%.04X', position '%d'", itm, _vm->_items[itm].value, _vm->_items[itm].flags, _vm->_items[itm].icon, block, itmPos);
	}

	return pos - data;
}

int EoBInfProcessor::oeob_launchObject(int8 *data) {
	static const uint8 startPos[] = { 2, 3, 0, 2, 1, 0, 3, 1 };

	int8 *pos = data;
	bool m = (*pos++ == -33);
	int i = READ_LE_UINT16(pos);
	pos += 2;
	uint16 block = READ_LE_UINT16(pos);
	pos += 2;
	int dir = *pos++;
	int dirOffs =  *pos++;

	if (m) {
		uint8 openBookType = _vm->_openBookType;
		_vm->_openBookType = 0;
		_vm->launchMagicObject(-1, i, block, startPos[dir * 2 + dirOffs], dir);
		_vm->_openBookType = openBookType;
	} else {
		Item itm = _vm->duplicateItem(i);
		if (itm) {
			if (!_vm->launchObject(-1, itm, block, startPos[dir * 2 + dirOffs], dir, _vm->_items[itm].type))
				_vm->_items[itm].block = -1;
		}
	}

	return pos - data;
}

int EoBInfProcessor::oeob_changeDirection(int8 *data) {
	int8 *pos = data;

	int8 cmd = *pos++;
	int8 dir = *pos++;

	if (cmd == -15) {
		_vm->_currentDirection = (_vm->_currentDirection + dir) & 3;
		//_vm->_keybControlUnk = -1;
		_vm->_sceneUpdateRequired = true;

	} else if (cmd == -11) {
		for (int i = 0; i < 10; i++) {
			if (_vm->_flyingObjects[i].enable)
				_vm->_flyingObjects[i].direction = (_vm->_flyingObjects[i].direction + dir) & 3;
		}
	}

	return pos - data;
}

int EoBInfProcessor::oeob_identifyItems(int8 *data) {
	int8 *pos = data;
	uint16 block = READ_LE_UINT16(pos);

	if (block == _vm->_currentBlock) {
		for (int i = 0; i < 6; i++) {
			if (!(_vm->_characters[i].flags & 1))
				continue;

			for (int ii = 0; ii < 27; ii++) {
				int inv = _vm->_characters[i].inventory[ii];
				if (inv)
					_vm->_items[inv].flags |= 0x40;
			}

			_vm->identifyQueuedItems(_vm->_characters[i].inventory[16]);
		}
	}

	_vm->identifyQueuedItems(_vm->_levelBlockProperties[block].drawObjects);
	return pos - data;
}

int EoBInfProcessor::oeob_sequence(int8 *data) {
	int8 *pos = data;
	_vm->_npcSequenceSub = -1;
	_vm->txt()->setWaitButtonMode(0);
	_vm->gui_updateControls();
	_vm->drawScene(1);

	int cmd = *pos++;

	if (_vm->game() == GI_EOB1) {
		if (cmd == 10)
			cmd = -1;
		else if (cmd == 9)
			cmd = -3;
		else if (cmd == 8)
			cmd = -2;
	}

	switch (cmd) {
	case -3:
		_vm->seq_xdeath();
		_vm->_runFlag = false;
		_vm->_playFinale = true;
		_abortScript = 1;
		return 0;

	case -2:
		_vm->seq_portal();
		break;

	case -1:
		_vm->_runFlag = _vm->checkPassword();
		break;

	default:
		_vm->npcSequence(cmd);
		break;
	}
	_vm->screen()->setScreenDim(7);
	return pos - data;
}

int EoBInfProcessor::oeob_delay(int8 *data) {
	int8 *pos = data;
	_vm->delay(READ_LE_UINT16(pos) * _vm->tickLength());
	pos += 2;
	return pos - data;
}

int EoBInfProcessor::oeob_drawScene(int8 *data) {
	_vm->drawScene(1);
	return 0;
}

int EoBInfProcessor::oeob_dialogue(int8 *data) {
	int8 *pos = data;

	switch (*pos++) {
	case -45:
		_vm->drawSequenceBitmap((const char *)pos, pos[13], READ_LE_UINT16(pos + 14), READ_LE_UINT16(pos + 16), READ_LE_UINT16(pos + 18));
		pos += 20;
		break;

	case -44:
		_vm->restoreAfterDialogueSequence();
		break;

	case -43:
		_vm->initDialogueSequence();
		break;

	case -42:
		_vm->gui_drawDialogueBox();
		break;

	case -40:
		_dlgResult = _vm->runDialogue(READ_LE_UINT16(pos), READ_LE_UINT16(pos + 6) == 0xFFFF ? 2 : 3, getString(READ_LE_UINT16(pos + 2)), getString(READ_LE_UINT16(pos + 4)), getString(READ_LE_UINT16(pos + 6)));
		pos += 8;
		break;

	case -8:
		_vm->txt()->printDialogueText(READ_LE_UINT16(pos), getString(READ_LE_UINT16(pos + 2)));
		pos += 4;
		break;

	default:
		break;
	}

	return pos - data;
}

int EoBInfProcessor::oeob_specialEvent(int8 *data) {
	int8 *pos = data;
	uint16 cmd = READ_LE_UINT16(pos);
	pos += 2;

	uint32 endTime = 0;
	int i = 0;

	switch (cmd) {
	case 0:
		_vm->drawScene(1);
		_screen->_curPage = 2;
		_screen->copyRegion(72, 0, 0, 0, 32, 120, 2, 12, Screen::CR_NO_P_CHECK);

		for (; i < 4; i++) {
			endTime = _vm->_system->getMillis() + _vm->_tickLength;
			_vm->drawLightningColumn();
			_screen->copyRegion(72, 0, 72, 0, 32, 120, 2, 0, Screen::CR_NO_P_CHECK);
			_screen->updateScreen();
			_screen->copyRegion(0, 0, 72, 0, 32, 120, 12, 2, Screen::CR_NO_P_CHECK);
			_vm->delayUntil(endTime);
		}

		_screen->_curPage = 0;
		_vm->_sceneUpdateRequired = true;
		break;

	case 1:
		_dlgResult = _vm->charSelectDialogue();
		break;

	case 2:
		_vm->characterLevelGain(_dlgResult);
		break;

	case 3:
		_dlgResult = _vm->resurrectionSelectDialogue();
		break;

	case 4:
		if (_vm->prepareForNewPartyMember(33, 5))
			_vm->initNpc(4);
		break;

	case 5:
		_vm->deletePartyItems(46, 5);
		_vm->deletePartyItems(46, 6);
		break;

	case 6:
		_vm->loadVcnData(0, 0);
		break;

	default:
		break;
	}

	return pos - data;
}

} // End of namespace Kyra

#endif // ENABLE_EOB
