/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/tags/release-1-1-1/engines/saga/script.cpp $
 * $Id: script.cpp 48139 2010-02-26 22:24:48Z thebluegr $
 *
 */

// Scripting module: Script resource handling functions
#include "saga/saga.h"

#include "saga/gfx.h"
#include "saga/console.h"

#include "saga/script.h"
#include "saga/interface.h"
#include "saga/itedata.h"
#include "saga/scene.h"
#include "saga/events.h"
#include "saga/actor.h"
#include "saga/objectmap.h"
#include "saga/isomap.h"
#include "saga/resource.h"

namespace Saga {

#define RID_SCENE1_VOICE_START 57
#define RID_SCENE1_VOICE_END 186

SAGA1Script::SAGA1Script(SagaEngine *vm) : Script(vm) {
	ResourceContext *resourceContext;
	byte *resourcePointer;
	size_t resourceLength;
	int prevTell;
	int i, j;
	byte *stringsPointer;
	size_t stringsLength;

	//initialize member variables
	_abortEnabled = true;
	_skipSpeeches = false;
	_conversingThread = NULL;
	_firstObjectSet = false;
	_secondObjectNeeded = false;
	_pendingVerb = getVerbType(kVerbNone);
	_currentVerb = getVerbType(kVerbNone);
	_stickyVerb = getVerbType(kVerbWalkTo);
	_leftButtonVerb = getVerbType(kVerbNone);
	_rightButtonVerb = getVerbType(kVerbNone);
	_pointerObject = ID_NOTHING;

	_staticSize = 0;
	_commonBufferSize = COMMON_BUFFER_SIZE;
	_commonBuffer = (byte*)malloc(_commonBufferSize);
	memset(_commonBuffer, 0, _commonBufferSize);

	debug(8, "Initializing scripting subsystem");
	// Load script resource file context
	_scriptContext = _vm->_resource->getContext(GAME_SCRIPTFILE);
	if (_scriptContext == NULL) {
		error("Script::Script() script context not found");
	}

	resourceContext = _vm->_resource->getContext(GAME_RESOURCEFILE);
	if (resourceContext == NULL) {
		error("Script::Script() resource context not found");
	}

	uint32 scriptResourceId = 0;
	scriptResourceId = _vm->getResourceDescription()->moduleLUTResourceId;
	debug(3, "Loading module LUT from resource %i", scriptResourceId);
	_vm->_resource->loadResource(resourceContext, scriptResourceId, resourcePointer, resourceLength);

	// Create logical script LUT from resource
	if (resourceLength % 22 == 0) {			// ITE CD
		_modulesLUTEntryLen = 22;
	} else if (resourceLength % 16 == 0) {	// ITE disk, IHNM
		_modulesLUTEntryLen = 16;
	} else {
		error("Script::Script() Invalid script lookup table length (%i)", (int)resourceLength);
	}

	// Calculate number of entries
	_modulesCount = resourceLength / _modulesLUTEntryLen;

	debug(3, "LUT has %i entries", _modulesCount);

	// Allocate space for logical LUT
	_modules = (ModuleData *)malloc(_modulesCount * sizeof(*_modules));
	if (_modules == NULL) {
		memoryError("Script::Script()");
	}

	// Convert LUT resource to logical LUT
	MemoryReadStreamEndian scriptS(resourcePointer, resourceLength, resourceContext->isBigEndian());
	for (i = 0; i < _modulesCount; i++) {
		memset(&_modules[i], 0, sizeof(ModuleData));

		prevTell = scriptS.pos();
		_modules[i].scriptResourceId = scriptS.readUint16();
		_modules[i].stringsResourceId = scriptS.readUint16();
		_modules[i].voicesResourceId = scriptS.readUint16();

		// Skip the unused portion of the structure
		for (j = scriptS.pos(); j < prevTell + _modulesLUTEntryLen; j++) {
			if (scriptS.readByte() != 0)
				warning("Unused scriptLUT part isn't really unused for LUT %d (pos: %d)", i, j);
		}
	}

	free(resourcePointer);

	// TODO
	//
	// In ITE, the "main strings" resource contains both the verb strings
	// and the object names.
	//
	// In IHNM, the "main strings" contains the verb strings, but not the
	// object names. At least, I think that's the case.

	_vm->_resource->loadResource(resourceContext, _vm->getResourceDescription()->mainStringsResourceId, stringsPointer, stringsLength);

	_vm->loadStrings(_mainStrings, stringsPointer, stringsLength);
	free(stringsPointer);

	setupScriptOpcodeList();

	// Setup script functions
	switch (_vm->getGameId()) {
		case GID_ITE:
			setupITEScriptFuncList();
			break;
#ifdef ENABLE_IHNM
		case GID_IHNM:
			setupIHNMScriptFuncList();
			break;
#endif
	}
}

SAGA1Script::~SAGA1Script() {
	debug(8, "Shutting down scripting subsystem.");

	_mainStrings.freeMem();
	_globalVoiceLUT.freeMem();

	freeModules();
	free(_modules);

	free(_commonBuffer);
}

SAGA2Script::SAGA2Script(SagaEngine *vm) : Script(vm) {
	byte *resourcePointer;
	size_t resourceLength;

	debug(8, "Initializing scripting subsystem");
	// Load script resource file context
	_scriptContext = _vm->_resource->getContext(GAME_SCRIPTFILE);
	if (_scriptContext == NULL) {
		error("Script::Script() script context not found");
	}

	// Script export segment (lookup table)
	uint32 saga2ExportSegId = MKID_BE('_EXP');
	int32 entryNum = _scriptContext->getEntryNum(saga2ExportSegId);
	if (entryNum < 0)
		error("Unable to locate the script's export segment");
	debug(3, "Loading module LUT from resource %i", entryNum);
	_vm->_resource->loadResource(_scriptContext, (uint32)entryNum, resourcePointer, resourceLength);

	_modulesLUTEntryLen = sizeof(uint32);

	// Calculate number of entries
	_modulesCount = resourceLength / _modulesLUTEntryLen + 1;

	debug(3, "LUT has %i entries", _modulesCount);

	// Script data segment
	/*
	uint32 saga2DataSegId = MKID_BE('__DA');
	entryNum = _scriptContext->getEntryNum(saga2DataSegId);
	if (entryNum < 0)
		error("Unable to locate the script's data segment");
	debug(3, "Loading module data from resource %i", entryNum);
	_vm->_resource->loadResource(_scriptContext, (uint32)entryNum, resourcePointer, resourceLength);
	*/

	// TODO
}

SAGA2Script::~SAGA2Script() {
	debug(8, "Shutting down scripting subsystem.");

	// TODO
}

// Initializes the scripting module.
// Loads script resource look-up table, initializes script data system
Script::Script(SagaEngine *vm) : _vm(vm) {

}

// Shut down script module gracefully; free all allocated module resources
Script::~Script() {

}

// Script opcodes
#define OPCODE(x) {&Script::x, #x}

void Script::setupScriptOpcodeList() {
	static const ScriptOpDescription SAGA1ScriptOpcodes[] = {
		OPCODE(opDummy),		// 00: Undefined
		// Internal operations
		OPCODE(opNextBlock),	// 01: Continue execution at next block
		OPCODE(opDup),			// 02: Duplicate 16-bit value on stack
		OPCODE(opDrop),			// 03: Drop 16-bit value on stack
		// Primary values
		OPCODE(opZero),			// 04: Push a zero on the stack
		OPCODE(opOne),			// 05: Push a one on the stack
		OPCODE(opConstInt),		// 06: Constant integer
		OPCODE(opDummy),		// 07: Constant ID reference (unused)
		OPCODE(opStrLit),		// 08: String literal
		OPCODE(opDummy),		// 09: Symbol address (unused)
		OPCODE(opDummy),		// 10: Symbol contents (unused)
		// References within this module
		OPCODE(opGetFlag),		// 11: Read flag bit
		OPCODE(opGetInt),		// 12: Read integer
		OPCODE(opDummy),		// 13: Read string (unused)
		OPCODE(opDummy),		// 14: Read id (unused)
		OPCODE(opPutFlag),		// 15: Write flag bit
		OPCODE(opPutInt),		// 16: Write integer
		OPCODE(opDummy),		// 17: Write string (unused)
		OPCODE(opDummy),		// 18: Write id (unused)
		// Void versions, which consume their arguments
		OPCODE(opPutFlagV),		// 19: Write flag bit
		OPCODE(opPutIntV),		// 20: Write integer
		OPCODE(opDummy),		// 21: Write string (unused)
		OPCODE(opDummy),		// 22: Write id (unused)
		// Function calling
		OPCODE(opCall),			// 23: Call function
		OPCODE(opCcall),		// 24: Call C function
		OPCODE(opCcallV),		// 25: Call C function ()
		OPCODE(opEnter),		// 26: Enter a function
		OPCODE(opReturn),		// 27: Return from a function
		OPCODE(opReturnV),		// 28: Return from a function ()
		// Branching
		OPCODE(opJmp),			// 29
		OPCODE(opJmpTrueV),		// 30: Test argument and consume it
		OPCODE(opJmpFalseV),	// 31: Test argument and consume it
		OPCODE(opJmpTrue),		// 32: Test argument but don't consume it
		OPCODE(opJmpFalse),		// 33: Test argument but don't consume it
		OPCODE(opJmpSwitch),	// 34: Switch (integer)
		OPCODE(opDummy),		// 35: Switch (string) (unused)
		OPCODE(opJmpRandom),	// 36: Random jump
		// Unary operators
		OPCODE(opNegate),		// 37
		OPCODE(opNot),			// 38
		OPCODE(opCompl),		// 39
		OPCODE(opIncV),			// 40: Increment, don't push
		OPCODE(opDecV),			// 41: Increment, don't push
		OPCODE(opPostInc),		// 42
		OPCODE(opPostDec),		// 43
		// Arithmetic
		OPCODE(opAdd),			// 44
		OPCODE(opSub),			// 45
		OPCODE(opMul),			// 46
		OPCODE(opDiv),			// 47
		OPCODE(opMod),			// 48
		// Conditional
		OPCODE(opDummy),		// 49: opConditional (unused)
		OPCODE(opDummy),		// 50: opComma (unused)
		// Comparison
		OPCODE(opEq),			// 51
		OPCODE(opNe),			// 52
		OPCODE(opGt),			// 53
		OPCODE(opLt),			// 54
		OPCODE(opGe),			// 55
		OPCODE(opLe),			// 56
		// String comparison
		OPCODE(opDummy),		// 57: opStrEq (unused)
		OPCODE(opDummy),		// 58: opStrNe (unused)
		OPCODE(opDummy),		// 59: opStrGt (unused)
		OPCODE(opDummy),		// 60: opStrLt (unused)
		OPCODE(opDummy),		// 61: opStrGe (unused)
		OPCODE(opDummy),		// 62: opStrLe (unused)
		// Shift
		OPCODE(opRsh),			// 63
		OPCODE(opLsh),			// 64
		// Bitwise
		OPCODE(opAnd),			// 65
		OPCODE(opOr),			// 66
		OPCODE(opXor),			// 67
		// Logical
		OPCODE(opLAnd),			// 68
		OPCODE(opLOr),			// 69
		OPCODE(opLXor),			// 70
		// String manipulation
		OPCODE(opDummy),		// 71: opStrCat, string concatenation (unused)
		OPCODE(opDummy),		// 72: opStrFormat, string formatting (unused)
		// Assignment
		OPCODE(opDummy),		// 73: assign (unused)
		OPCODE(opDummy),		// 74: += (unused)
		OPCODE(opDummy),		// 75: -= (unused)
		OPCODE(opDummy),		// 76: *= (unused)
		OPCODE(opDummy),		// 77: /= (unused)
		OPCODE(opDummy),		// 78: %= (unused)
		OPCODE(opDummy),		// 79: <<= (unused)
		OPCODE(opDummy),		// 80: >>= (unused)
		OPCODE(opDummy),		// 81: and (unused)
		OPCODE(opDummy),		// 82: or (unused)
		// Special
		OPCODE(opSpeak),		// 83
		OPCODE(opDialogBegin),	// 84
		OPCODE(opDialogEnd),	// 85
		OPCODE(opReply),		// 86
		OPCODE(opAnimate)		// 87
	};

#ifdef ENABLE_SAGA2
	static const ScriptOpDescription SAGA2ScriptOpcodes[] = {
		OPCODE(opDummy),		// 00: Undefined
		// Internal operations
		OPCODE(opNextBlock),	// 01: Continue execution at next block
		OPCODE(opDup),			// 02: Duplicate 16-bit value on stack
		OPCODE(opDrop),			// 03: Drop 16-bit value on stack
		// Primary values
		OPCODE(opZero),			// 04: Push a zero on the stack
		OPCODE(opOne),			// 05: Push a one on the stack
		OPCODE(opConstInt),		// 06: Constant integer
		OPCODE(opDummy),		// 07: Constant ID reference (unused)
		OPCODE(opStrLit),		// 08: String literal
		OPCODE(opDummy),		// 09: Symbol address (unused)
		OPCODE(opDummy),		// 10: Symbol contents (unused)
		OPCODE(opDummy),		// 11: Reference to "this" (unused)
		OPCODE(opDummy),		// 12: Dereference of an ID (unused)
		// References within this module
		OPCODE(opGetFlag),		// 13: Read flag bit
		OPCODE(opGetByte),		// 14: Read byte
		OPCODE(opGetInt),		// 15: Read integer
		OPCODE(opDummy),		// 16: Read string (unused)
		OPCODE(opDummy),		// 17: Read id (unused)
		OPCODE(opPutFlag),		// 18: Write flag bit
		OPCODE(opPutByte),		// 19: Write byte
		OPCODE(opPutInt),		// 20: Write integer
		OPCODE(opDummy),		// 21: Write string (unused)
		OPCODE(opDummy),		// 22: Write id (unused)
		OPCODE(opDummy),		// 23: Push effective address (unused)
		// Void versions, which consume their arguments
		OPCODE(opPutFlagV),		// 24: Write flag bit
		OPCODE(opPutByteV),		// 25: Write byte
		OPCODE(opPutIntV),		// 26: Write integer
		OPCODE(opDummy),		// 27: Write string (unused)
		OPCODE(opDummy),		// 28: Write id (unused)
		// Function calling
		OPCODE(opCallNear),		// 29: Call function in the same segment
		OPCODE(opCallFar),		// 30: Call function in other segment
		OPCODE(opCcall),		// 31: Call C function
		OPCODE(opCcallV),		// 32: Call C function ()
		OPCODE(opCallMember),	// 33: Call member function
		OPCODE(opCallMemberV),	// 34: Call member function ()
		OPCODE(opEnter),		// 35: Enter a function
		OPCODE(opReturn),		// 36: Return from a function
		OPCODE(opReturnV),		// 37: Return from a function ()
		// Branching
		OPCODE(opJmp),			// 38
		OPCODE(opJmpTrueV),		// 39: Test argument and consume it
		OPCODE(opJmpFalseV),	// 40: Test argument and consume it
		OPCODE(opJmpTrue),		// 41: Test argument but don't consume it
		OPCODE(opJmpFalse),		// 42: Test argument but don't consume it
		OPCODE(opJmpSwitch),	// 43: Switch (integer)
		OPCODE(opDummy),		// 44: Switch (string) (unused)
		OPCODE(opJmpRandom),	// 45: Random jump
		// Unary operators
		OPCODE(opNegate),		// 46
		OPCODE(opNot),			// 47
		OPCODE(opCompl),		// 48
		OPCODE(opIncV),			// 49: Increment, don't push
		OPCODE(opDecV),			// 50: Increment, don't push
		OPCODE(opPostInc),		// 51
		OPCODE(opPostDec),		// 52
		// Arithmetic
		OPCODE(opAdd),			// 53
		OPCODE(opSub),			// 54
		OPCODE(opMul),			// 55
		OPCODE(opDiv),			// 56
		OPCODE(opMod),			// 57
		// Conditional
		OPCODE(opDummy),		// 58: opConditional (unused)
		OPCODE(opDummy),		// 59: opComma (unused)
		// Comparison
		OPCODE(opEq),			// 60
		OPCODE(opNe),			// 61
		OPCODE(opGt),			// 62
		OPCODE(opLt),			// 63
		OPCODE(opGe),			// 64
		OPCODE(opLe),			// 65
		// String comparison
		OPCODE(opDummy),		// 66: opStrEq (unused)
		OPCODE(opDummy),		// 67: opStrNe (unused)
		OPCODE(opDummy),		// 68: opStrGt (unused)
		OPCODE(opDummy),		// 69: opStrLt (unused)
		OPCODE(opDummy),		// 70: opStrGe (unused)
		OPCODE(opDummy),		// 71: opStrLe (unused)
		// Shift
		OPCODE(opRsh),			// 72
		OPCODE(opLsh),			// 73
		// Bitwise
		OPCODE(opAnd),			// 74
		OPCODE(opOr),			// 75
		OPCODE(opXor),			// 76
		// Logical
		OPCODE(opLAnd),			// 77
		OPCODE(opLOr),			// 78
		OPCODE(opLXor),			// 79
		// String manipulation
		OPCODE(opDummy),		// 80: opStrCat, string concatenation (unused)
		OPCODE(opDummy),		// 81: opStrFormat, string formatting (unused)
		// Assignment
		OPCODE(opDummy),		// 82: assign (unused)
		OPCODE(opDummy),		// 83: += (unused)
		OPCODE(opDummy),		// 84: -= (unused)
		OPCODE(opDummy),		// 85: *= (unused)
		OPCODE(opDummy),		// 86: /= (unused)
		OPCODE(opDummy),		// 87: %= (unused)
		OPCODE(opDummy),		// 88: <<= (unused)
		OPCODE(opDummy),		// 89: >>= (unused)
		OPCODE(opDummy),		// 90: and (unused)
		OPCODE(opDummy),		// 91: or (unused)
		// Special
		OPCODE(opSpeak),		// 92
		OPCODE(opDialogBegin),	// 93
		OPCODE(opDialogEnd),	// 94
		OPCODE(opReply),		// 95
		OPCODE(opAnimate),		// 96
		OPCODE(opJmpSeedRandom),// 97: Seeded random jump
		OPCODE(opDummy)			// 98: Get seeded export number (unused)
	};
#endif

	if (!_vm->isSaga2()) {
		_scriptOpsList = SAGA1ScriptOpcodes;
#ifdef ENABLE_SAGA2
	} else {
		_scriptOpsList = SAGA2ScriptOpcodes;
#endif
	}
}


void Script::opDup(SCRIPTOP_PARAMS) {
	thread->push(thread->stackTop());
}

void Script::opDrop(SCRIPTOP_PARAMS) {
	thread->pop();
}

void Script::opZero(SCRIPTOP_PARAMS) {
	thread->push(0);
}

void Script::opOne(SCRIPTOP_PARAMS) {
	thread->push(1);
}

void Script::opConstInt(SCRIPTOP_PARAMS) {
	thread->push(scriptS->readSint16LE());
}

void Script::opStrLit(SCRIPTOP_PARAMS) {
	thread->push(scriptS->readSint16LE());
}

void Script::opGetFlag(SCRIPTOP_PARAMS) {
	byte *addr = thread->baseAddress(scriptS->readByte());
	int16 iparam1 = scriptS->readSint16LE();
	addr += (iparam1 >> 3);
	iparam1 = (1 << (iparam1 & 7));
	thread->push((*addr) & iparam1 ? 1 : 0);
}

void Script::opGetByte(SCRIPTOP_PARAMS) {
	// SAGA 2 opcode
	// TODO
	warning("opGetByte");
}

void Script::opGetInt(SCRIPTOP_PARAMS) {
	byte mode = scriptS->readByte();
	byte *addr = thread->baseAddress(mode);
	int16 iparam1 = scriptS->readSint16LE();
	addr += iparam1;
	thread->push(readUint16(addr, mode));
	debug(8, "0x%X", readUint16(addr, mode));
}

void Script::opPutFlag(SCRIPTOP_PARAMS) {
	byte *addr = thread->baseAddress(scriptS->readByte());
	int16 iparam1 = scriptS->readSint16LE();
	addr += (iparam1 >> 3);
	iparam1 = (1 << (iparam1 & 7));
	if (thread->stackTop()) {
		*addr |= iparam1;
	} else {
		*addr &= ~iparam1;
	}
}

void Script::opPutByte(SCRIPTOP_PARAMS) {
	// SAGA 2 opcode
	// TODO
	warning("opPutByte");
}

void Script::opPutInt(SCRIPTOP_PARAMS) {
	byte mode = scriptS->readByte();
	byte *addr = thread->baseAddress(mode);
	int16 iparam1 = scriptS->readSint16LE();
	addr += iparam1;
	writeUint16(addr, thread->stackTop(), mode);
}

void Script::opPutFlagV(SCRIPTOP_PARAMS) {
	byte *addr = thread->baseAddress(scriptS->readByte());
	int16 iparam1 = scriptS->readSint16LE();
	addr += (iparam1 >> 3);
	iparam1 = (1 << (iparam1 & 7));
	if (thread->pop()) {
		*addr |= iparam1;
	} else {
		*addr &= ~iparam1;
	}
}

void Script::opPutByteV(SCRIPTOP_PARAMS) {
	// SAGA 2 opcode
	// TODO
	warning("opPutByteV");
}

void Script::opPutIntV(SCRIPTOP_PARAMS) {
	byte mode = scriptS->readByte();
	byte *addr = thread->baseAddress(mode);
	int16 iparam1 = scriptS->readSint16LE();
	addr += iparam1;
	writeUint16(addr, thread->pop(), mode);
}

void Script::opCall(SCRIPTOP_PARAMS) {
	byte argumentsCount = scriptS->readByte();
	int16 iparam1 = scriptS->readByte();
	if (iparam1 != kAddressModule) {
		error("Script::runThread iparam1 != kAddressModule");
	}
	byte *addr = thread->baseAddress(iparam1);
	iparam1 = scriptS->readSint16LE();
	addr += iparam1;
	thread->push(argumentsCount);

	// NOTE: The original pushes the program
	// counter as a pointer here. But I don't think
	// we will have to do that.
	thread->push(scriptS->pos());
	// NOTE2: program counter is 32bit - so we should "emulate" it size - because kAddressStack relies on it
	thread->push(0);
	thread->_instructionOffset = iparam1;
}

void Script::opCallNear(SCRIPTOP_PARAMS) {
	// SAGA 2 opcode
	// TODO
	warning("opCallNear");
}

void Script::opCallFar(SCRIPTOP_PARAMS) {
	// SAGA 2 opcode
	// TODO
	warning("opCallFar");
}

void Script::opCcall(SCRIPTOP_PARAMS) {
	byte argumentsCount = scriptS->readByte();
	uint16 functionNumber = scriptS->readUint16LE();
	if (functionNumber >= ((_vm->getGameId() == GID_IHNM) ?
						   IHNM_SCRIPT_FUNCTION_MAX : ITE_SCRIPT_FUNCTION_MAX)) {
		error("Script::opCcall() Invalid script function number (%d)", functionNumber);
	}

	debug(2, "Calling #%d %s argCount=%i", functionNumber, _scriptFunctionsList[functionNumber].scriptFunctionName, argumentsCount);
	ScriptFunctionType scriptFunction = _scriptFunctionsList[functionNumber].scriptFunction;
	uint16 checkStackTopIndex = thread->_stackTopIndex + argumentsCount;
	(this->*scriptFunction)(thread, argumentsCount, stopParsing);
	if (stopParsing)
		return;

	if (scriptFunction == &Saga::Script::sfScriptGotoScene) {
		stopParsing = true; // cause abortAllThreads called and _this_ thread destroyed
		breakOut = true;
		return;
	}

#ifdef ENABLE_IHNM
	if (scriptFunction == &Saga::Script::sfVsetTrack) {
		stopParsing = true;
		breakOut = true;
		return;		// cause abortAllThreads called and _this_ thread destroyed
	}
#endif

	thread->_stackTopIndex = checkStackTopIndex;

	thread->push(thread->_returnValue);		// return value

	if (thread->_flags & kTFlagAsleep)
		breakOut = true;	// break out of loop!
}

void Script::opCallMember(SCRIPTOP_PARAMS) {
	// SAGA 2 opcode
	// TODO
	warning("opCallMember");
}

void Script::opCallMemberV(SCRIPTOP_PARAMS) {
	// SAGA 2 opcode
	// TODO
	warning("opCallMemberV");
}

void Script::opCcallV(SCRIPTOP_PARAMS) {
	byte argumentsCount = scriptS->readByte();
	uint16 functionNumber = scriptS->readUint16LE();
	if (functionNumber >= ((_vm->getGameId() == GID_IHNM) ?
						   IHNM_SCRIPT_FUNCTION_MAX : ITE_SCRIPT_FUNCTION_MAX)) {
		error("Script::opCcallV() Invalid script function number (%d)", functionNumber);
	}

	debug(2, "Calling #%d %s argCount=%i", functionNumber, _scriptFunctionsList[functionNumber].scriptFunctionName, argumentsCount);
	ScriptFunctionType scriptFunction = _scriptFunctionsList[functionNumber].scriptFunction;
	uint16 checkStackTopIndex = thread->_stackTopIndex + argumentsCount;
	(this->*scriptFunction)(thread, argumentsCount, stopParsing);
	if (stopParsing)
		return;

	if (scriptFunction == &Saga::Script::sfScriptGotoScene) {
		stopParsing = true;
		breakOut = true;
		return;		// cause abortAllThreads called and _this_ thread destroyed
	}

#ifdef ENABLE_IHNM
	if (scriptFunction == &Saga::Script::sfVsetTrack) {
		stopParsing = true;
		breakOut = true;
		return;		// cause abortAllThreads called and _this_ thread destroyed
	}
#endif

	thread->_stackTopIndex = checkStackTopIndex;

	if (thread->_flags & kTFlagAsleep)
		breakOut = true;	// break out of loop!
}

void Script::opEnter(SCRIPTOP_PARAMS) {
	thread->push(thread->_frameIndex);
	thread->_frameIndex = thread->_stackTopIndex;
	thread->_stackTopIndex -= (scriptS->readSint16LE() / 2);
}

void Script::opReturn(SCRIPTOP_PARAMS) {
	thread->_returnValue = thread->pop();		// return value

	thread->_stackTopIndex = thread->_frameIndex;
	thread->_frameIndex = thread->pop();
	if (thread->pushedSize() == 0) {
		thread->_flags |= kTFlagFinished;
		stopParsing = true;
		breakOut = true;
		return;
	} else {
		thread->pop(); //cause it 0
		thread->_instructionOffset = thread->pop();

		// Pop all the call parameters off the stack
		int16 iparam1 = thread->pop();
		while (iparam1--) {
			thread->pop();
		}

		thread->push(thread->_returnValue);
	}
}

void Script::opReturnV(SCRIPTOP_PARAMS) {
	thread->_stackTopIndex = thread->_frameIndex;
	thread->_frameIndex = thread->pop();
	if (thread->pushedSize() == 0) {
		thread->_flags |= kTFlagFinished;
		stopParsing = true;
		breakOut = true;
		return;
	} else {
		thread->pop(); //cause it 0
		thread->_instructionOffset = thread->pop();

		// Pop all the call parameters off the stack
		int16 iparam1 = thread->pop();
		while (iparam1--) {
			thread->pop();
		}
	}
}

void Script::opJmp(SCRIPTOP_PARAMS) {
	thread->_instructionOffset = scriptS->readUint16LE();
}

void Script::opJmpTrueV(SCRIPTOP_PARAMS) {
	uint16 jmpOffset1 = scriptS->readUint16LE();
	if (thread->pop())
		thread->_instructionOffset = jmpOffset1;
}

void Script::opJmpFalseV(SCRIPTOP_PARAMS) {
	uint16 jmpOffset1 = scriptS->readUint16LE();
	if (!thread->pop())
		thread->_instructionOffset = jmpOffset1;
}

void Script::opJmpTrue(SCRIPTOP_PARAMS) {
	uint16 jmpOffset1 = scriptS->readUint16LE();
	if (thread->stackTop())
		thread->_instructionOffset = jmpOffset1;
}

void Script::opJmpFalse(SCRIPTOP_PARAMS) {
	uint16 jmpOffset1 = scriptS->readUint16LE();
	if (!thread->stackTop())
		thread->_instructionOffset = jmpOffset1;
}

void Script::opJmpSwitch(SCRIPTOP_PARAMS) {
	int16 iparam1 = scriptS->readSint16LE();
	int16 iparam2 = thread->pop();
	int16 iparam3;

	while (iparam1--) {
		iparam3 = scriptS->readUint16LE();
		thread->_instructionOffset = scriptS->readUint16LE();
		if (iparam3 == iparam2)
			break;
	}

	if (iparam1 < 0)
		thread->_instructionOffset = scriptS->readUint16LE();
}

void Script::opJmpRandom(SCRIPTOP_PARAMS) {
	// Supposedly the number of possible branches.
	// The original interpreter ignores it.
	scriptS->readUint16LE();
	int16 iparam1 = scriptS->readSint16LE();
	iparam1 = _vm->_rnd.getRandomNumber(iparam1 - 1);
	int16 iparam2;

	while (1) {
		iparam2 = scriptS->readSint16LE();
		thread->_instructionOffset = scriptS->readUint16LE();

		iparam1 -= iparam2;
		if (iparam1 < 0)
			break;
	}
}

void Script::opNegate(SCRIPTOP_PARAMS) {
	thread->push(-thread->pop());
}

void Script::opNot(SCRIPTOP_PARAMS) {
	thread->push(!thread->pop());
}

void Script::opCompl(SCRIPTOP_PARAMS) {
	thread->push(~thread->pop());
}

void Script::opIncV(SCRIPTOP_PARAMS) {
	byte mode = scriptS->readByte();
	byte *addr = thread->baseAddress(mode);
	int16 iparam1 = scriptS->readSint16LE();
	addr += iparam1;
	iparam1 = readUint16(addr, mode);
	writeUint16(addr, iparam1 + 1, mode);
}

void Script::opDecV(SCRIPTOP_PARAMS) {
	byte mode = scriptS->readByte();
	byte *addr = thread->baseAddress(mode);
	int16 iparam1 = scriptS->readSint16LE();
	addr += iparam1;
	iparam1 = readUint16(addr, mode);
	writeUint16(addr, iparam1 - 1, mode);
}

void Script::opPostInc(SCRIPTOP_PARAMS) {
	byte mode = scriptS->readByte();
	byte *addr = thread->baseAddress(mode);
	int16 iparam1 = scriptS->readSint16LE();
	addr += iparam1;
	iparam1 = readUint16(addr, mode);
	thread->push(iparam1);
	writeUint16(addr, iparam1 + 1, mode);
}

void Script::opPostDec(SCRIPTOP_PARAMS) {
	byte mode = scriptS->readByte();
	byte *addr = thread->baseAddress(mode);
	int16 iparam1 = scriptS->readSint16LE();
	addr += iparam1;
	iparam1 = readUint16(addr, mode);
	thread->push(iparam1);
	writeUint16(addr, iparam1 - 1, mode);
}

void Script::opAdd(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(iparam1 + iparam2);
}

void Script::opSub(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(iparam1 - iparam2);
}

void Script::opMul(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(iparam1 * iparam2);
}

void Script::opDiv(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(iparam1 / iparam2);
}

void Script::opMod(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(iparam1 % iparam2);
}

void Script::opEq(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push((iparam1 == iparam2) ? 1 : 0);
}

void Script::opNe(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push((iparam1 != iparam2) ? 1 : 0);
}

void Script::opGt(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push((iparam1 > iparam2) ? 1 : 0);
}

void Script::opLt(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push((iparam1 < iparam2) ? 1 : 0);
}

void Script::opGe(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push((iparam1 >= iparam2) ? 1 : 0);
}

void Script::opLe(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push((iparam1 <= iparam2) ? 1 : 0);
}

void Script::opRsh(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(iparam1 >> iparam2);
}

void Script::opLsh(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(iparam1 << iparam2);
}

void Script::opAnd(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(iparam1 & iparam2);
}

void Script::opOr(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(iparam1 | iparam2);
}

void Script::opXor(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(iparam1 ^ iparam2);
}

void Script::opLAnd(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push((iparam1 && iparam2) ? 1 : 0);
}

void Script::opLOr(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push((iparam1 || iparam2) ? 1 : 0);
}

void Script::opLXor(SCRIPTOP_PARAMS) {
	int16 iparam2 = thread->pop();
	int16 iparam1 = thread->pop();
	thread->push(((iparam1 && !iparam2) || (!iparam1 && iparam2)) ? 1 : 0);
}

void Script::opSpeak(SCRIPTOP_PARAMS) {
	if (_vm->_actor->isSpeaking()) {
		thread->wait(kWaitTypeSpeech);
		stopParsing = true;
		breakOut = false;
		return;
	}

	int stringsCount = scriptS->readByte();
	uint16 actorId = scriptS->readUint16LE();
	uint16 speechFlags = scriptS->readByte();
	int sampleResourceId = -1;
	int16 first;
	const char *strings[ACTOR_SPEECH_STRING_MAX];

	scriptS->readUint16LE(); // x,y skip

	if (stringsCount == 0)
		error("opSpeak stringsCount == 0");

	if (stringsCount > ACTOR_SPEECH_STRING_MAX)
		error("opSpeak stringsCount=0x%X exceed ACTOR_SPEECH_STRING_MAX", stringsCount);

	int16 iparam1 = first = thread->stackTop();
	for (int i = 0; i < stringsCount; i++) {
		iparam1 = thread->pop();
		strings[i] = thread->_strings->getString(iparam1);
	}

	// now data contains last string index

#if 0
	if (_vm->getFeatures() & GF_OLD_ITE_DOS) { // special ITE dos
		if ((_vm->_scene->currentSceneNumber() == ITE_DEFAULT_SCENE) &&
			(iparam1 >= 288) && (iparam1 <= (RID_SCENE1_VOICE_END - RID_SCENE1_VOICE_START + 288))) {
			sampleResourceId = RID_SCENE1_VOICE_START + iparam1 - 288;
		}
	} else {
#endif
		if (thread->_voiceLUT->voicesCount > first)
			sampleResourceId = thread->_voiceLUT->voices[first];
#if 0
	}
#endif

	if (sampleResourceId < 0 || sampleResourceId > 4000)
		sampleResourceId = -1;

	if (_vm->getGameId() == GID_ITE && !sampleResourceId)
		sampleResourceId = -1;

	_vm->_actor->actorSpeech(actorId, strings, stringsCount, sampleResourceId, speechFlags);

	if (!(speechFlags & kSpeakAsync)) {
		thread->wait(kWaitTypeSpeech);
	}
}

void Script::opDialogBegin(SCRIPTOP_PARAMS) {
	if (_conversingThread) {
		thread->wait(kWaitTypeDialogBegin);
		stopParsing = true;
		breakOut = false;
		return;
	}
	_conversingThread = thread;
	_vm->_interface->converseClear();
}

void Script::opDialogEnd(SCRIPTOP_PARAMS) {
	if (thread == _conversingThread) {
		_vm->_interface->activate();
		_vm->_interface->setMode(kPanelConverse);
		thread->wait(kWaitTypeDialogEnd);
		stopParsing = true;
		breakOut = false;
		return;
	}
}

void Script::opReply(SCRIPTOP_PARAMS) {
	const char *str;
	byte replyNum = scriptS->readByte();
	byte flags = scriptS->readByte();
	int16 iparam1 = 0;
	int strID = thread->pop();

	if (flags & kReplyOnce) {
		iparam1 = scriptS->readSint16LE();
		byte *addr = thread->_staticBase + (iparam1 >> 3);
		if (*addr & (1 << (iparam1 & 7))) {
			return;
		}
	}

	str = thread->_strings->getString(strID);
	if (_vm->_interface->converseAddText(str, strID, replyNum, flags, iparam1))
		warning("Error adding ConverseText (%s, %d, %d, %d)", str, replyNum, flags, iparam1);
}

void Script::opAnimate(SCRIPTOP_PARAMS) {
	scriptS->readUint16LE();
	scriptS->readUint16LE();
	thread->_instructionOffset += scriptS->readByte();
}

void Script::opJmpSeedRandom(SCRIPTOP_PARAMS) {
	// SAGA 2 opcode
	// TODO
	warning("opJmpSeedRandom");
}

void Script::loadModule(int scriptModuleNumber) {
	byte *resourcePointer;
	size_t resourceLength;

	// Validate script number
	if ((scriptModuleNumber < 0) || (scriptModuleNumber >= _modulesCount)) {
		error("Script::loadScript() Invalid script module number");
	}

	if (_modules[scriptModuleNumber].loaded) {
		return;
	}

	// Initialize script data structure
	debug(3, "Loading script module #%d", scriptModuleNumber);

	_vm->_resource->loadResource(_scriptContext, _modules[scriptModuleNumber].scriptResourceId, resourcePointer, resourceLength);

	loadModuleBase(_modules[scriptModuleNumber], resourcePointer, resourceLength);
	free(resourcePointer);

	_vm->_resource->loadResource(_scriptContext, _modules[scriptModuleNumber].stringsResourceId, resourcePointer, resourceLength);

	_vm->loadStrings(_modules[scriptModuleNumber].strings, resourcePointer, resourceLength);
	free(resourcePointer);

	if (_modules[scriptModuleNumber].voicesResourceId > 0) {
		_vm->_resource->loadResource(_scriptContext, _modules[scriptModuleNumber].voicesResourceId, resourcePointer, resourceLength);

		loadVoiceLUT(_modules[scriptModuleNumber].voiceLUT, resourcePointer, resourceLength);
		free(resourcePointer);
	}

	_modules[scriptModuleNumber].staticOffset = _staticSize;
	_staticSize += _modules[scriptModuleNumber].staticSize;
	if (_staticSize > _commonBufferSize) {
		error("Script::loadModule() _staticSize > _commonBufferSize");
	}
	_modules[scriptModuleNumber].loaded = true;
}

void Script::freeModules() {
	int i;
	for (i = 0; i < _modulesCount; i++) {
		if (_modules[i].loaded) {
			_modules[i].freeMem();
			_modules[i].loaded = false;
		}
	}
	_staticSize = 0;
}

void Script::loadModuleBase(ModuleData &module, const byte *resourcePointer, size_t resourceLength) {
	int i;

	debug(3, "Loading module base...");

	module.moduleBase = (byte*)malloc(resourceLength);
	module.moduleBaseSize = resourceLength;

	memcpy(module.moduleBase, resourcePointer, resourceLength);

	MemoryReadStreamEndian scriptS(module.moduleBase, module.moduleBaseSize, _scriptContext->isBigEndian());

	module.entryPointsCount = scriptS.readUint16();
	scriptS.readUint16(); //skip
	module.entryPointsTableOffset = scriptS.readUint16();
	scriptS.readUint16(); //skip

	if ((module.moduleBaseSize - module.entryPointsTableOffset) < (module.entryPointsCount * SCRIPT_TBLENTRY_LEN)) {
		error("Script::loadModuleBase() Invalid table offset");
	}

	if (module.entryPointsCount > SCRIPT_MAX) {
		error("Script::loadModuleBase()Script limit exceeded");
	}

	module.entryPoints = (EntryPoint *)malloc(module.entryPointsCount * sizeof(*module.entryPoints));
	if (module.entryPoints == NULL) {
		memoryError("Script::loadModuleBase");
	}

	// Read in the entrypoint table

	module.staticSize = scriptS.readUint16();
	while (scriptS.pos() < module.entryPointsTableOffset)
		scriptS.readByte();

	for (i = 0; i < module.entryPointsCount; i++) {
		// First uint16 is the offset of the entrypoint name from the start
		// of the bytecode resource, second uint16 is the offset of the
		// bytecode itself for said entrypoint
		module.entryPoints[i].nameOffset = scriptS.readUint16();
		module.entryPoints[i].offset = scriptS.readUint16();

		// Perform a simple range check on offset values
		if ((module.entryPoints[i].nameOffset >= module.moduleBaseSize) || (module.entryPoints[i].offset >= module.moduleBaseSize)) {
			error("Script::loadModuleBase() Invalid offset encountered in script entrypoint table");
		}
	}
}

void Script::loadVoiceLUT(VoiceLUT &voiceLUT, const byte *resourcePointer, size_t resourceLength) {
	uint16 i;

	voiceLUT.voicesCount = resourceLength / 2;

	voiceLUT.voices = (uint16 *)malloc(voiceLUT.voicesCount * sizeof(*voiceLUT.voices));
	if (voiceLUT.voices == NULL) {
		error("Script::loadVoiceLUT() not enough memory");
	}

	MemoryReadStreamEndian scriptS(resourcePointer, resourceLength, _scriptContext->isBigEndian());

	for (i = 0; i < voiceLUT.voicesCount; i++) {
		voiceLUT.voices[i] = scriptS.readUint16();
	}
}

// verb
void Script::showVerb(int statusColor) {
	const char *verbName;
	const char *object1Name;
	const char *object2Name;
	char statusString[STATUS_TEXT_LEN];

	if (_leftButtonVerb == getVerbType(kVerbNone)) {
		_vm->_interface->setStatusText("");
		return;
	}

	if (_vm->getGameId() == GID_ITE)
		verbName = _mainStrings.getString(_leftButtonVerb - 1);
	else
		verbName = _mainStrings.getString(_leftButtonVerb + 1);

	if (objectTypeId(_currentObject[0]) == kGameObjectNone) {
		_vm->_interface->setStatusText(verbName, statusColor);
		return;
	}

	object1Name = _vm->getObjectName(_currentObject[0]);

	if (!_secondObjectNeeded) {
		snprintf(statusString, STATUS_TEXT_LEN, "%s %s", verbName, object1Name);
		_vm->_interface->setStatusText(statusString, statusColor);
		return;
	}


	if (objectTypeId(_currentObject[1]) != kGameObjectNone) {
		object2Name = _vm->getObjectName(_currentObject[1]);
	} else {
		object2Name = "";
	}

	if (_leftButtonVerb == getVerbType(kVerbGive)) {
		snprintf(statusString, STATUS_TEXT_LEN, _vm->getTextString(kTextGiveTo), object1Name, object2Name);
		_vm->_interface->setStatusText(statusString, statusColor);
	} else {
		if (_leftButtonVerb == getVerbType(kVerbUse)) {
			snprintf(statusString, STATUS_TEXT_LEN, _vm->getTextString(kTextUseWidth), object1Name, object2Name);
			_vm->_interface->setStatusText(statusString, statusColor);
		} else {
			snprintf(statusString, STATUS_TEXT_LEN, "%s %s", verbName, object1Name);
			_vm->_interface->setStatusText(statusString, statusColor);
		}
	}
}

int Script::getVerbType(VerbTypes verbType) {
	if (_vm->getGameId() == GID_ITE) {
		switch (verbType) {
		case kVerbNone:
			return kVerbITENone;
		case kVerbWalkTo:
			return kVerbITEWalkTo;
		case kVerbGive:
			return kVerbITEGive;
		case kVerbUse:
			return kVerbITEUse;
		case kVerbEnter:
			return kVerbITEEnter;
		case kVerbLookAt:
			return kVerbITELookAt;
		case kVerbPickUp:
			return kVerbITEPickUp;
		case kVerbOpen:
			return kVerbITEOpen;
		case kVerbClose:
			return kVerbITEClose;
		case kVerbTalkTo:
			return kVerbITETalkTo;
		case kVerbWalkOnly:
			return kVerbITEWalkOnly;
		case kVerbLookOnly:
			return kVerbITELookOnly;
		case kVerbOptions:
			return kVerbITEOptions;
		}
#ifdef ENABLE_IHNM
	} else if (_vm->getGameId() == GID_IHNM) {
		switch (verbType) {
		case kVerbNone:
			return kVerbIHNMNone;
		case kVerbWalkTo:
			return kVerbIHNMWalk;
		case kVerbLookAt:
			return kVerbIHNMLookAt;
		case kVerbPickUp:
			return kVerbIHNMTake;
		case kVerbUse:
			return kVerbIHNMUse;
		case kVerbTalkTo:
			return kVerbIHNMTalkTo;
		case kVerbOpen:
			return kVerbIHNMSwallow;
		case kVerbGive:
			return kVerbIHNMGive;
		case kVerbClose:
			return kVerbIHNMPush;
		case kVerbEnter:
			return kVerbIHNMEnter;
		case kVerbWalkOnly:
			return kVerbIHNMWalkOnly;
		case kVerbLookOnly:
			return kVerbIHNMLookOnly;
		case kVerbOptions:
			return kVerbIHNMOptions;
		}
#endif
	}
	error("Script::getVerbType() unknown verb type %d", verbType);
}

void Script::setVerb(int verb) {
	_pendingObject[0] = ID_NOTHING;
	_currentObject[0] = ID_NOTHING;
	_pendingObject[1] = ID_NOTHING;
	_currentObject[1] = ID_NOTHING;
	_firstObjectSet = false;
	_secondObjectNeeded = false;

	// The pointer object will be updated again immediately. This way the
	// new verb will be applied to it. It's not exactly how the original
	// engine did it, but it appears to work.
	_pointerObject = ID_NOTHING;

	setLeftButtonVerb( verb );
	showVerb();
}

void Script::setLeftButtonVerb(int verb) {
	int		oldVerb = _currentVerb;

	_currentVerb = _leftButtonVerb = verb;

	if ((_currentVerb != oldVerb) && (_vm->_interface->getMode() == kPanelMain)){
			if (oldVerb > getVerbType(kVerbNone))
				_vm->_interface->setVerbState(oldVerb, 2);

			if (_currentVerb > getVerbType(kVerbNone))
				_vm->_interface->setVerbState(_currentVerb, 2);
	}
}

void Script::setRightButtonVerb(int verb) {
	int		oldVerb = _rightButtonVerb;

	_rightButtonVerb = verb;

	if ((_rightButtonVerb != oldVerb) && (_vm->_interface->getMode() == kPanelMain)){
		if (oldVerb > getVerbType(kVerbNone))
			_vm->_interface->setVerbState(oldVerb, 2);

		if (_rightButtonVerb > getVerbType(kVerbNone))
			_vm->_interface->setVerbState(_rightButtonVerb, 2);
	}
}

void Script::doVerb() {
	int scriptEntrypointNumber = 0;
	int scriptModuleNumber = 0;
	int objectType;
	Event event;
	const char *excuseText;
	int excuseSampleResourceId;
	const HitZone *hitZone;

	objectType = objectTypeId(_pendingObject[0]);

	if (_pendingVerb == getVerbType(kVerbGive)) {
		scriptEntrypointNumber = _vm->_actor->getObjectScriptEntrypointNumber(_pendingObject[1]);
		if (_vm->_actor->getObjectFlags(_pendingObject[1]) & (kFollower|kProtagonist|kExtended)) {
			scriptModuleNumber = 0;
		} else {
			scriptModuleNumber = _vm->_scene->getScriptModuleNumber();
		}
		// IHNM never sets scriptModuleNumber to 0
		if (_vm->getGameId() == GID_IHNM)
			scriptModuleNumber = _vm->_scene->getScriptModuleNumber();
	} else {
		if (_pendingVerb == getVerbType(kVerbUse)) {
			if ((objectTypeId(_pendingObject[1]) > kGameObjectNone) && (objectType < objectTypeId(_pendingObject[1]))) {
				SWAP(_pendingObject[0], _pendingObject[1]);
				objectType = objectTypeId(_pendingObject[0]);
			}
		}

		if (objectType == 0)
			return;
		else if (objectType == kGameObjectHitZone) {
			scriptModuleNumber = _vm->_scene->getScriptModuleNumber();
			hitZone = _vm->_scene->_objectMap->getHitZone(objectIdToIndex(_pendingObject[0]));

			if (hitZone == NULL)
				return;

			if ((hitZone->getFlags() & kHitZoneExit) == 0) {
				scriptEntrypointNumber = hitZone->getScriptNumber();
			}
		} else {
			if (objectType & (kGameObjectActor | kGameObjectObject)) {
				scriptEntrypointNumber = _vm->_actor->getObjectScriptEntrypointNumber(_pendingObject[0]);

				if ((objectType == kGameObjectActor) && !(_vm->_actor->getObjectFlags(_pendingObject[0]) & (kFollower|kProtagonist|kExtended))) {
					scriptModuleNumber = _vm->_scene->getScriptModuleNumber();
				} else {
					scriptModuleNumber = 0;
				}
				// IHNM never sets scriptModuleNumber to 0
				if (_vm->getGameId() == GID_IHNM)
					scriptModuleNumber = _vm->_scene->getScriptModuleNumber();
			}
		}
	}

	// WORKAROUND for a bug in the original game scripts of IHNM. Edna's script (actor 8197) is problematic, so
	// when the knife (object 16385) is used with her, the expected result is not correct. The first time that
	// the knife is used, Edna's heart is cut out (which is correct). But on subsequent use, the object's script
	// is buggy, therefore it's possible to talk to a dead Edna by using the knife on her, or to incorrectly get her
	// heart again, which remove's Gorrister's heart from the inventory. The solution is to disable the "use knife with
	// Edna" action altogether, because if the player wants to kill Edna, he can do that by talking to her and
	// choosing "[Cut out Edna's heart]", which works correctly. To disable this action, if the knife is used on Edna, we
	// change the action here to "use knife with the knife", which yields a better reply ("I'd just dull my knife").
	// Fixes bug #1826871 - "IHNM: Edna's got two hearts but loves to be on the hook"
	if (_vm->getGameId() == GID_IHNM && _pendingObject[0] == 16385 && _pendingObject[1] == 8197 && _pendingVerb == 4)
		_pendingObject[1] = 16385;

	// WORKAROUND for a bug in the original game scripts of IHNM. Gorrister's heart is not supposed to have a
	// "use" phrase attached to it (it's not used anywhere, it's only given), but when "used", an incorrect
	// reply is given to the player ("It's too narrow for me to pass", said when Gorrister tries to pick up the
	// heart without a rope). Therefore, for object number 16397 (Gorrister's heart), when the active verb is
	// "Use", set it to "Push", which gives a more appropriate reply ("What good will that do me?")
	if (_vm->getGameId() == GID_IHNM && _pendingObject[0] == 16397 && _pendingVerb == 4)
		_pendingVerb = 8;

	if (scriptEntrypointNumber > 0) {

		event.type = kEvTOneshot;
		event.code = kScriptEvent;
		event.op = kEventExecNonBlocking;
		event.time = 0;
		event.param = scriptModuleNumber;
		event.param2 = scriptEntrypointNumber;
		event.param3 = _pendingVerb;		// Action
		event.param4 = _pendingObject[0];	// Object
		event.param5 = _pendingObject[1];	// With Object
		event.param6 = (objectType == kGameObjectActor) ? _pendingObject[0] : ID_PROTAG;		// Actor
		_vm->_events->queue(&event);

	} else {
		// Show excuse text in ITE CD Versions
		if (_vm->getGameId() == GID_ITE) {
			_vm->getExcuseInfo(_pendingVerb, excuseText, excuseSampleResourceId);
			if (excuseText) {
				// In Floppy versions we don't have excuse texts
				if (_vm->getFeatures() & GF_ITE_FLOPPY)
					excuseSampleResourceId = -1;

				_vm->_actor->actorSpeech(ID_PROTAG, &excuseText, 1, excuseSampleResourceId, 0);
			}
		}
	}

	if ((_currentVerb == getVerbType(kVerbWalkTo)) || (_currentVerb == getVerbType(kVerbLookAt))) {
		_stickyVerb = _currentVerb;
	}

	_pendingVerb = getVerbType(kVerbNone);
	_currentObject[0] = _currentObject[1] = ID_NOTHING;
	setLeftButtonVerb(_stickyVerb);

	setPointerVerb();
}

void Script::setPointerVerb() {
	if (_vm->_interface->isActive()) {
		_pointerObject = ID_PROTAG;
		whichObject(_vm->mousePos());
	}
}

void Script::hitObject(bool leftButton) {
	int verb;
	verb = leftButton ? _leftButtonVerb : _rightButtonVerb;

	if (verb > getVerbType(kVerbNone)) {
		if (_firstObjectSet) {
			if (_secondObjectNeeded) {
				_pendingObject[0] = _currentObject[0];
				_pendingObject[1] = _currentObject[1];
				_pendingVerb = verb;

				_leftButtonVerb = verb;
				if (_pendingVerb > getVerbType(kVerbNone))
					showVerb(kITEColorBrightWhite);
				else
					showVerb();

				_secondObjectNeeded = false;
				_firstObjectSet = false;
				return;
			}
		} else {
			if (verb == getVerbType(kVerbGive)) {
				_secondObjectNeeded = true;
			} else {
				if (verb == getVerbType(kVerbUse)) {

					if (_currentObjectFlags[0] & kObjUseWith) {
						_secondObjectNeeded = true;
					}
				}
			}

			if (!_secondObjectNeeded) {
				_pendingObject[0] = _currentObject[0];
				_pendingObject[1] = ID_NOTHING;
				_pendingVerb = verb;

				_secondObjectNeeded = false;
				_firstObjectSet = false;
			} else {
				_firstObjectSet = true;
			}
		}

		_leftButtonVerb = verb;
		if (_pendingVerb > getVerbType(kVerbNone))
			showVerb(kITEColorBrightWhite);
		else
			showVerb();
	}

}

void Script::playfieldClick(const Point& mousePoint, bool leftButton) {
	Location pickLocation;
	const HitZone *hitZone;
	Point specialPoint;

	_vm->incrementMouseClickCount();
	_vm->_actor->abortSpeech();

	if ((_vm->_actor->_protagonist->_currentAction != kActionWait) &&
		(_vm->_actor->_protagonist->_currentAction != kActionFreeze) &&
		(_vm->_actor->_protagonist->_currentAction != kActionWalkToLink) &&
		(_vm->_actor->_protagonist->_currentAction != kActionWalkToPoint)) {
		return;
	}
	if (_pendingVerb > getVerbType(kVerbNone)) {
		setLeftButtonVerb(getVerbType(kVerbWalkTo));
	}

	if (_pointerObject != ID_NOTHING) {
		hitObject( leftButton );
	} else {
		_pendingObject[0] = ID_NOTHING;
		_pendingObject[1] = ID_NOTHING;
		_pendingVerb = getVerbType(kVerbWalkTo);
	}


	// tiled stuff
	if (_vm->_scene->getFlags() & kSceneFlagISO) {
		_vm->_isoMap->screenPointToTileCoords(mousePoint, pickLocation);
	} else {
		pickLocation.fromScreenPoint(mousePoint);
	}


	hitZone = NULL;

	if (objectTypeId(_pendingObject[0]) == kGameObjectHitZone) {
		 hitZone = _vm->_scene->_objectMap->getHitZone(objectIdToIndex(_pendingObject[0]));
	} else {
		if ((_pendingVerb == getVerbType(kVerbUse)) && (objectTypeId(_pendingObject[1]) == kGameObjectHitZone)) {
			hitZone = _vm->_scene->_objectMap->getHitZone(objectIdToIndex(_pendingObject[1]));
		}
	}

	if (hitZone != NULL) {
		if (_vm->getGameId() == GID_ITE) {
			if (hitZone->getFlags() & kHitZoneNoWalk) {
				_vm->_actor->actorFaceTowardsPoint(ID_PROTAG, pickLocation);
				doVerb();
				return;
			}
		} else {
			if (_vm->getGameId() == GID_IHNM) {
				if ((hitZone->getFlags() & kHitZoneNoWalk) && (_pendingVerb != getVerbType(kVerbWalkTo))) {
					doVerb();
					return;
				}
			}
		}

		if (hitZone->getFlags() & kHitZoneProject) {
			if (!hitZone->getSpecialPoint(specialPoint)) {
				// Original behaved this way and this prevents from crash
				// at ruins. See bug #1257459
				specialPoint.x = specialPoint.y = 0;
			}

			// tiled stuff
			if (_vm->_scene->getFlags() & kSceneFlagISO) {
				pickLocation.u() = specialPoint.x;
				pickLocation.v() = specialPoint.y;
				pickLocation.z = _vm->_actor->_protagonist->_location.z;
			} else {
				pickLocation.fromScreenPoint(specialPoint);
			}
		}
	}

	if (_vm->getGameId() == GID_ITE) {
		if ((_pendingVerb == getVerbType(kVerbWalkTo)) ||
			(_pendingVerb == getVerbType(kVerbPickUp)) ||
			(_pendingVerb == getVerbType(kVerbOpen)) ||
			(_pendingVerb == getVerbType(kVerbClose)) ||
			(_pendingVerb == getVerbType(kVerbUse))) {
				_vm->_actor->actorWalkTo(ID_PROTAG, pickLocation);
		} else {
			if (_pendingVerb == getVerbType(kVerbLookAt)) {
				if (objectTypeId(_pendingObject[0]) != kGameObjectActor ) {
					_vm->_actor->actorWalkTo(ID_PROTAG, pickLocation);
				} else {
					doVerb();
				}
			} else {
				if ((_pendingVerb == getVerbType(kVerbTalkTo)) ||
					(_pendingVerb == getVerbType(kVerbGive))) {
						doVerb();
				}
			}
		}
	}

#ifdef ENABLE_IHNM
	if (_vm->getGameId() == GID_IHNM) {

		if ((_pendingVerb == getVerbType(kVerbWalkTo)) ||
			(_pendingVerb == getVerbType(kVerbPickUp)) ||
			(_pendingVerb == getVerbType(kVerbOpen)) ||
			(_pendingVerb == getVerbType(kVerbClose)) ||
			(_pendingVerb == getVerbType(kVerbUse))) {
				_vm->_actor->actorWalkTo(ID_PROTAG, pickLocation);

				// Auto-use no-walk hitzones in IHNM, needed for Benny's chapter
				if (_pendingVerb == getVerbType(kVerbWalkTo) &&
					hitZone != NULL && (hitZone->getFlags() & kHitZoneNoWalk)) {
					_pendingVerb = getVerbType(kVerbUse);
					if (objectTypeId(_pendingObject[0]) == kGameObjectActor) {
						_vm->_actor->actorFaceTowardsObject(ID_PROTAG, _pendingObject[0]);
						doVerb();
					}
				}

				// Auto-use hitzone with id 24576 (the exit to the left) in screens 16 - 19
				// (screens with Gorrister's heart) in IHNM. For some reason, this zone does
				// not have a corresponding action zone, so we auto-use it here, like the exits
				// in Benny's chapter
				if (_vm->_scene->currentChapterNumber() == 1 &&
					_vm->_scene->currentSceneNumber() >= 16 &&
					_vm->_scene->currentSceneNumber() <= 19 &&
					_pendingVerb == getVerbType(kVerbWalkTo) &&
					hitZone != NULL && hitZone->getHitZoneId() == 24576) {
					_pendingVerb = getVerbType(kVerbUse);
					if (objectTypeId(_pendingObject[0]) == kGameObjectActor) {
						_vm->_actor->actorFaceTowardsObject(ID_PROTAG, _pendingObject[0]);
						doVerb();
					}
				}

		} else {
			if (_pendingVerb == getVerbType(kVerbLookAt)) {
				if (objectTypeId(_pendingObject[0]) != kGameObjectActor) {
					_vm->_actor->actorWalkTo(ID_PROTAG, pickLocation);
				} else {
					_vm->_actor->actorFaceTowardsObject(ID_PROTAG, _pendingObject[0]);
					doVerb();
				}
			} else {
				if ((_pendingVerb == getVerbType(kVerbTalkTo)) ||
					(_pendingVerb == getVerbType(kVerbGive))) {
						doVerb();
				}
			}
		}
	}
#endif

}

void Script::whichObject(const Point& mousePoint) {
	uint16 objectId;
	int16 objectFlags;
	int newRightButtonVerb;
	uint16 newObjectId;
	ActorData *actor;
	ObjectData *obj;
	Point pickPoint;
	Location pickLocation;
	int hitZoneIndex;
	const HitZone * hitZone;
	PanelButton * panelButton;

	objectId = ID_NOTHING;
	objectFlags = 0;
	_leftButtonVerb = _currentVerb;
	newRightButtonVerb = getVerbType(kVerbNone);

	// _protagonist can be null while loading a game from the command line
	if (_vm->_actor->_protagonist == NULL)
		return;

	if (_vm->_actor->_protagonist->_currentAction != kActionWalkDir) {
		if (_vm->_scene->getHeight() >= mousePoint.y) {
			newObjectId = _vm->_actor->hitTest(mousePoint, true);

			if (newObjectId != ID_NOTHING) {
				if (objectTypeId(newObjectId) == kGameObjectObject) {
					objectId = newObjectId;
					objectFlags = 0;
					newRightButtonVerb = getVerbType(kVerbLookAt);

					if ((_currentVerb == getVerbType(kVerbTalkTo)) || ((_currentVerb == getVerbType(kVerbGive)) && _firstObjectSet)) {
						objectId = ID_NOTHING;
						newObjectId = ID_NOTHING;
					}
				} else {
					actor = _vm->_actor->getActor(newObjectId);
					objectId = newObjectId;
					if (_vm->getGameId() == GID_ITE)
						objectFlags = kObjUseWith;
					// Note: for IHNM, the default right button action is "Look at" for actors,
					// but "Talk to" makes much more sense
					newRightButtonVerb = getVerbType(kVerbTalkTo);
					// Slight hack because of the above change: the jukebox in Gorrister's chapter
					// is an actor, so change the right button action to "Look at"
					if (_vm->getGameId() == GID_IHNM && objectId == 8199)
						newRightButtonVerb = getVerbType(kVerbLookAt);

					if ((_currentVerb == getVerbType(kVerbPickUp)) ||
						(_currentVerb == getVerbType(kVerbOpen)) ||
						(_currentVerb == getVerbType(kVerbClose)) ||
						((_currentVerb == getVerbType(kVerbGive)) && !_firstObjectSet) ||
						((_currentVerb == getVerbType(kVerbUse)) && !(actor->_flags & kFollower))) {
							if (_vm->getGameId() == GID_ITE) {
								objectId = ID_NOTHING;
								newObjectId = ID_NOTHING;
							}
						}
				}
			}

			if (newObjectId == ID_NOTHING) {

				pickPoint = mousePoint;

				if (_vm->_scene->getFlags() & kSceneFlagISO) {
					pickPoint.y -= _vm->_actor->_protagonist->_location.z;
					_vm->_isoMap->screenPointToTileCoords(pickPoint, pickLocation);
					pickLocation.toScreenPointUV(pickPoint);
				}

				hitZoneIndex = _vm->_scene->_objectMap->hitTest(pickPoint);

				// WORKAROUND for an incorrect hitzone which exists in IHNM
				// In Gorrister's chapter, in the toilet screen, the hitzone of the exit is
				// placed over the place where Gorrister sits to examine the graffiti on the wall
				// to the left, which makes him exit the screen when the graffiti is examined.
				// We effectively change the left side of the hitzone here so that it starts from
				// pixel 301 onwards. The same workaround is applied in Actor::handleActions
				if (_vm->getGameId() == GID_IHNM) {
					if (_vm->_scene->currentChapterNumber() == 1 && _vm->_scene->currentSceneNumber() == 22)
						if (hitZoneIndex == 8 && pickPoint.x <= 300)
							hitZoneIndex = -1;
				}

				if ((hitZoneIndex != -1)) {
					hitZone = _vm->_scene->_objectMap->getHitZone(hitZoneIndex);
					objectId = hitZone->getHitZoneId();
					objectFlags = 0;
					newRightButtonVerb = hitZone->getRightButtonVerb() & 0x7f;

					// WORKAROUND for a problematic object in IHNM
					// In the freezer room, the key that drops is made of a hitzone which
					// contains the key object itself. We change the object ID that the
					// hitzone contains (object ID 24578 - "The key") to the ID of the key
					// object itself (object ID 16402 - "Edna's key"), as the user can keep
					// hovering the cursor to both items, but can only pick up one
					if (_vm->getGameId() == GID_IHNM) {
						if (_vm->_scene->currentChapterNumber() == 1 && _vm->_scene->currentSceneNumber() == 24) {
							if (objectId == 24578)
								objectId = 16402;
						}
					}

					if (_vm->getGameId() == GID_ITE) {

						if (newRightButtonVerb == getVerbType(kVerbWalkOnly)) {
							if (_firstObjectSet) {
								objectId = ID_NOTHING;
							} else {
								newRightButtonVerb = _leftButtonVerb = getVerbType(kVerbWalkTo);
							}
						} else {
							if (newRightButtonVerb == getVerbType(kVerbLookOnly)) {
								if (_firstObjectSet) {
									objectId = ID_NOTHING;
								} else {
									newRightButtonVerb = _leftButtonVerb = getVerbType(kVerbLookAt);
								}
							}
						}

						if (newRightButtonVerb >= getVerbType(kVerbOptions)) {
							newRightButtonVerb = getVerbType(kVerbNone);
						}
					} else {
						if (newRightButtonVerb >= getVerbType(kVerbOptions)) {
							newRightButtonVerb = getVerbType(kVerbWalkTo);
						}
					}

					if ((_currentVerb == getVerbType(kVerbTalkTo)) || ((_currentVerb == getVerbType(kVerbGive)) && _firstObjectSet)) {
						objectId = ID_NOTHING;
						newObjectId = ID_NOTHING;
					}

					if ((_leftButtonVerb == getVerbType(kVerbUse)) && (hitZone->getRightButtonVerb() & 0x80)) {
						objectFlags = kObjUseWith;
					}
				}
			}
		} else {
			if ((_currentVerb == getVerbType(kVerbTalkTo)) || ((_currentVerb == getVerbType(kVerbGive)) && _firstObjectSet)) {
				// no way
			} else {
				panelButton = _vm->_interface->inventoryHitTest(mousePoint);
				if (panelButton) {
					objectId = _vm->_interface->getInventoryContentByPanelButton(panelButton);
					if (objectId != 0) {
						obj = _vm->_actor->getObj(objectId);
						newRightButtonVerb = getVerbType(kVerbLookAt);
						if (obj->_interactBits & kObjUseWith) {
							objectFlags = kObjUseWith;
						}
					}
				}
			}

			if ((_currentVerb == getVerbType(kVerbPickUp)) || (_currentVerb == getVerbType(kVerbTalkTo)) || (_currentVerb == getVerbType(kVerbWalkTo))) {
				_leftButtonVerb = getVerbType(kVerbLookAt);
			}
		}
	}

	if (objectId != _pointerObject) {
		_pointerObject = objectId;
		_currentObject[_firstObjectSet ? 1 : 0] = objectId;
		_currentObjectFlags[_firstObjectSet ? 1 : 0] = objectFlags;
		if (_pendingVerb == getVerbType(kVerbNone)) {
			showVerb();
		}
	}

	if (newRightButtonVerb != _rightButtonVerb) {
		setRightButtonVerb(newRightButtonVerb);
	}
}

} // End of namespace Saga
