void Script::initializeObjectsSci3(SegManager *segMan, SegmentId segmentId) {
SciSpan<const byte> seeker = getSci3ObjectsPointer();
while (seeker.getUint16SEAt(0) == SCRIPT_OBJECT_MAGIC_NUMBER) {
Object *obj = scriptObjInit(make_reg32(segmentId, seeker - *_buf));
obj->setSuperClassSelector(segMan->getClassAddress(obj->getSuperClassSelector().getOffset(), SCRIPT_GET_LOCK, 0));
seeker += seeker.getUint16SEAt(2);
}
relocateSci3(segmentId);
}
void Script::initializeObjectsSci0(SegManager *segMan, SegmentId segmentId) {
bool oldScriptHeader = (getSciVersion() == SCI_VERSION_0_EARLY);
// We need to make two passes, as the objects in the script might be in the
// wrong order (e.g. in the demo of Iceman) - refer to bug #3034713
for (int pass = 1; pass <= 2; pass++) {
SciSpan<const byte> seeker = _buf->subspan(oldScriptHeader ? 2 : 0);
do {
uint16 objType = seeker.getUint16SEAt(0);
if (!objType)
break;
switch (objType) {
case SCI_OBJ_OBJECT:
case SCI_OBJ_CLASS:
{
reg_t addr = make_reg(segmentId, seeker - *_buf + 4 - SCRIPT_OBJECT_MAGIC_OFFSET);
Object *obj;
if (pass == 1) {
obj = scriptObjInit(addr);
obj->initSpecies(segMan, addr);
} else {
obj = getObject(addr.getOffset());
if (!obj->initBaseObject(segMan, addr)) {
if ((_nr == 202 || _nr == 764) && g_sci->getGameId() == GID_KQ5) {
// WORKAROUND: Script 202 of KQ5 French and German
// (perhaps Spanish too?) has an invalid object.
// This is non-fatal. Refer to bugs #3035396 and
// #3150767.
// Same happens with script 764, it seems to
// contain junk towards its end.
_objects.erase(addr.toUint16() - SCRIPT_OBJECT_MAGIC_OFFSET);
} else {
error("Failed to locate base object for object at %04x:%04x in script %d", PRINT_REG(addr), _nr);
}
}
}
}
break;
default:
break;
}
seeker += seeker.getUint16SEAt(2);
} while ((uint32)(seeker - *_buf) < getScriptSize() - 2);
}
relocateSci0Sci21(segmentId);
}
void Script::initializeLocals(SegManager *segMan) {
LocalVariables *locals = allocLocalsSegment(segMan);
if (locals) {
if (getSciVersion() > SCI_VERSION_0_EARLY) {
const SciSpan<const byte> base = _buf->subspan(getLocalsOffset());
for (uint16 i = 0; i < getLocalsCount(); i++)
locals->_locals[i] = make_reg(0, base.getUint16SEAt(i * sizeof(uint16)));
} else {
// In SCI0 early, locals are set at run time, thus zero them all here
for (uint16 i = 0; i < getLocalsCount(); i++)
locals->_locals[i] = NULL_REG;
}
}
}
void Script::relocateSci0Sci21(const SegmentId segmentId) {
const SciSpan<const uint16> relocEntries = getRelocationTableSci0Sci21();
const uint32 heapOffset = getHeapOffset();
for (uint i = 0; i < relocEntries.size(); ++i) {
const uint pos = relocEntries.getUint16SEAt(i) + heapOffset;
// In SCI0-SCI1, script local variables, objects and code are relocated.
// We only relocate locals and objects here, and ignore relocation of
// code blocks. In SCI1.1 and newer versions, only locals and objects
// are relocated.
if (!relocateLocal(segmentId, pos, getHeapOffset())) {
// Not a local? It's probably an object or code block. If it's an
// object, relocate it.
const ObjMap::iterator end = _objects.end();
for (ObjMap::iterator it = _objects.begin(); it != end; ++it)
if (it->_value.relocateSci0Sci21(segmentId, pos, getHeapOffset()))
break;
}
}
}
uint32 Script::getRelocationOffset(const uint32 offset) const {
if (getSciVersion() == SCI_VERSION_3) {
SciSpan<const byte> relocStart = _buf->subspan(_buf->getUint32SEAt(8));
const uint relocCount = _buf->getUint16SEAt(18);
for (uint i = 0; i < relocCount; ++i) {
if (offset == relocStart.getUint32SEAt(0)) {
return relocStart.getUint32SEAt(4);
}
relocStart += 10;
}
} else {
const SciSpan<const uint16> relocTable = getRelocationTableSci0Sci21();
for (uint i = 0; i < relocTable.size(); ++i) {
if (relocTable.getUint16SEAt(i) == offset) {
return getHeapOffset();
}
}
}
return kNoRelocation;
}
void GfxPalette::createFromData(const SciSpan<const byte> &data, Palette *paletteOut) const {
int palFormat = 0;
uint palOffset = 0;
uint palColorStart = 0;
uint palColorCount = 0;
uint colorNo = 0;
memset(paletteOut, 0, sizeof(Palette));
// Setup 1:1 mapping
for (colorNo = 0; colorNo < 256; colorNo++) {
paletteOut->mapping[colorNo] = colorNo;
}
if (data.size() < 37) {
// This happens when loading palette of picture 0 in sq5 - the resource is broken and doesn't contain a full
// palette
debugC(kDebugLevelResMan, "GfxPalette::createFromData() - not enough bytes in resource (%u), expected palette header", data.size());
return;
}
// palette formats in here are not really version exclusive, we can not use sci-version to differentiate between them
// they were just called that way, because they started appearing in sci1.1 for example
if ((data[0] == 0 && data[1] == 1) || (data[0] == 0 && data[1] == 0 && data.getUint16SEAt(29) == 0)) {
// SCI0/SCI1 palette
palFormat = SCI_PAL_FORMAT_VARIABLE; // CONSTANT;
palOffset = 260;
palColorStart = 0; palColorCount = 256;
//memcpy(&paletteOut->mapping, data, 256);
} else {
// SCI1.1 palette
palFormat = data[32];
palOffset = 37;
palColorStart = data[25];
palColorCount = data.getUint16SEAt(29);
}
switch (palFormat) {
case SCI_PAL_FORMAT_CONSTANT:
// Check, if enough bytes left
if (data.size() < palOffset + (3 * palColorCount)) {
warning("GfxPalette::createFromData() - not enough bytes in resource, expected palette colors");
return;
}
for (colorNo = palColorStart; colorNo < palColorStart + palColorCount; colorNo++) {
paletteOut->colors[colorNo].used = 1;
paletteOut->colors[colorNo].r = data[palOffset++];
paletteOut->colors[colorNo].g = data[palOffset++];
paletteOut->colors[colorNo].b = data[palOffset++];
}
break;
case SCI_PAL_FORMAT_VARIABLE:
if (data.size() < palOffset + (4 * palColorCount)) {
warning("GfxPalette::createFromData() - not enough bytes in resource, expected palette colors");
return;
}
for (colorNo = palColorStart; colorNo < palColorStart + palColorCount; colorNo++) {
paletteOut->colors[colorNo].used = data[palOffset++];
paletteOut->colors[colorNo].r = data[palOffset++];
paletteOut->colors[colorNo].g = data[palOffset++];
paletteOut->colors[colorNo].b = data[palOffset++];
}
break;
}
}
void Script::initializeClasses(SegManager *segMan) {
SciSpan<const byte> seeker;
uint16 mult = 0;
if (getSciVersion() <= SCI_VERSION_1_LATE) {
seeker = _script;
mult = 1;
// SCI0 early has an extra two bytes of header
if (getSciVersion() == SCI_VERSION_0_EARLY) {
seeker += 2;
}
} else if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1_LATE) {
seeker = _heap.subspan(4 + _heap.getUint16SEAt(2) * 2);
mult = 2;
#ifdef ENABLE_SCI32
} else if (getSciVersion() == SCI_VERSION_3) {
seeker = getSci3ObjectsPointer();
mult = 1;
#endif
}
if (!seeker)
return;
uint16 marker;
bool isClass = false;
uint32 classpos;
int16 species = 0;
for (;;) {
// In SCI0-SCI1, this is the segment type. In SCI11, it's a marker (0x1234)
marker = seeker.getUint16SEAt(0);
classpos = seeker - *_buf;
if (getSciVersion() <= SCI_VERSION_1_LATE && !marker)
break;
if (getSciVersion() >= SCI_VERSION_1_1 && marker != SCRIPT_OBJECT_MAGIC_NUMBER)
break;
if (getSciVersion() <= SCI_VERSION_1_LATE) {
isClass = (marker == SCI_OBJ_CLASS);
if (isClass)
species = seeker.getUint16SEAt(12);
classpos += 12;
} else if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1_LATE) {
isClass = (seeker.getUint16SEAt(14) & kInfoFlagClass); // -info- selector
species = seeker.getUint16SEAt(10);
} else if (getSciVersion() == SCI_VERSION_3) {
isClass = (seeker.getUint16SEAt(10) & kInfoFlagClass);
species = seeker.getUint16SEAt(4);
}
if (isClass) {
// WORKAROUNDs for off-by-one script errors
if (species == (int)segMan->classTableSize()) {
if (g_sci->getGameId() == GID_LSL2 && g_sci->isDemo())
segMan->resizeClassTable(species + 1);
else if (g_sci->getGameId() == GID_LSL3 && !g_sci->isDemo() && _nr == 500)
segMan->resizeClassTable(species + 1);
else if (g_sci->getGameId() == GID_SQ3 && !g_sci->isDemo() && _nr == 93)
segMan->resizeClassTable(species + 1);
else if (g_sci->getGameId() == GID_SQ3 && !g_sci->isDemo() && _nr == 99)
segMan->resizeClassTable(species + 1);
}
if (species < 0 || species >= (int)segMan->classTableSize())
error("Invalid species %d(0x%x) unknown max %d(0x%x) while instantiating script %d",
species, species, segMan->classTableSize(), segMan->classTableSize(), _nr);
segMan->setClassOffset(species, make_reg32(segMan->getScriptSegment(_nr), classpos));
}
seeker += seeker.getUint16SEAt(2) * mult;
}
}
void Script::load(int script_nr, ResourceManager *resMan, ScriptPatcher *scriptPatcher) {
freeScript();
Resource *script = resMan->findResource(ResourceId(kResourceTypeScript, script_nr), false);
if (!script)
error("Script %d not found", script_nr);
_nr = script_nr;
uint32 scriptSize = script->size();
uint32 bufSize = scriptSize;
if (getSciVersion() == SCI_VERSION_0_EARLY) {
bufSize += script->getUint16LEAt(0) * 2;
} else if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1_LATE) {
// In SCI1.1 - SCI2.1, the heap was in a separate space from the script. We append
// it to the end of the script, and adjust addressing accordingly.
// However, since we address the heap with a 16-bit pointer, the
// combined size of the stack and the heap must be 64KB. So far this has
// worked for SCI11, SCI2 and SCI21 games. SCI3 games use a different
// script format, and they can exceed the 64KB boundary using relocation.
Resource *heap = resMan->findResource(ResourceId(kResourceTypeHeap, script_nr), false);
bufSize += heap->size();
// Ensure that the start of the heap resource can be word-aligned.
if (script->size() & 2) {
++bufSize;
++scriptSize;
}
// As mentioned above, the script and the heap together should not exceed 64KB
if (script->size() + heap->size() > 65535)
error("Script and heap %d sizes combined exceed 64K. This means a fundamental "
"design bug was made regarding SCI1.1 and newer games.\n"
"Please report this error to the ScummVM team", script_nr);
} else if (getSciVersion() == SCI_VERSION_3 && script->size() > 0x3FFFF) {
error("Script %d size exceeds 256K (it is %u bytes).\n"
"Please report this error to the ScummVM team", script_nr, script->size());
}
uint extraLocalsWorkaround = 0;
if (g_sci->getGameId() == GID_FANMADE && _nr == 1 && script->size() == 11140) {
// WORKAROUND: Script 1 in Ocean Battle doesn't have enough locals to
// fit the string showing how many shots are left (a nasty script bug,
// corrupting heap memory). We add 10 more locals so that it has enough
// space to use as the target for its kFormat operation. Fixes bug
// #3059871.
extraLocalsWorkaround = 10;
}
bufSize += extraLocalsWorkaround * 2;
SciSpan<byte> outBuffer = _buf->allocate(bufSize, script->name() + " buffer");
script->copyDataTo(outBuffer);
// The word-aligned script size is used here because other parts of the code
// currently rely on finding the start of the heap by reading the script
// size
_script = _buf->subspan(0, scriptSize, script->name());
if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1_LATE) {
Resource *heap = resMan->findResource(ResourceId(kResourceTypeHeap, _nr), false);
assert(heap);
SciSpan<byte> outHeap = outBuffer.subspan(scriptSize, heap->size(), heap->name(), 0);
heap->copyDataTo(outHeap);
_heap = outHeap;
}
// Check scripts (+ possibly SCI 1.1 heap) for matching signatures and patch those, if found
scriptPatcher->processScript(_nr, outBuffer);
if (getSciVersion() <= SCI_VERSION_1_LATE) {
// Some buggy game scripts contain two export tables (e.g. script 912
// in Camelot and script 306 in KQ4); in these scripts, the first table
// is broken, so we ignore it and use the last one instead
// Fixes bugs #3039785 and #3037595.
SciSpan<const uint16> exportTable = findBlockSCI0(SCI_OBJ_EXPORTS, true).subspan<const uint16>(0);
if (exportTable) {
// The export table is after the block header (4 bytes / 2 uint16s)
// and the number of exports (2 bytes / 1 uint16).
// The exports span does not need to be explicitly sized since the
// maximum size was already determined by findBlockSCI0
_exports = exportTable.subspan(3);
_numExports = exportTable.getUint16SEAt(2);
}
SciSpan<const byte> synonymTable = findBlockSCI0(SCI_OBJ_SYNONYMS);
if (synonymTable) {
// the synonyms table is after the block header (4 bytes),
// and each synonym entry is 4 bytes
_synonyms = synonymTable.subspan(4);
_numSynonyms = _synonyms.size() / 4;
}
SciSpan<const byte> localsTable = findBlockSCI0(SCI_OBJ_LOCALVARS);
if (localsTable) {
// skip header (4 bytes)
_localsOffset = localsTable - *_buf + 4;
_localsCount = localsTable.size() / 2 - 2;
}
} else if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1_LATE) {
_numExports = _buf->getUint16SEAt(kSci11NumExportsOffset);
if (_numExports) {
_exports = _buf->subspan<const uint16>(kSci11ExportTableOffset, _numExports * sizeof(uint16));
}
_localsOffset = getHeapOffset() + 4;
_localsCount = _buf->getUint16SEAt(_localsOffset - 2);
} else if (getSciVersion() == SCI_VERSION_3) {
_localsCount = _buf->getUint16LEAt(12);
_numExports = _buf->getUint16LEAt(20);
if (_numExports) {
_exports = _buf->subspan<const uint16>(22, _numExports * sizeof(uint16));
}
// SCI3 local variables always start dword-aligned
if (_numExports % 2)
_localsOffset = 22 + _numExports * sizeof(uint16);
else
_localsOffset = 24 + _numExports * sizeof(uint16);
}
// WORKAROUND: Increase locals, if needed (check above)
_localsCount += extraLocalsWorkaround;
if (getSciVersion() == SCI_VERSION_0_EARLY) {
// SCI0 early
// Old script block. There won't be a localvar block in this case.
// Instead, the script starts with a 16 bit int specifying the
// number of locals we need; these are then allocated and zeroed.
_localsCount = _buf->getUint16LEAt(0);
_localsOffset = -_localsCount * 2; // Make sure it's invalid
} else {
// SCI0 late and newer
// Does the script actually have locals? If not, set the locals offset to 0
if (!_localsCount)
_localsOffset = 0;
if (_localsOffset + _localsCount * 2 + 1 >= (int)_buf->size()) {
error("Locals extend beyond end of script %d: offset %04x, count %u vs size %u", _nr, _localsOffset, _localsCount, _buf->size());
}
}
// find all strings of this script
identifyOffsets();
}
const SciSpan<const uint16> Script::getRelocationTableSci0Sci21() const {
SciSpan<const byte> relocationBlock;
uint16 numEntries;
uint16 dataOffset;
if (getSciVersion() < SCI_VERSION_1_1) {
relocationBlock = findBlockSCI0(SCI_OBJ_POINTERS);
if (!relocationBlock) {
return SciSpan<const uint16>();
}
if (relocationBlock != findBlockSCI0(SCI_OBJ_POINTERS, true)) {
warning("Script %d has multiple relocation tables", _nr);
}
numEntries = relocationBlock.getUint16SEAt(4);
if (!numEntries) {
return SciSpan<const uint16>();
}
dataOffset = 6;
// Starting somewhere around SQ1, and continuing through the rest of
// SCI1, the relocation table in scripts started including an extra
// null entry at the beginning of the table, without a corresponding
// increase in the entry count. While this change is consistent in
// most of the SCI1mid+ games (all scripts in LSL1, Jones CD,
// EQ floppy, SQ1, LSL5, and Ms Astro Chicken have the null entry),
// a few games include scripts without the null entry (Castle of Dr
// Brain 947 & 997, PQ3 997, KQ5 CD 975 & 997). Since 0 is never a
// valid relocation offset, we just skip it if we see it
const uint16 firstEntry = relocationBlock.getUint16SEAt(6);
if (firstEntry == 0) {
dataOffset += 2;
}
} else if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1_LATE) {
relocationBlock = _heap.subspan(_heap.getUint16SEAt(0));
if (!relocationBlock) {
return SciSpan<const uint16>();
}
numEntries = relocationBlock.getUint16SEAt(0);
if (!numEntries) {
return SciSpan<const uint16>();
}
dataOffset = 2;
} else {
error("Invalid engine version called Script::getRelocationTableSci0Sci21 on script %d", _nr);
}
// This check should work correctly even with SCI1.1+ because the relocation
// table is always at the very end of the heap in these games
if (dataOffset + numEntries * sizeof(uint16) != relocationBlock.size()) {
warning("Script %d unexpected relocation table size %u", _nr, relocationBlock.size());
}
return relocationBlock.subspan<const uint16>(dataOffset, numEntries * sizeof(uint16));
}
void Script::identifyOffsets() {
offsetLookupArrayEntry arrayEntry;
SciSpan<const byte> scriptDataPtr;
SciSpan<const byte> stringStartPtr;
SciSpan<const byte> stringDataPtr;
byte stringDataByte = 0;
uint16 typeObject_id = 0;
uint16 typeString_id = 0;
uint16 typeSaid_id = 0;
uint16 blockType = 0;
uint16 blockSize = 0;
_offsetLookupArray.clear();
_offsetLookupObjectCount = 0;
_offsetLookupStringCount = 0;
_offsetLookupSaidCount = 0;
_codeOffset = 0;
if (getSciVersion() < SCI_VERSION_1_1) {
// SCI0 + SCI1
scriptDataPtr = *_buf;
// Go through all blocks
if (getSciVersion() == SCI_VERSION_0_EARLY) {
if (scriptDataPtr.size() < 2)
error("Script::identifyOffsets(): unexpected end of script %d", _nr);
scriptDataPtr += 2;
}
for (;;) {
if (scriptDataPtr.size() < 2)
error("Script::identifyOffsets(): unexpected end of script %d", _nr);
blockType = scriptDataPtr.getUint16LEAt(0);
scriptDataPtr += 2;
if (blockType == 0) // end of blocks detected
break;
if (scriptDataPtr.size() < 2)
error("Script::identifyOffsets(): unexpected end of script %d", _nr);
blockSize = scriptDataPtr.getUint16LEAt(0);
if (blockSize < 4)
error("Script::identifyOffsets(): invalid block size in script %d", _nr);
blockSize -= 4; // block size includes block-type UINT16 and block-size UINT16
scriptDataPtr += 2;
if (scriptDataPtr.size() < blockSize)
error("Script::identifyOffsets(): invalid block size in script %d", _nr);
switch (blockType) {
case SCI_OBJ_OBJECT:
case SCI_OBJ_CLASS:
typeObject_id++;
arrayEntry.type = SCI_SCR_OFFSET_TYPE_OBJECT;
arrayEntry.id = typeObject_id;
arrayEntry.offset = scriptDataPtr - *_buf + 8; // Calculate offset inside script data (VM uses +8)
arrayEntry.stringSize = 0;
_offsetLookupArray.push_back(arrayEntry);
_offsetLookupObjectCount++;
break;
case SCI_OBJ_STRINGS:
// string block detected, we now grab all NUL terminated strings out of this block
stringDataPtr = scriptDataPtr.subspan(0, blockSize);
arrayEntry.type = SCI_SCR_OFFSET_TYPE_STRING;
for (;;) {
if (stringDataPtr.size() < 1) // no more bytes left
break;
stringStartPtr = stringDataPtr;
if (stringDataPtr.size() == 1) {
// only 1 byte left and that byte is a [00], in that case we also exit
stringDataByte = *stringStartPtr;
if (stringDataByte == 0x00)
break;
}
// now look for terminating [NUL]
for (;;) {
stringDataByte = *stringDataPtr;
stringDataPtr++;
if (!stringDataByte) // NUL found, exit this loop
break;
if (stringDataPtr.size() < 1) {
// no more bytes left
warning("Script::identifyOffsets(): string without terminating NUL in script %d", _nr);
break;
}
}
if (stringDataByte)
break;
typeString_id++;
arrayEntry.id = typeString_id;
arrayEntry.offset = stringStartPtr - *_buf; // Calculate offset inside script data
arrayEntry.stringSize = stringDataPtr - stringStartPtr;
_offsetLookupArray.push_back(arrayEntry);
_offsetLookupStringCount++;
}
break;
case SCI_OBJ_SAID:
// said block detected, we now try to find every single said "string" inside this block
// said strings are terminated with a 0xFF, the string itself may contain words (2 bytes), where
// the second byte of a word may also be a 0xFF.
stringDataPtr = scriptDataPtr.subspan(0, blockSize);
arrayEntry.type = SCI_SCR_OFFSET_TYPE_SAID;
for (;;) {
if (stringDataPtr.size() < 1) // no more bytes left
break;
stringStartPtr = stringDataPtr;
if (stringDataPtr.size() == 1) {
// only 1 byte left and that byte is a [00], in that case we also exit
// happens in some scripts, for example Conquests of Camelot, script 997
// may have been a bug in the compiler or just an intentional filler byte
stringDataByte = *stringStartPtr;
if (stringDataByte == 0x00)
break;
}
// now look for terminating 0xFF
for (;;) {
stringDataByte = *stringDataPtr;
stringDataPtr++;
if (stringDataByte == 0xFF) // Terminator found, exit this loop
break;
if (stringDataPtr.size() < 1) // no more bytes left
error("Script::identifyOffsets(): said-string without terminator in script %d", _nr);
if (stringDataByte < 0xF0) {
// Part of a word, skip second byte
stringDataPtr++;
if (stringDataPtr.size() < 1) // no more bytes left
error("Script::identifyOffsets(): said-string without terminator in script %d", _nr);
}
}
typeSaid_id++;
arrayEntry.id = typeSaid_id;
arrayEntry.offset = stringStartPtr - *_buf; // Calculate offset inside script data
arrayEntry.stringSize = 0;
_offsetLookupArray.push_back(arrayEntry);
_offsetLookupSaidCount++;
}
break;
default:
break;
}
scriptDataPtr += blockSize;
}
} else if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1_LATE) {
// Strings in SCI1.1 up to SCI2 come after the object instances
scriptDataPtr = _heap;
enum {
kExportSize = sizeof(uint16),
kPropertySize = sizeof(uint16),
kNumMethodsSize = sizeof(uint16),
kPropDictEntrySize = 2,
kMethDictEntrySize = 4
};
SciSpan<const byte> hunkPtr = _buf->subspan(kSci11ExportTableOffset + _numExports * kExportSize);
if (scriptDataPtr.size() < 4)
error("Script::identifyOffsets(): unexpected end of script in script %d", _nr);
uint16 endOfStringOffset = scriptDataPtr.getUint16SEAt(0);
uint16 objectStartOffset = scriptDataPtr.getUint16SEAt(2) * 2 + 4;
if (scriptDataPtr.size() < objectStartOffset)
error("Script::identifyOffsets(): object start is beyond heap size in script %d", _nr);
if (scriptDataPtr.size() < endOfStringOffset)
error("Script::identifyOffsets(): end of string is beyond heap size in script %d", _nr);
SciSpan<const byte> endOfStringPtr = scriptDataPtr.subspan(endOfStringOffset);
scriptDataPtr += objectStartOffset;
// go through all objects
for (;;) {
if (scriptDataPtr.size() < 2)
error("Script::identifyOffsets(): unexpected end of script %d", _nr);
blockType = scriptDataPtr.getUint16SEAt(0);
scriptDataPtr += 2;
if (blockType != SCRIPT_OBJECT_MAGIC_NUMBER)
break;
// Object found, add offset of object
typeObject_id++;
arrayEntry.type = SCI_SCR_OFFSET_TYPE_OBJECT;
arrayEntry.id = typeObject_id;
arrayEntry.offset = scriptDataPtr - *_buf - 2; // the VM uses a pointer to the Magic-Number
arrayEntry.stringSize = 0;
_offsetLookupArray.push_back(arrayEntry);
_offsetLookupObjectCount++;
if (scriptDataPtr.size() < 2)
error("Script::identifyOffsets(): unexpected end of script in script %d", _nr);
const uint16 numProperties = scriptDataPtr.getUint16SEAt(0);
blockSize = numProperties * kPropertySize;
if (blockSize < 4)
error("Script::identifyOffsets(): invalid block size in script %d", _nr);
scriptDataPtr += 2;
const uint16 scriptNum = scriptDataPtr.getUint16SEAt(6);
if (scriptNum != 0xFFFF) {
hunkPtr += numProperties * kPropDictEntrySize;
}
const uint16 numMethods = hunkPtr.getUint16SEAt(0);
hunkPtr += kNumMethodsSize + numMethods * kMethDictEntrySize;
blockSize -= 4; // blocksize contains UINT16 type and UINT16 size
if (scriptDataPtr.size() < blockSize)
error("Script::identifyOffsets(): invalid block size in script %d", _nr);
scriptDataPtr += blockSize;
}
_codeOffset = hunkPtr - *_buf;
// now scriptDataPtr points to right at the start of the strings
if (scriptDataPtr > endOfStringPtr)
error("Script::identifyOffsets(): string block / end-of-string block mismatch in script %d", _nr);
stringDataPtr = scriptDataPtr.subspan(0, endOfStringPtr - scriptDataPtr);
arrayEntry.type = SCI_SCR_OFFSET_TYPE_STRING;
for (;;) {
if (stringDataPtr.size() < 1) // no more bytes left
break;
stringStartPtr = stringDataPtr;
// now look for terminating [NUL]
for (;;) {
stringDataByte = *stringDataPtr;
stringDataPtr++;
if (!stringDataByte) // NUL found, exit this loop
break;
if (stringDataPtr.size() < 1) {
// no more bytes left
warning("Script::identifyOffsets(): string without terminating NUL in script %d", _nr);
break;
}
}
if (stringDataByte)
break;
typeString_id++;
arrayEntry.id = typeString_id;
arrayEntry.offset = stringStartPtr - *_buf; // Calculate offset inside script data
arrayEntry.stringSize = stringDataPtr - stringStartPtr;
_offsetLookupArray.push_back(arrayEntry);
_offsetLookupStringCount++;
}
#ifdef ENABLE_SCI32
} else if (getSciVersion() == SCI_VERSION_3) {
// SCI3
uint32 sci3StringOffset = 0;
uint32 sci3RelocationOffset = 0;
uint32 sci3BoundaryOffset = 0;
if (_buf->size() < 22)
error("Script::identifyOffsets(): script %d smaller than expected SCI3-header", _nr);
_codeOffset = _buf->getUint32LEAt(0);
sci3StringOffset = _buf->getUint32LEAt(4);
sci3RelocationOffset = _buf->getUint32LEAt(8);
if (sci3RelocationOffset > _buf->size())
error("Script::identifyOffsets(): relocation offset is beyond end of script %d", _nr);
// First we get all the objects
scriptDataPtr = getSci3ObjectsPointer();
for (;;) {
if (scriptDataPtr.size() < 2)
error("Script::identifyOffsets(): unexpected end of script %d", _nr);
blockType = scriptDataPtr.getUint16SEAt(0);
scriptDataPtr += 2;
if (blockType != SCRIPT_OBJECT_MAGIC_NUMBER)
break;
// Object found, add offset of object
typeObject_id++;
arrayEntry.type = SCI_SCR_OFFSET_TYPE_OBJECT;
arrayEntry.id = typeObject_id;
arrayEntry.offset = scriptDataPtr - *_buf - 2; // the VM uses a pointer to the Magic-Number
arrayEntry.stringSize = 0;
_offsetLookupArray.push_back(arrayEntry);
_offsetLookupObjectCount++;
if (scriptDataPtr.size() < 2)
error("Script::identifyOffsets(): unexpected end of script in script %d", _nr);
blockSize = scriptDataPtr.getUint16SEAt(0);
if (blockSize < 4)
error("Script::identifyOffsets(): invalid block size in script %d", _nr);
scriptDataPtr += 2;
blockSize -= 4; // blocksize contains UINT16 type and UINT16 size
if (scriptDataPtr.size() < blockSize)
error("Script::identifyOffsets(): invalid block size in script %d", _nr);
scriptDataPtr += blockSize;
}
// And now we get all the strings
if (sci3StringOffset > 0) {
// string offset set, we expect strings
if (sci3StringOffset > _buf->size())
error("Script::identifyOffsets(): string offset is beyond end of script %d", _nr);
if (sci3RelocationOffset < sci3StringOffset)
error("Script::identifyOffsets(): string offset points beyond relocation offset in script %d", _nr);
stringDataPtr = _buf->subspan(sci3StringOffset, sci3RelocationOffset - sci3StringOffset);
arrayEntry.type = SCI_SCR_OFFSET_TYPE_STRING;
for (;;) {
if (stringDataPtr.size() < 1) // no more bytes left
break;
stringStartPtr = stringDataPtr;
if (stringDataPtr.size() == 1) {
// only 1 byte left and that byte is a [00], in that case we also exit
stringDataByte = *stringStartPtr;
if (stringDataByte == 0x00)
break;
}
// now look for terminating [NUL]
for (;;) {
stringDataByte = *stringDataPtr;
stringDataPtr++;
if (!stringDataByte) // NUL found, exit this loop
break;
if (stringDataPtr.size() < 1) {
// no more bytes left
warning("Script::identifyOffsets(): string without terminating NUL in script %d", _nr);
break;
}
}
if (stringDataByte)
break;
typeString_id++;
arrayEntry.id = typeString_id;
arrayEntry.offset = stringStartPtr - *_buf; // Calculate offset inside script data
arrayEntry.stringSize = stringDataPtr - stringStartPtr;
_offsetLookupArray.push_back(arrayEntry);
_offsetLookupStringCount++;
// SCI3 seems to have aligned all string on DWORD boundaries
sci3BoundaryOffset = stringDataPtr - *_buf; // Calculate current offset inside script data
sci3BoundaryOffset = sci3BoundaryOffset & 3; // Check boundary offset
if (sci3BoundaryOffset) {
// lower 2 bits are set? Then we have to adjust the offset
sci3BoundaryOffset = 4 - sci3BoundaryOffset;
if (stringDataPtr.size() < sci3BoundaryOffset)
error("Script::identifyOffsets(): SCI3 string boundary adjustment goes beyond end of string block in script %d", _nr);
stringDataPtr += sci3BoundaryOffset;
}
}
}
#endif
}
}
void Script::initializeObjectsSci11(SegManager *segMan, SegmentId segmentId) {
SciSpan<const byte> seeker = _heap.subspan(4 + _heap.getUint16SEAt(2) * 2);
Common::Array<reg_t> mismatchedVarCountObjects;
while (seeker.getUint16SEAt(0) == SCRIPT_OBJECT_MAGIC_NUMBER) {
reg_t reg = make_reg(segmentId, seeker - *_buf);
Object *obj = scriptObjInit(reg);
// Copy base from species class, as we need its selector IDs
obj->setSuperClassSelector(
segMan->getClassAddress(obj->getSuperClassSelector().getOffset(), SCRIPT_GET_LOCK, 0));
// -propDict- is used by Obj::isMemberOf to determine if an object
// is an instance of a class. For classes, we therefore relocate
// -propDict- to the script's segment. For instances, we copy
// -propDict- from its class.
// Example test case - room 381 of sq4cd - if isMemberOf() doesn't work,
// talk-clicks on the robot will act like clicking on ego.
if (obj->isClass()) {
reg_t propDict = obj->getPropDictSelector();
propDict.setSegment(segmentId);
obj->setPropDictSelector(propDict);
} else {
reg_t classObject = obj->getSuperClassSelector();
const Object *classObj = segMan->getObject(classObject);
obj->setPropDictSelector(classObj->getPropDictSelector());
// At least some versions of Island of Dr Brain have a bMessager
// instance in script 0 with a var count greater than that of its
// class; warn about this here to see if it shows up in any other
// games
if (obj->getVarCount() != classObj->getVarCount()) {
// Warnings have to be deferred until after relocation for the
// object name to be resolvable
mismatchedVarCountObjects.push_back(reg);
}
}
// Set the -classScript- selector to the script number.
// FIXME: As this selector is filled in at run-time, it is likely
// that it is supposed to hold a pointer. The Obj::isKindOf method
// uses this selector together with -propDict- to compare classes.
// For the purpose of Obj::isKindOf, using the script number appears
// to be sufficient.
obj->setClassScriptSelector(make_reg(0, _nr));
seeker += seeker.getUint16SEAt(2) * 2;
}
relocateSci0Sci21(segmentId);
for (uint i = 0; i < mismatchedVarCountObjects.size(); ++i) {
const reg_t pos = mismatchedVarCountObjects[i];
const Object *obj = segMan->getObject(pos);
reg_t classObject = obj->getSuperClassSelector();
const Object *classObj = segMan->getObject(classObject);
warning("Object %04x:%04x (%s) from %s declares %d variables, "
"but its class declares %d variables",
PRINT_REG(pos),
segMan->getObjectName(pos),
_buf->name().c_str(),
obj->getVarCount(),
classObj->getVarCount());
}
}
