libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-25 03:07:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
2b2af8ab5e
scummvm/engines/scumm/script.cpp

1405 lines
35 KiB
C++
Raw Blame History

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#include "common/stdafx.h"
#include "common/config-manager.h"
#include "common/util.h"
#include "scumm/actor.h"
#include "scumm/intern.h"
#include "scumm/object.h"
#include "scumm/resource.h"
#include "scumm/util.h"
#include "scumm/scumm.h"
#include "scumm/verbs.h"
namespace Scumm {
/* Start executing script 'script' with the given parameters */
void ScummEngine::runScript(int script, bool freezeResistant, bool recursive, int *lvarptr, int cycle) {
ScriptSlot *s;
byte *scriptPtr;
uint32 scriptOffs;
byte scriptType;
int slot;
if (!script)
return;
if (!recursive)
stopScript(script);
if (script < _numGlobalScripts) {
scriptPtr = getResourceAddress(rtScript, script);
scriptOffs = _resourceHeaderSize;
scriptType = WIO_GLOBAL;
debugC(DEBUG_SCRIPTS, "runScript(Global-%d) from %d-%d", script,
vm.slot[_currentScript].number, _roomResource);
} else {
scriptOffs = _localScriptOffsets[script - _numGlobalScripts];
if (scriptOffs == 0)
error("Local script %d is not in room %d", script, _roomResource);
scriptType = WIO_LOCAL;
debugC(DEBUG_SCRIPTS, "runScript(%d) from %d-%d", script,
vm.slot[_currentScript].number, _roomResource);
}
if (cycle == 0)
cycle = (_game.heversion >= 90) ? VAR(VAR_SCRIPT_CYCLE) : 1;
slot = getScriptSlot();
s = &vm.slot[slot];
s->number = script;
s->offs = scriptOffs;
s->status = ssRunning;
s->where = scriptType;
s->freezeResistant = freezeResistant;
s->recursive = recursive;
s->freezeCount = 0;
s->delayFrameCount = 0;
s->cycle = cycle;
initializeLocals(slot, lvarptr);
runScriptNested(slot);
}
void ScummEngine::runObjectScript(int object, int entry, bool freezeResistant, bool recursive, int *vars, int slot, int cycle) {
ScriptSlot *s;
uint32 obcd;
int where, offs;
if (!object)
return;
if (!recursive && (_game.version >= 3))
stopObjectScript(object);
where = whereIsObject(object);
if (where == WIO_NOT_FOUND) {
warning("Code for object %d not in room %d", object, _roomResource);
return;
}
obcd = getOBCDOffs(object);
// Find a free object slot, unless one was specified
if (slot == -1)
slot = getScriptSlot();
offs = getVerbEntrypoint(object, entry);
if (offs == 0)
return;
if (cycle == 0)
cycle = (_game.heversion >= 90) ? VAR(VAR_SCRIPT_CYCLE) : 1;
s = &vm.slot[slot];
s->number = object;
s->offs = obcd + offs;
s->status = ssRunning;
s->where = where;
s->freezeResistant = freezeResistant;
s->recursive = recursive;
s->freezeCount = 0;
s->delayFrameCount = 0;
s->cycle = cycle;
initializeLocals(slot, vars);
runScriptNested(slot);
}
void ScummEngine::initializeLocals(int slot, int *vars) {
int i;
if (!vars) {
for (i = 0; i < 25; i++)
vm.localvar[slot][i] = 0;
} else {
for (i = 0; i < 25; i++)
vm.localvar[slot][i] = vars[i];
}
}
int ScummEngine::getVerbEntrypoint(int obj, int entry) {
const byte *objptr, *verbptr;
int verboffs;
// WORKAROUND for bug #1555938: Disallow pulling the rope if it's
// already in the player's inventory.
if (_game.id == GID_MONKEY2 && obj == 1047 && entry == 6 && whereIsObject(obj) == WIO_INVENTORY) {
return 0;
}
if (whereIsObject(obj) == WIO_NOT_FOUND)
return 0;
objptr = getOBCDFromObject(obj);
assert(objptr);
if (_game.version == 0)
verbptr = objptr + 14;
else if (_game.version <= 2)
verbptr = objptr + 15;
else if ((_game.id == GID_LOOM && _game.platform == Common::kPlatformPCEngine) ||
_game.features & GF_OLD_BUNDLE)
verbptr = objptr + 17;
else if (_game.features & GF_SMALL_HEADER)
verbptr = objptr + 19;
else
verbptr = findResource(MKID_BE('VERB'), objptr);
assert(verbptr);
verboffs = verbptr - objptr;
if (!(_game.features & GF_SMALL_HEADER))
verbptr += _resourceHeaderSize;
if (_game.version == 8) {
const uint32 *ptr = (const uint32 *)verbptr;
uint32 verb;
do {
verb = READ_LE_UINT32(ptr);
if (!verb)
return 0;
if (verb == (uint32)entry || verb == 0xFFFFFFFF)
break;
ptr += 2;
} while (1);
return verboffs + 8 + READ_LE_UINT32(ptr + 1);
} else if (_game.version <= 2) {
do {
if (!*verbptr)
return 0;
if (*verbptr == entry || *verbptr == 0xFF)
break;
verbptr += 2;
} while (1);
return *(verbptr + 1);
} else {
do {
if (!*verbptr)
return 0;
if (*verbptr == entry || *verbptr == 0xFF)
break;
verbptr += 3;
} while (1);
if (_game.id == GID_LOOM && _game.platform == Common::kPlatformPCEngine)
return verboffs + READ_LE_UINT16(verbptr + 1) + 3;
else if (_game.features & GF_SMALL_HEADER)
return READ_LE_UINT16(verbptr + 1);
else
return verboffs + READ_LE_UINT16(verbptr + 1);
}
}
/* Stop script 'script' */
void ScummEngine::stopScript(int script) {
ScriptSlot *ss;
int i;
if (script == 0)
return;
ss = vm.slot;
for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++) {
if (script == ss->number && ss->status != ssDead &&
(ss->where == WIO_GLOBAL || ss->where == WIO_LOCAL)) {
if (ss->cutsceneOverride)
if (_game.version >= 5)
error("Script %d stopped with active cutscene/override", script);
ss->number = 0;
ss->status = ssDead;
nukeArrays(i);
if (_currentScript == i)
_currentScript = 0xFF;
}
}
for (i = 0; i < vm.numNestedScripts; ++i) {
if (vm.nest[i].number == script &&
(vm.nest[i].where == WIO_GLOBAL || vm.nest[i].where == WIO_LOCAL)) {
nukeArrays(vm.nest[i].slot);
vm.nest[i].number = 0xFF;
vm.nest[i].slot = 0xFF;
vm.nest[i].where = 0xFF;
}
}
}
/* Stop an object script 'script'*/
void ScummEngine::stopObjectScript(int script) {
ScriptSlot *ss;
NestedScript *nest;
int i, num;
if (script == 0)
return;
ss = vm.slot;
for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++) {
if (script == ss->number && ss->status != ssDead &&
(ss->where == WIO_ROOM || ss->where == WIO_INVENTORY || ss->where == WIO_FLOBJECT)) {
if (ss->cutsceneOverride)
if (_game.version >= 5)
error("Object %d stopped with active cutscene/override", script);
ss->number = 0;
ss->status = ssDead;
nukeArrays(i);
if (_currentScript == i)
_currentScript = 0xFF;
}
}
nest = vm.nest;
num = vm.numNestedScripts;
while (num > 0) {
if (nest->number == script &&
(nest->where == WIO_ROOM || nest->where == WIO_INVENTORY || nest->where == WIO_FLOBJECT)) {
nukeArrays(nest->slot);
nest->number = 0xFF;
nest->slot = 0xFF;
nest->where = 0xFF;
}
nest++;
num--;
}
}
/* Return a free script slot */
int ScummEngine::getScriptSlot() {
ScriptSlot *s;
int i;
for (i = 1; i < NUM_SCRIPT_SLOT; i++) {
s = &vm.slot[i];
if (s->status == ssDead)
return i;
}
error("Too many scripts running, %d max", NUM_SCRIPT_SLOT);
return -1;
}
/* Run script 'script' nested - eg, within the parent script.*/
void ScummEngine::runScriptNested(int script) {
NestedScript *nest;
ScriptSlot *slot;
updateScriptPtr();
nest = &vm.nest[vm.numNestedScripts];
if (_currentScript == 0xFF) {
nest->number = 0xFF;
nest->where = 0xFF;
} else {
// Store information about the currently running script
slot = &vm.slot[_currentScript];
nest->number = slot->number;
nest->where = slot->where;
nest->slot = _currentScript;
}
vm.numNestedScripts++;
if (vm.numNestedScripts > ARRAYSIZE(vm.nest))
error("Too many nested scripts");
_currentScript = script;
getScriptBaseAddress();
getScriptEntryPoint();
executeScript();
if (vm.numNestedScripts != 0)
vm.numNestedScripts--;
if (nest->number != 0xFF) {
// Try to resume the script which called us, if its status has not changed
// since it invoked us. In particular, we only resume it if it hasn't been
// stopped in the meantime, and if it did not already move on.
slot = &vm.slot[nest->slot];
if (slot->number == nest->number && slot->where == nest->where &&
slot->status != ssDead && slot->freezeCount == 0) {
_currentScript = nest->slot;
getScriptBaseAddress();
getScriptEntryPoint();
return;
}
}
_currentScript = 0xFF;
}
void ScummEngine::updateScriptPtr() {
if (_currentScript == 0xFF)
return;
vm.slot[_currentScript].offs = _scriptPointer - _scriptOrgPointer;
}
/* Nuke arrays based on script */
void ScummEngine::nukeArrays(byte scriptSlot) {
int i;
if (_game.heversion == 0 || scriptSlot == 0)
return;
for (i = 1; i < _numArray; i++) {
if (_arraySlot[i] == scriptSlot) {
_res->nukeResource(rtString, i);
_arraySlot[i] = 0;
}
}
}
/* Get the code pointer to a script */
void ScummEngine::getScriptBaseAddress() {
ScriptSlot *ss;
int idx;
if (_currentScript == 0xFF)
return;
ss = &vm.slot[_currentScript];
switch (ss->where) {
case WIO_INVENTORY: /* inventory script * */
for (idx = 0; idx < _numInventory; idx++)
if (_inventory[idx] == ss->number)
break;
_scriptOrgPointer = getResourceAddress(rtInventory, idx);
assert(idx < _numInventory);
_lastCodePtr = &_res->address[rtInventory][idx];
break;
case WIO_LOCAL:
case WIO_ROOM: /* room script */
if (_game.version == 8) {
_scriptOrgPointer = getResourceAddress(rtRoomScripts, _roomResource);
assert(_roomResource < _res->num[rtRoomScripts]);
_lastCodePtr = &_res->address[rtRoomScripts][_roomResource];
} else {
_scriptOrgPointer = getResourceAddress(rtRoom, _roomResource);
assert(_roomResource < _numRooms);
_lastCodePtr = &_res->address[rtRoom][_roomResource];
}
break;
case WIO_GLOBAL: /* global script */
_scriptOrgPointer = getResourceAddress(rtScript, ss->number);
assert(ss->number < _numScripts);
_lastCodePtr = &_res->address[rtScript][ss->number];
break;
case WIO_FLOBJECT: /* flobject script */
idx = getObjectIndex(ss->number);
assert(idx != -1);
idx = _objs[idx].fl_object_index;
_scriptOrgPointer = getResourceAddress(rtFlObject, idx);
assert(idx < _numFlObject);
_lastCodePtr = &_res->address[rtFlObject][idx];
break;
default:
error("Bad type while getting base address");
}
// The following fixes bug #1202487. Confirmed against disasm.
if (_game.version <= 2 && _scriptOrgPointer == NULL) {
ss->status = ssDead;
_currentScript = 0xFF;
}
}
void ScummEngine::getScriptEntryPoint() {
if (_currentScript == 0xFF)
return;
_scriptPointer = _scriptOrgPointer + vm.slot[_currentScript].offs;
}
/* Execute a script - Read opcode, and execute it from the table */
void ScummEngine::executeScript() {
int c;
while (_currentScript != 0xFF) {
if (_showStack == 1) {
printf("Stack:");
for (c=0; c < _scummStackPos; c++) {
printf(" %d", _vmStack[c]);
}
printf("\n");
}
_opcode = fetchScriptByte();
if (_game.version > 2) // V0-V2 games didn't use the didexec flag
vm.slot[_currentScript].didexec = true;
debugC(DEBUG_OPCODES, "Script %d, offset 0x%x: [%X] %s()",
vm.slot[_currentScript].number,
_scriptPointer - _scriptOrgPointer,
_opcode,
getOpcodeDesc(_opcode));
if (_hexdumpScripts == true) {
for (c= -1; c < 15; c++) {
printf(" %02x", *(_scriptPointer + c));
}
printf("\n");
}
executeOpcode(_opcode);
}
}
byte ScummEngine::fetchScriptByte() {
if (*_lastCodePtr + sizeof(MemBlkHeader) != _scriptOrgPointer) {
long oldoffs = _scriptPointer - _scriptOrgPointer;
getScriptBaseAddress();
_scriptPointer = _scriptOrgPointer + oldoffs;
}
return *_scriptPointer++;
}
uint ScummEngine::fetchScriptWord() {
int a;
if (*_lastCodePtr + sizeof(MemBlkHeader) != _scriptOrgPointer) {
long oldoffs = _scriptPointer - _scriptOrgPointer;
getScriptBaseAddress();
_scriptPointer = _scriptOrgPointer + oldoffs;
}
a = READ_LE_UINT16(_scriptPointer);
_scriptPointer += 2;
return a;
}
int ScummEngine::fetchScriptWordSigned() {
return (int16)fetchScriptWord();
}
uint ScummEngine::fetchScriptDWord() {
int a;
if (*_lastCodePtr + sizeof(MemBlkHeader) != _scriptOrgPointer) {
uint32 oldoffs = _scriptPointer - _scriptOrgPointer;
getScriptBaseAddress();
_scriptPointer = _scriptOrgPointer + oldoffs;
}
a = READ_LE_UINT32(_scriptPointer);
_scriptPointer += 4;
return a;
}
int ScummEngine::fetchScriptDWordSigned() {
return (int32)fetchScriptDWord();
}
int ScummEngine::readVar(uint var) {
int a;
debugC(DEBUG_VARS, "readvar(%d)", var);
if ((var & 0x2000) && (_game.version <= 5)) {
a = fetchScriptWord();
if (a & 0x2000)
var += readVar(a & ~0x2000);
else
var += a & 0xFFF;
var &= ~0x2000;
}
if (!(var & 0xF000)) {
if (!_copyProtection) {
if (var == 490 && _game.id == GID_MONKEY2) {
var = 518;
}
}
if (VAR_SUBTITLES != 0xFF && var == VAR_SUBTITLES) {
return ConfMan.getBool("subtitles");
}
if (VAR_NOSUBTITLES != 0xFF && var == VAR_NOSUBTITLES) {
return !ConfMan.getBool("subtitles");
}
assertRange(0, var, _numVariables - 1, "variable (reading)");
return _scummVars[var];
}
if (var & 0x8000) {
if (_game.heversion >= 80) {
var &= 0xFFF;
assertRange(0, var, _numRoomVariables - 1, "room variable (reading)");
return _roomVars[var];
} else if (_game.version <= 3 && !(_game.id == GID_INDY3 && _game.platform == Common::kPlatformFMTowns) &&
!(_game.id == GID_LOOM && _game.platform == Common::kPlatformPCEngine)) {
int bit = var & 0xF;
var = (var >> 4) & 0xFF;
if (!_copyProtection) {
if (_game.id == GID_LOOM && (_game.platform == Common::kPlatformFMTowns) && var == 214 && bit == 15) {
return 0;
} else if (_game.id == GID_ZAK && (_game.platform == Common::kPlatformFMTowns) && var == 151 && bit == 8) {
return 0;
}
}
assertRange(0, var, _numVariables - 1, "variable (reading)");
return (_scummVars[ var ] & ( 1 << bit ) ) ? 1 : 0;
} else {
var &= 0x7FFF;
if (!_copyProtection) {
if (_game.id == GID_INDY3 && (_game.platform == Common::kPlatformFMTowns) && var == 1508)
return 0;
}
assertRange(0, var, _numBitVariables - 1, "variable (reading)");
return (_bitVars[var >> 3] & (1 << (var & 7))) ? 1 : 0;
}
}
if (var & 0x4000) {
if (_game.features & GF_FEW_LOCALS) {
var &= 0xF;
} else {
var &= 0xFFF;
}
if (_game.heversion >= 80)
assertRange(0, var, 25, "local variable (reading)");
else
assertRange(0, var, 20, "local variable (reading)");
return vm.localvar[_currentScript][var];
}
error("Illegal varbits (r)");
return -1;
}
void ScummEngine::writeVar(uint var, int value) {
debugC(DEBUG_VARS, "writeVar(%d, %d)", var, value);
if (!(var & 0xF000)) {
assertRange(0, var, _numVariables - 1, "variable (writing)");
if (VAR_SUBTITLES != 0xFF && var == VAR_SUBTITLES) {
// Ignore default setting in HE72-73 games
if (_game.heversion <= 73 && vm.slot[_currentScript].number == 1)
return;
assert(value == 0 || value == 1);
ConfMan.setBool("subtitles", (value != 0));
}
if (VAR_NOSUBTITLES != 0xFF && var == VAR_NOSUBTITLES) {
// Ignore default setting in HE60-71 games
if (_game.heversion >= 60 && vm.slot[_currentScript].number == 1)
return;
assert(value == 0 || value == 1);
ConfMan.setBool("subtitles", !value);
}
if (var == VAR_CHARINC) {
if (ConfMan.hasKey("talkspeed")) {
value = getTalkspeed();
} else {
// Save the new talkspeed value to ConfMan
setTalkspeed(value);
}
}
_scummVars[var] = value;
if ((_varwatch == (int)var) || (_varwatch == 0)) {
if (vm.slot[_currentScript].number < 100)
debug(1, "vars[%d] = %d (via script-%d)", var, value, vm.slot[_currentScript].number);
else
debug(1, "vars[%d] = %d (via room-%d-%d)", var, value, _currentRoom,
vm.slot[_currentScript].number);
}
return;
}
if (var & 0x8000) {
if (_game.heversion >= 80) {
var &= 0xFFF;
assertRange(0, var, _numRoomVariables - 1, "room variable (writing)");
_roomVars[var] = value;
} else if (_game.version <= 3 && !(_game.id == GID_INDY3 && _game.platform == Common::kPlatformFMTowns) &&
!(_game.id == GID_LOOM && _game.platform == Common::kPlatformPCEngine)) {
// In the old games, the bit variables were using the same memory
// as the normal variables!
int bit = var & 0xF;
var = (var >> 4) & 0xFF;
assertRange(0, var, _numVariables - 1, "variable (writing)");
if (value)
_scummVars[var] |= ( 1 << bit );
else
_scummVars[var] &= ~( 1 << bit );
} else {
var &= 0x7FFF;
assertRange(0, var, _numBitVariables - 1, "bit variable (writing)");
if (value)
_bitVars[var >> 3] |= (1 << (var & 7));
else
_bitVars[var >> 3] &= ~(1 << (var & 7));
}
return;
}
if (var & 0x4000) {
if (_game.features & GF_FEW_LOCALS) {
var &= 0xF;
} else {
var &= 0xFFF;
}
if (_game.heversion >= 80)
assertRange(0, var, 25, "local variable (writing)");
else
assertRange(0, var, 20, "local variable (writing)");
vm.localvar[_currentScript][var] = value;
return;
}
error("Illegal varbits (w)");
}
void ScummEngine::getResultPos() {
int a;
_resultVarNumber = fetchScriptWord();
if (_resultVarNumber & 0x2000) {
a = fetchScriptWord();
if (a & 0x2000) {
_resultVarNumber += readVar(a & ~0x2000);
} else {
_resultVarNumber += a & 0xFFF;
}
_resultVarNumber &= ~0x2000;
}
}
void ScummEngine::setResult(int value) {
writeVar(_resultVarNumber, value);
}
void ScummEngine::push(int a) {
assert(_scummStackPos >= 0 && _scummStackPos < ARRAYSIZE(_vmStack));
debug(9, "push %d", a);
_vmStack[_scummStackPos++] = a;
}
int ScummEngine::pop() {
if (_scummStackPos < 1 || _scummStackPos > ARRAYSIZE(_vmStack)) {
error("No items on stack to pop() for %s (0x%X) at [%d-%d]", getOpcodeDesc(_opcode), _opcode, _roomResource, vm.slot[_currentScript].number);
}
--_scummStackPos;
debug(9, "pop %d", _vmStack[_scummStackPos]);
return _vmStack[_scummStackPos];
}
void ScummEngine::stopObjectCode() {
ScriptSlot *ss;
ss = &vm.slot[_currentScript];
if (_game.version <= 2) {
if (ss->where == WIO_GLOBAL || ss->where == WIO_LOCAL) {
stopScript(ss->number);
} else {
ss->number = 0;
ss->status = ssDead;
}
} else if (_game.version <= 5) {
if (ss->where != WIO_GLOBAL && ss->where != WIO_LOCAL) {
stopObjectScript(ss->number);
} else {
if (_game.version >= 4 && ss->cutsceneOverride)
error("Script %d ending with active cutscene/override (%d)", ss->number, ss->cutsceneOverride);
ss->number = 0;
ss->status = ssDead;
}
} else {
if (ss->where != WIO_GLOBAL && ss->where != WIO_LOCAL) {
if (ss->cutsceneOverride)
error("Object %d ending with active cutscene/override (%d)", ss->number, ss->cutsceneOverride);
} else {
if (ss->cutsceneOverride)
error("Script %d ending with active cutscene/override (%d)", ss->number, ss->cutsceneOverride);
}
ss->number = 0;
ss->status = ssDead;
}
nukeArrays(_currentScript);
_currentScript = 0xFF;
}
void ScummEngine::runInventoryScript(int i) {
int args[24];
memset(args, 0, sizeof(args));
args[0] = i;
if (VAR(VAR_INVENTORY_SCRIPT)) {
if (_game.id == GID_INDY3 && _game.platform == Common::kPlatformMacintosh) {
inventoryScript();
} else {
runScript(VAR(VAR_INVENTORY_SCRIPT), 0, 0, args);
}
}
}
void ScummEngine::inventoryScript() {
VerbSlot *vs;
int args[24];
int j, slot;
memset(args, 0, sizeof(args));
if (VAR(67) < 0) {
VAR(67) = 0;
}
args[5] = getInventoryCount(VAR(VAR_EGO));
if (args[5] <= 6) {
VAR(67) = 0;
}
if (args[5] >= 6) {
args[5] -= 6;
}
args[6] = 0;
if (VAR(67) >= args[5]) {
VAR(67) = args[5];
args[4] = args[5];
args[5] /= 2;
args[5] *= 2;
args[4] -= args[5];
if (args[4]) {
VAR(67)++;
}
args[6]++;
}
args[2] = 1;
for (j = 1; j < 7; j++) {
args[1] = (VAR(67) + args[2]);
args[3] = findInventory(VAR(VAR_EGO),args[1]);
VAR(82 + args[2]) = args[3];
args[2]++;
}
byte tmp[6];
tmp[0] = 0xFF;
tmp[1] = 0x06;
tmp[3] = 0x00;
tmp[4] = 0x00;
for (j = 0; j < 6; j++) {
tmp[2] = 0x53 + j;
slot = getVerbSlot(101 + j, 0);
vs = &_verbs[slot];
loadPtrToResource(rtVerb, slot, tmp);
vs->type = kTextVerbType;
vs->imgindex = 0;
vs->curmode = 1;
drawVerb(slot, 0);
}
args[5] = getInventoryCount(VAR(VAR_EGO));
if (args[5] > 6) {
slot = getVerbSlot(107, 0);
if (VAR(67)) {
vs = &_verbs[slot];
vs->curmode = 1;
} else {
vs = &_verbs[slot];
vs->curmode = 0;
}
drawVerb(slot, 0);
slot = getVerbSlot(108, 0);
if (!args[6]) {
vs = &_verbs[slot];
vs->curmode = 1;
} else {
vs = &_verbs[slot];
vs->curmode = 0;
}
drawVerb(slot, 0);
} else {
slot = getVerbSlot(107, 0);
vs = &_verbs[slot];
vs->curmode = 0;
drawVerb(slot, 0);
slot = getVerbSlot(108, 0);
vs = &_verbs[slot];
vs->curmode = 0;
drawVerb(slot, 0);
}
verbMouseOver(0);
}
void ScummEngine::freezeScripts(int flag) {
int i;
if (_game.version <= 2) {
for (i = 0; i < NUM_SCRIPT_SLOT; i++) {
if (_currentScript != i && vm.slot[i].status != ssDead && !vm.slot[i].freezeResistant) {
vm.slot[i].status |= 0x80;
}
}
return;
}
for (i = 0; i < NUM_SCRIPT_SLOT; i++) {
if (_currentScript != i && vm.slot[i].status != ssDead && (!vm.slot[i].freezeResistant || flag >= 0x80)) {
vm.slot[i].status |= 0x80;
vm.slot[i].freezeCount++;
}
}
for (i = 0; i < NUM_SENTENCE; i++)
_sentence[i].freezeCount++;
if (vm.cutSceneScriptIndex != 0xFF) {
vm.slot[vm.cutSceneScriptIndex].status &= 0x7F;
vm.slot[vm.cutSceneScriptIndex].freezeCount = 0;
}
}
void ScummEngine::unfreezeScripts() {
int i;
if (_game.version <= 2) {
for (i = 0; i < NUM_SCRIPT_SLOT; i++) {
vm.slot[i].status &= 0x7F;
}
return;
}
for (i = 0; i < NUM_SCRIPT_SLOT; i++) {
if (vm.slot[i].status & 0x80) {
if (!--vm.slot[i].freezeCount) {
vm.slot[i].status &= 0x7F;
}
}
}
for (i = 0; i < NUM_SENTENCE; i++) {
if (_sentence[i].freezeCount > 0)
_sentence[i].freezeCount--;
}
}
void ScummEngine::runAllScripts() {
int i;
for (i = 0; i < NUM_SCRIPT_SLOT; i++)
vm.slot[i].didexec = false;
_currentScript = 0xFF;
int numCycles = (_game.heversion >= 90) ? VAR(VAR_NUM_SCRIPT_CYCLES) : 1;
for (int cycle = 1; cycle <= numCycles; cycle++) {
for (i = 0; i < NUM_SCRIPT_SLOT; i++) {
if (vm.slot[i].cycle == cycle && vm.slot[i].status == ssRunning && !vm.slot[i].didexec) {
_currentScript = (byte)i;
getScriptBaseAddress();
getScriptEntryPoint();
executeScript();
}
}
}
}
void ScummEngine::runExitScript() {
if (VAR_EXIT_SCRIPT != 0xFF && VAR(VAR_EXIT_SCRIPT))
runScript(VAR(VAR_EXIT_SCRIPT), 0, 0, 0);
if (_EXCD_offs) {
int slot = getScriptSlot();
vm.slot[slot].status = ssRunning;
vm.slot[slot].number = 10001;
vm.slot[slot].where = WIO_ROOM;
vm.slot[slot].offs = _EXCD_offs;
vm.slot[slot].freezeResistant = false;
vm.slot[slot].recursive = false;
vm.slot[slot].freezeCount = 0;
vm.slot[slot].delayFrameCount = 0;
vm.slot[slot].cycle = 1;
// FIXME: the exit script of room 7 in indy3 only seems to have a size
// and tag not actual data not even a 00 (stop code). Maybe we should
// be limiting ourselves to strictly reading the size from the header?
if (_game.id == GID_INDY3 && !(_game.features & GF_OLD_BUNDLE)) {
byte *roomptr = getResourceAddress(rtRoom, _roomResource);
const byte *excd = findResourceData(MKID_BE('EXCD'), roomptr) - _resourceHeaderSize;
if (!excd || (getResourceDataSize(excd) < 1)) {
debug(2, "Exit-%d is empty", _roomResource);
return;
}
}
initializeLocals(slot, 0);
runScriptNested(slot);
}
if (VAR_EXIT_SCRIPT2 != 0xFF && VAR(VAR_EXIT_SCRIPT2))
runScript(VAR(VAR_EXIT_SCRIPT2), 0, 0, 0);
}
void ScummEngine::runEntryScript() {
if (VAR_ENTRY_SCRIPT != 0xFF && VAR(VAR_ENTRY_SCRIPT))
runScript(VAR(VAR_ENTRY_SCRIPT), 0, 0, 0);
if (_ENCD_offs) {
int slot = getScriptSlot();
vm.slot[slot].status = ssRunning;
vm.slot[slot].number = 10002;
vm.slot[slot].where = WIO_ROOM;
vm.slot[slot].offs = _ENCD_offs;
vm.slot[slot].freezeResistant = false;
vm.slot[slot].recursive = false;
vm.slot[slot].freezeCount = 0;
vm.slot[slot].delayFrameCount = 0;
vm.slot[slot].cycle = 1;
initializeLocals(slot, 0);
runScriptNested(slot);
}
if (VAR_ENTRY_SCRIPT2 != 0xFF && VAR(VAR_ENTRY_SCRIPT2))
runScript(VAR(VAR_ENTRY_SCRIPT2), 0, 0, 0);
}
void ScummEngine::killScriptsAndResources() {
ScriptSlot *ss;
int i;
ss = vm.slot;
for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++) {
if (ss->where == WIO_ROOM || ss->where == WIO_FLOBJECT) {
if (ss->cutsceneOverride) {
if (_game.version >= 5)
warning("Object %d stopped with active cutscene/override in exit", ss->number);
ss->cutsceneOverride = 0;
}
nukeArrays(i);
ss->status = ssDead;
} else if (ss->where == WIO_LOCAL) {
if (ss->cutsceneOverride) {
if (_game.version >= 5)
warning("Script %d stopped with active cutscene/override in exit", ss->number);
ss->cutsceneOverride = 0;
}
nukeArrays(i);
ss->status = ssDead;
}
}
/* Nuke local object names */
if (_newNames) {
for (i = 0; i < _numNewNames; i++) {
const int obj = _newNames[i];
if (obj) {
const int owner = getOwner(obj);
// We can delete custom name resources if either the object is
// no longer in use (i.e. not owned by anyone anymore); or if
// it is an object which is owned by a room.
if (owner == 0 || (_game.version < 7 && owner == OF_OWNER_ROOM)) {
// WORKAROUND for a problem mentioned in bug report #941275:
// In FOA in the sentry room, in the chest plate of the statue,
// the pegs may be renamed to mouth: this custom name is lost
// when leaving the room; this hack prevents this).
if (owner == OF_OWNER_ROOM && _game.id == GID_INDY4 && 336 <= obj && obj <= 340)
continue;
_newNames[i] = 0;
_res->nukeResource(rtObjectName, i);
}
}
}
}
}
void ScummEngine::killAllScriptsExceptCurrent() {
for (int i = 0; i < NUM_SCRIPT_SLOT; i++) {
if (i != _currentScript) {
vm.slot[i].status = ssDead;
if (_game.version == 6)
vm.slot[i].cutsceneOverride = 0;
}
}
}
void ScummEngine::doSentence(int verb, int objectA, int objectB) {
SentenceTab *st;
if (_game.version >= 7) {
if (objectA == objectB)
return;
if (_sentenceNum > 0) {
st = &_sentence[_sentenceNum - 1];
// Check if this doSentence request is identical to the previous one;
// if yes, ignore this invocation.
if (_sentenceNum && st->verb == verb && st->objectA == objectA && st->objectB == objectB)
return;
}
}
assert(_sentenceNum < NUM_SENTENCE);
st = &_sentence[_sentenceNum++];
st->verb = verb;
st->objectA = objectA;
st->objectB = objectB;
st->preposition = (objectB != 0);
st->freezeCount = 0;
}
void ScummEngine::checkAndRunSentenceScript() {
int i;
int localParamList[24];
const ScriptSlot *ss;
int sentenceScript;
if (_game.version <= 2)
sentenceScript = 2;
else
sentenceScript = VAR(VAR_SENTENCE_SCRIPT);
memset(localParamList, 0, sizeof(localParamList));
if (isScriptInUse(sentenceScript)) {
ss = vm.slot;
for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++)
if (ss->number == sentenceScript && ss->status != ssDead && ss->freezeCount == 0)
return;
}
if (!_sentenceNum || _sentence[_sentenceNum - 1].freezeCount)
return;
_sentenceNum--;
SentenceTab &st = _sentence[_sentenceNum];
if (_game.version < 7)
if (st.preposition && st.objectB == st.objectA)
return;
if (_game.version <= 2) {
VAR(VAR_ACTIVE_VERB) = st.verb;
VAR(VAR_ACTIVE_OBJECT1) = st.objectA;
VAR(VAR_ACTIVE_OBJECT2) = st.objectB;
VAR(VAR_VERB_ALLOWED) = (0 != getVerbEntrypoint(st.objectA, st.verb));
} else {
localParamList[0] = st.verb;
localParamList[1] = st.objectA;
localParamList[2] = st.objectB;
if (_game.id == GID_FT && !isValidActor(localParamList[1]) && !isValidActor(localParamList[2])) {
// WORKAROUND for bug #1407789. The buggy script clearly
// assumes that one of the two objects is an actor. If that's
// not the case, fall back on the default sentence script.
// FIXME: We do not yet have all necessary information, but the
// following is known:
//
// * The US PC version uses scripts 28 and 103 and has 456 scripts.
// * The French PC version uses scripts 29 and 104 and has 467 scripts.
// * The German Mac version uses scripts 29 and 104 and has 469 scripts.
// * The German, Italian, Portuguese and Spanish PC versions
// use script 29. The other script is not currently known.
// * The US Mac demo uses script 28.
//
// For now we assume that if there are more than 460 scripts, then
// the pair 29/104 is used, else the pair 28/103.
if (_res->num[rtScript] > 460) {
if (sentenceScript == 104)
sentenceScript = 29;
} else {
if (sentenceScript == 103)
sentenceScript = 28;
}
}
}
_currentScript = 0xFF;
if (sentenceScript)
runScript(sentenceScript, 0, 0, localParamList);
}
void ScummEngine_v2::runInputScript(int clickArea, int val, int mode) {
int args[24];
int verbScript;
verbScript = 4;
VAR(VAR_CLICK_AREA) = clickArea;
switch (clickArea) {
case kVerbClickArea: // Verb clicked
VAR(VAR_CLICK_VERB) = val;
break;
case kInventoryClickArea: // Inventory clicked
VAR(VAR_CLICK_OBJECT) = val;
break;
}
memset(args, 0, sizeof(args));
args[0] = clickArea;
args[1] = val;
args[2] = mode;
if (verbScript)
runScript(verbScript, 0, 0, args);
}
void ScummEngine::runInputScript(int clickArea, int val, int mode) {
int args[24];
int verbScript;
verbScript = VAR(VAR_VERB_SCRIPT);
memset(args, 0, sizeof(args));
args[0] = clickArea;
args[1] = val;
args[2] = mode;
// All HE 72+ games but only some HE 71 games.
if (_game.heversion >= 71) {
args[3] = VAR(VAR_VIRT_MOUSE_X);
args[4] = VAR(VAR_VIRT_MOUSE_Y);
}
// Macintosh verison of indy3ega used different interface, so adjust values.
if (_game.id == GID_INDY3 && _game.platform == Common::kPlatformMacintosh) {
if (clickArea == kVerbClickArea && (val >= 101 && val <= 108)) {
if (val == 107) {
VAR(67) -= 2;
inventoryScript();
return;
} else if (val == 108) {
VAR(67) += 2;
inventoryScript();
return;
} else {
args[0] = 3;
args[1] = VAR(83 + (val - 101));
}
}
}
if (verbScript)
runScript(verbScript, 0, 0, args);
}
void ScummEngine::decreaseScriptDelay(int amount) {
ScriptSlot *ss = vm.slot;
int i;
for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++) {
if (ss->status == ssPaused) {
ss->delay -= amount;
if (ss->delay < 0) {
ss->status = ssRunning;
ss->delay = 0;
}
}
}
}
bool ScummEngine::isScriptInUse(int script) const {
int i;
const ScriptSlot *ss = vm.slot;
for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++)
if (ss->number == script)
return true;
return false;
}
bool ScummEngine::isScriptRunning(int script) const {
int i;
const ScriptSlot *ss = vm.slot;
for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++)
if (ss->number == script && (ss->where == WIO_GLOBAL || ss->where == WIO_LOCAL) && ss->status != ssDead)
return true;
return false;
}
bool ScummEngine::isRoomScriptRunning(int script) const {
int i;
const ScriptSlot *ss = vm.slot;
for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++)
if (ss->number == script && ss->where == WIO_ROOM && ss->status != ssDead)
return true;
return false;
}
void ScummEngine::copyScriptString(byte *dst) {
int len = resStrLen(_scriptPointer) + 1;
while (len--)
*dst++ = fetchScriptByte();
*dst = 0;
}
//
// Given a pointer to a Scumm string, this function returns the total byte length
// of the string data in that resource. To do so it has to understand certain
// special characters embedded into the string. The reason for this function is that
// sometimes this embedded data contains zero bytes, thus we can't just use strlen.
//
int ScummEngine::resStrLen(const byte *src) const {
int num = 0;
byte chr;
if (src == NULL)
src = _scriptPointer;
while ((chr = *src++) != 0) {
num++;
if (_game.heversion <= 71 && chr == 0xFF) {
chr = *src++;
num++;
// WORKAROUND for bug #985948, a script bug in Indy3. See also
// the corresponding code in ScummEngine::convertMessageToString().
if (_game.id == GID_INDY3 && chr == 0x2E) {
continue;
}
if (chr != 1 && chr != 2 && chr != 3 && chr != 8) {
if (_game.version == 8) {
src += 4;
num += 4;
} else {
src += 2;
num += 2;
}
}
}
}
return num;
}
void ScummEngine::beginCutscene(int *args) {
int scr = _currentScript;
vm.slot[scr].cutsceneOverride++;
if (++vm.cutSceneStackPointer > ARRAYSIZE(vm.cutSceneData))
error("Cutscene stack overflow");
vm.cutSceneData[vm.cutSceneStackPointer] = args[0];
vm.cutSceneScript[vm.cutSceneStackPointer] = 0;
vm.cutScenePtr[vm.cutSceneStackPointer] = 0;
vm.cutSceneScriptIndex = scr;
if (VAR(VAR_CUTSCENE_START_SCRIPT))
runScript(VAR(VAR_CUTSCENE_START_SCRIPT), 0, 0, args);
vm.cutSceneScriptIndex = 0xFF;
}
void ScummEngine::endCutscene() {
ScriptSlot *ss = &vm.slot[_currentScript];
int args[16];
if (ss->cutsceneOverride > 0) // Only terminate if active
ss->cutsceneOverride--;
memset(args, 0, sizeof(args));
args[0] = vm.cutSceneData[vm.cutSceneStackPointer];
VAR(VAR_OVERRIDE) = 0;
if (vm.cutScenePtr[vm.cutSceneStackPointer] && (ss->cutsceneOverride > 0)) // Only terminate if active
ss->cutsceneOverride--;
vm.cutSceneScript[vm.cutSceneStackPointer] = 0;
vm.cutScenePtr[vm.cutSceneStackPointer] = 0;
vm.cutSceneStackPointer--;
if (VAR(VAR_CUTSCENE_END_SCRIPT))
runScript(VAR(VAR_CUTSCENE_END_SCRIPT), 0, 0, args);
}
void ScummEngine::abortCutscene() {
const int idx = vm.cutSceneStackPointer;
assert(0 <= idx && idx < 5);
uint32 offs = vm.cutScenePtr[idx];
if (offs) {
ScriptSlot *ss = &vm.slot[vm.cutSceneScript[idx]];
ss->offs = offs;
ss->status = ssRunning;
ss->freezeCount = 0;
if (ss->cutsceneOverride > 0)
ss->cutsceneOverride--;
VAR(VAR_OVERRIDE) = 1;
vm.cutScenePtr[idx] = 0;
// HACK to fix issues with SMUSH and the way it does keyboard handling.
// In particular, normally abortCutscene() is being called while no
// scripts are active. But SMUSH runs from *inside* the script engine.
// And it calls abortCutscene() if ESC is pressed... not good.
// Proper fix might be to let SMUSH/INSANE run from outside the script
// engine but that would require lots of changes and may actually have
// negative effects, too. So we cheat here, to fix bug #751670.
if (_game.version == 7)
getScriptEntryPoint();
}
}
void ScummEngine::beginOverride() {
const int idx = vm.cutSceneStackPointer;
assert(0 <= idx && idx < 5);
vm.cutScenePtr[idx] = _scriptPointer - _scriptOrgPointer;
vm.cutSceneScript[idx] = _currentScript;
// Skip the jump instruction following the override instruction
// (the jump is responsible for "skipping" cutscenes, and the reason
// why we record the current script position in vm.cutScenePtr).
fetchScriptByte();
fetchScriptWord();
if (_game.version >= 5)
VAR(VAR_OVERRIDE) = 0;
}
void ScummEngine::endOverride() {
const int idx = vm.cutSceneStackPointer;
assert(0 <= idx && idx < 5);
vm.cutScenePtr[idx] = 0;
vm.cutSceneScript[idx] = 0;
if (_game.version >= 4)
VAR(VAR_OVERRIDE) = 0;
}
} // End of namespace Scumm
Reference in New Issue View Git Blame Copy Permalink