23fc7f52e0
Fixes several problems with the SoundResource class: - Constructor doesn't fully initialize object if resource doesn't exist - Destructor crashes if object not fully initialized - Constructor has no mechanism to report failure - Callers believe failure is reported by constructor returning null - SoundCommandParser::initSoundResource attempts to pre-detect failure insufficiently in the absence of a formal mechanism. SoundResource now always fully initializes, the destructor no longer accesses uninitialized memory, and an exists() method has been added which callers now test. SQ6 Mac can now progress past the main menu.
827 lines
25 KiB
C++
827 lines
25 KiB
C++
/* 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.
|
|
*
|
|
*/
|
|
|
|
#include "sci/engine/features.h"
|
|
#include "sci/engine/kernel.h"
|
|
#include "sci/engine/script.h"
|
|
#include "sci/engine/selector.h"
|
|
#include "sci/engine/vm.h"
|
|
|
|
#include "common/config-manager.h"
|
|
#include "common/file.h"
|
|
|
|
namespace Sci {
|
|
|
|
GameFeatures::GameFeatures(SegManager *segMan, Kernel *kernel) : _segMan(segMan), _kernel(kernel) {
|
|
_setCursorType = SCI_VERSION_NONE;
|
|
_doSoundType = SCI_VERSION_NONE;
|
|
_lofsType = SCI_VERSION_NONE;
|
|
_gfxFunctionsType = SCI_VERSION_NONE;
|
|
_messageFunctionType = SCI_VERSION_NONE;
|
|
_moveCountType = kMoveCountUninitialized;
|
|
#ifdef ENABLE_SCI32
|
|
_sci21KernelType = SCI_VERSION_NONE;
|
|
#endif
|
|
_usesCdTrack = Common::File::exists("cdaudio.map");
|
|
if (!ConfMan.getBool("use_cdaudio"))
|
|
_usesCdTrack = false;
|
|
_forceDOSTracks = false;
|
|
_pseudoMouseAbility = kPseudoMouseAbilityUninitialized;
|
|
}
|
|
|
|
reg_t GameFeatures::getDetectionAddr(const Common::String &objName, Selector slc, int methodNum) {
|
|
// Get address of target object
|
|
reg_t objAddr = _segMan->findObjectByName(objName, 0);
|
|
reg_t addr;
|
|
|
|
if (objAddr.isNull()) {
|
|
error("getDetectionAddr: %s object couldn't be found", objName.c_str());
|
|
return NULL_REG;
|
|
}
|
|
|
|
if (methodNum == -1) {
|
|
if (lookupSelector(_segMan, objAddr, slc, NULL, &addr) != kSelectorMethod) {
|
|
error("getDetectionAddr: target selector is not a method of object %s", objName.c_str());
|
|
return NULL_REG;
|
|
}
|
|
} else {
|
|
addr = _segMan->getObject(objAddr)->getFunction(methodNum);
|
|
}
|
|
|
|
return addr;
|
|
}
|
|
|
|
bool GameFeatures::autoDetectSoundType() {
|
|
// Look up the script address
|
|
reg_t addr = getDetectionAddr("Sound", SELECTOR(play));
|
|
|
|
if (!addr.getSegment())
|
|
return false;
|
|
|
|
uint32 offset = addr.getOffset();
|
|
Script *script = _segMan->getScript(addr.getSegment());
|
|
uint16 intParam = 0xFFFF;
|
|
bool foundTarget = false;
|
|
|
|
while (true) {
|
|
int16 opparams[4];
|
|
byte extOpcode;
|
|
byte opcode;
|
|
offset += readPMachineInstruction(script->getBuf(offset), extOpcode, opparams);
|
|
opcode = extOpcode >> 1;
|
|
|
|
// Check for end of script
|
|
if (opcode == op_ret || offset >= script->getBufSize())
|
|
break;
|
|
|
|
// The play method of the Sound object pushes the DoSound command that
|
|
// it will use just before it calls DoSound. We intercept that here in
|
|
// order to check what sound semantics are used, cause the position of
|
|
// the sound commands has changed at some point during SCI1 middle.
|
|
if (opcode == op_pushi) {
|
|
// Load the pushi parameter
|
|
intParam = opparams[0];
|
|
} else if (opcode == op_callk) {
|
|
uint16 kFuncNum = opparams[0];
|
|
|
|
// Late SCI1 games call kIsObject before kDoSound
|
|
if (kFuncNum == 6) { // kIsObject (SCI0-SCI11)
|
|
foundTarget = true;
|
|
} else if (kFuncNum == 45) { // kDoSound (SCI1)
|
|
// First, check which DoSound function is called by the play
|
|
// method of the Sound object
|
|
switch (intParam) {
|
|
case 1:
|
|
_doSoundType = SCI_VERSION_0_EARLY;
|
|
break;
|
|
case 7:
|
|
_doSoundType = SCI_VERSION_1_EARLY;
|
|
break;
|
|
case 8:
|
|
_doSoundType = SCI_VERSION_1_LATE;
|
|
break;
|
|
default:
|
|
// Unknown case... should never happen. We fall back to
|
|
// alternative detection here, which works in general, apart
|
|
// from some transitive games like Jones CD
|
|
_doSoundType = foundTarget ? SCI_VERSION_1_LATE : SCI_VERSION_1_EARLY;
|
|
break;
|
|
}
|
|
|
|
if (_doSoundType != SCI_VERSION_NONE)
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false; // not found
|
|
}
|
|
|
|
SciVersion GameFeatures::detectDoSoundType() {
|
|
if (_doSoundType == SCI_VERSION_NONE) {
|
|
if (getSciVersion() == SCI_VERSION_0_EARLY) {
|
|
// Almost all of the SCI0EARLY games use different sound resources than
|
|
// SCI0LATE. Although the last SCI0EARLY game (lsl2) uses SCI0LATE resources
|
|
_doSoundType = g_sci->getResMan()->detectEarlySound() ? SCI_VERSION_0_EARLY : SCI_VERSION_0_LATE;
|
|
#ifdef ENABLE_SCI32
|
|
} else if (getSciVersion() >= SCI_VERSION_2_1_MIDDLE &&
|
|
g_sci->getGameId() != GID_SQ6 &&
|
|
// Assuming MGDX uses SCI2.1early sound mode since SQ6 does
|
|
// and it was released earlier, but not verified (Phar Lap
|
|
// Windows-only release)
|
|
g_sci->getGameId() != GID_MOTHERGOOSEHIRES) {
|
|
_doSoundType = SCI_VERSION_2_1_MIDDLE;
|
|
} else if (getSciVersion() >= SCI_VERSION_2_1_EARLY) {
|
|
_doSoundType = SCI_VERSION_2_1_EARLY;
|
|
} else if (getSciVersion() >= SCI_VERSION_2) {
|
|
_doSoundType = SCI_VERSION_2;
|
|
#endif
|
|
} else if (SELECTOR(nodePtr) == -1) {
|
|
// No nodePtr selector, so this game is definitely using newer
|
|
// SCI0 sound code (i.e. SCI_VERSION_0_LATE)
|
|
_doSoundType = SCI_VERSION_0_LATE;
|
|
} else if (getSciVersion() >= SCI_VERSION_1_LATE) {
|
|
// All SCI1 late games use the newer doSound semantics
|
|
_doSoundType = SCI_VERSION_1_LATE;
|
|
} else {
|
|
if (!autoDetectSoundType()) {
|
|
warning("DoSound detection failed, taking an educated guess");
|
|
|
|
if (getSciVersion() >= SCI_VERSION_1_MIDDLE)
|
|
_doSoundType = SCI_VERSION_1_LATE;
|
|
else if (getSciVersion() > SCI_VERSION_01)
|
|
_doSoundType = SCI_VERSION_1_EARLY;
|
|
}
|
|
}
|
|
|
|
debugC(1, kDebugLevelSound, "Detected DoSound type: %s", getSciVersionDesc(_doSoundType));
|
|
}
|
|
|
|
return _doSoundType;
|
|
}
|
|
|
|
SciVersion GameFeatures::detectSetCursorType() {
|
|
if (_setCursorType == SCI_VERSION_NONE) {
|
|
if (getSciVersion() <= SCI_VERSION_1_MIDDLE) {
|
|
// SCI1 middle and older games never use cursor views
|
|
_setCursorType = SCI_VERSION_0_EARLY;
|
|
} else if (getSciVersion() >= SCI_VERSION_1_1) {
|
|
// SCI1.1 games always use cursor views
|
|
_setCursorType = SCI_VERSION_1_1;
|
|
} else { // SCI1 late game, detect cursor semantics
|
|
// If the Cursor object doesn't exist, we're using the SCI0 early
|
|
// kSetCursor semantics.
|
|
if (_segMan->findObjectByName("Cursor") == NULL_REG) {
|
|
_setCursorType = SCI_VERSION_0_EARLY;
|
|
debugC(1, kDebugLevelGraphics, "Detected SetCursor type: %s", getSciVersionDesc(_setCursorType));
|
|
return _setCursorType;
|
|
}
|
|
|
|
// Check for the existence of the handCursor object (first found).
|
|
// This is based on KQ5.
|
|
reg_t objAddr = _segMan->findObjectByName("handCursor", 0);
|
|
|
|
// If that doesn't exist, we assume it uses SCI1.1 kSetCursor semantics
|
|
if (objAddr == NULL_REG) {
|
|
_setCursorType = SCI_VERSION_1_1;
|
|
debugC(1, kDebugLevelGraphics, "Detected SetCursor type: %s", getSciVersionDesc(_setCursorType));
|
|
return _setCursorType;
|
|
}
|
|
|
|
// Now we check what the number variable holds in the handCursor
|
|
// object.
|
|
uint16 number = readSelectorValue(_segMan, objAddr, SELECTOR(number));
|
|
|
|
// If the number is 0, it uses views and therefore the SCI1.1
|
|
// kSetCursor semantics, otherwise it uses the SCI0 early kSetCursor
|
|
// semantics.
|
|
if (number == 0)
|
|
_setCursorType = SCI_VERSION_1_1;
|
|
else
|
|
_setCursorType = SCI_VERSION_0_EARLY;
|
|
}
|
|
|
|
debugC(1, kDebugLevelGraphics, "Detected SetCursor type: %s", getSciVersionDesc(_setCursorType));
|
|
}
|
|
|
|
return _setCursorType;
|
|
}
|
|
|
|
bool GameFeatures::autoDetectLofsType(Common::String gameSuperClassName, int methodNum) {
|
|
// Look up the script address
|
|
reg_t addr = getDetectionAddr(gameSuperClassName.c_str(), -1, methodNum);
|
|
|
|
if (!addr.getSegment())
|
|
return false;
|
|
|
|
uint32 offset = addr.getOffset();
|
|
Script *script = _segMan->getScript(addr.getSegment());
|
|
|
|
while (true) {
|
|
int16 opparams[4];
|
|
byte extOpcode;
|
|
byte opcode;
|
|
offset += readPMachineInstruction(script->getBuf(offset), extOpcode, opparams);
|
|
opcode = extOpcode >> 1;
|
|
|
|
// Check for end of script
|
|
if (opcode == op_ret || offset >= script->getBufSize())
|
|
break;
|
|
|
|
if (opcode == op_lofsa || opcode == op_lofss) {
|
|
// Load lofs operand
|
|
uint16 lofs = opparams[0];
|
|
|
|
// Check for going out of bounds when interpreting as abs/rel
|
|
if (lofs >= script->getBufSize())
|
|
_lofsType = SCI_VERSION_0_EARLY;
|
|
|
|
if ((signed)offset + (int16)lofs < 0)
|
|
_lofsType = SCI_VERSION_1_MIDDLE;
|
|
|
|
if ((signed)offset + (int16)lofs >= (signed)script->getBufSize())
|
|
_lofsType = SCI_VERSION_1_MIDDLE;
|
|
|
|
if (_lofsType != SCI_VERSION_NONE)
|
|
return true;
|
|
|
|
// If we reach here, we haven't been able to deduce the lofs
|
|
// parameter type so far.
|
|
}
|
|
}
|
|
|
|
return false; // not found
|
|
}
|
|
|
|
SciVersion GameFeatures::detectLofsType() {
|
|
if (_lofsType == SCI_VERSION_NONE) {
|
|
// This detection only works (and is only needed) for SCI 1
|
|
if (getSciVersion() <= SCI_VERSION_01) {
|
|
_lofsType = SCI_VERSION_0_EARLY;
|
|
return _lofsType;
|
|
}
|
|
|
|
if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1_LATE) {
|
|
// SCI1.1 type, i.e. we compensate for the fact that the heap is attached
|
|
// to the end of the script
|
|
_lofsType = SCI_VERSION_1_1;
|
|
return _lofsType;
|
|
}
|
|
|
|
if (getSciVersion() == SCI_VERSION_3) {
|
|
// SCI3 type, same as pre-SCI1.1, really, as there is no separate heap
|
|
// resource
|
|
_lofsType = SCI_VERSION_3;
|
|
return _lofsType;
|
|
}
|
|
|
|
// Find a function of the "Game" object (which is the game super class) which invokes lofsa/lofss
|
|
const Object *gameObject = _segMan->getObject(g_sci->getGameObject());
|
|
const Object *gameSuperObject = _segMan->getObject(gameObject->getSuperClassSelector());
|
|
bool found = false;
|
|
if (gameSuperObject) {
|
|
Common::String gameSuperClassName = _segMan->getObjectName(gameObject->getSuperClassSelector());
|
|
|
|
for (uint m = 0; m < gameSuperObject->getMethodCount(); m++) {
|
|
found = autoDetectLofsType(gameSuperClassName, m);
|
|
if (found)
|
|
break;
|
|
}
|
|
} else {
|
|
warning("detectLofsType(): Could not find superclass of game object");
|
|
}
|
|
|
|
if (!found) {
|
|
warning("detectLofsType(): failed, taking an educated guess");
|
|
|
|
if (getSciVersion() >= SCI_VERSION_1_MIDDLE)
|
|
_lofsType = SCI_VERSION_1_MIDDLE;
|
|
else
|
|
_lofsType = SCI_VERSION_0_EARLY;
|
|
}
|
|
|
|
debugC(1, kDebugLevelVM, "Detected Lofs type: %s", getSciVersionDesc(_lofsType));
|
|
}
|
|
|
|
return _lofsType;
|
|
}
|
|
|
|
bool GameFeatures::autoDetectGfxFunctionsType(int methodNum) {
|
|
// Look up the script address
|
|
reg_t addr = getDetectionAddr("Rm", SELECTOR(overlay), methodNum);
|
|
|
|
if (!addr.getSegment())
|
|
return false;
|
|
|
|
uint32 offset = addr.getOffset();
|
|
Script *script = _segMan->getScript(addr.getSegment());
|
|
|
|
while (true) {
|
|
int16 opparams[4];
|
|
byte extOpcode;
|
|
byte opcode;
|
|
offset += readPMachineInstruction(script->getBuf(offset), extOpcode, opparams);
|
|
opcode = extOpcode >> 1;
|
|
|
|
// Check for end of script
|
|
if (opcode == op_ret || offset >= script->getBufSize())
|
|
break;
|
|
|
|
if (opcode == op_callk) {
|
|
uint16 kFuncNum = opparams[0];
|
|
uint16 argc = opparams[1];
|
|
|
|
if (kFuncNum == 8) { // kDrawPic (SCI0 - SCI11)
|
|
// If kDrawPic is called with 6 parameters from the overlay
|
|
// selector, the game is using old graphics functions.
|
|
// Otherwise, if it's called with 8 parameters (e.g. SQ3) or 4 parameters
|
|
// (e.g. Hoyle 1/2), it's using new graphics functions.
|
|
_gfxFunctionsType = (argc == 6) ? SCI_VERSION_0_EARLY : SCI_VERSION_0_LATE;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false; // not found
|
|
}
|
|
|
|
SciVersion GameFeatures::detectGfxFunctionsType() {
|
|
if (_gfxFunctionsType == SCI_VERSION_NONE) {
|
|
if (getSciVersion() == SCI_VERSION_0_EARLY) {
|
|
// Old SCI0 games always used old graphics functions
|
|
_gfxFunctionsType = SCI_VERSION_0_EARLY;
|
|
} else if (getSciVersion() >= SCI_VERSION_01) {
|
|
// SCI01 and newer games always used new graphics functions
|
|
_gfxFunctionsType = SCI_VERSION_0_LATE;
|
|
} else { // SCI0 late
|
|
// Check if the game is using an overlay
|
|
bool searchRoomObj = false;
|
|
reg_t rmObjAddr = _segMan->findObjectByName("Rm");
|
|
|
|
if (SELECTOR(overlay) != -1) {
|
|
// The game has an overlay selector, check how it calls kDrawPic
|
|
// to determine the graphics functions type used
|
|
if (lookupSelector(_segMan, rmObjAddr, SELECTOR(overlay), NULL, NULL) == kSelectorMethod) {
|
|
if (!autoDetectGfxFunctionsType()) {
|
|
warning("Graphics functions detection failed, taking an educated guess");
|
|
|
|
// Try detecting the graphics function types from the
|
|
// existence of the motionCue selector (which is a bit
|
|
// of a hack)
|
|
if (_kernel->findSelector("motionCue") != -1)
|
|
_gfxFunctionsType = SCI_VERSION_0_LATE;
|
|
else
|
|
_gfxFunctionsType = SCI_VERSION_0_EARLY;
|
|
}
|
|
} else {
|
|
// The game has an overlay selector, but it's not a method
|
|
// of the Rm object (like in Hoyle 1 and 2), so search for
|
|
// other methods
|
|
searchRoomObj = true;
|
|
}
|
|
} else {
|
|
// The game doesn't have an overlay selector, so search for it
|
|
// manually
|
|
searchRoomObj = true;
|
|
}
|
|
|
|
if (searchRoomObj) {
|
|
// If requested, check if any method of the Rm object is calling
|
|
// kDrawPic, as the overlay selector might be missing in demos
|
|
bool found = false;
|
|
|
|
const Object *obj = _segMan->getObject(rmObjAddr);
|
|
for (uint m = 0; m < obj->getMethodCount(); m++) {
|
|
found = autoDetectGfxFunctionsType(m);
|
|
if (found)
|
|
break;
|
|
}
|
|
|
|
if (!found) {
|
|
// No method of the Rm object is calling kDrawPic, thus the
|
|
// game doesn't have overlays and is using older graphics
|
|
// functions
|
|
_gfxFunctionsType = SCI_VERSION_0_EARLY;
|
|
}
|
|
}
|
|
}
|
|
|
|
debugC(1, kDebugLevelVM, "Detected graphics functions type: %s", getSciVersionDesc(_gfxFunctionsType));
|
|
}
|
|
|
|
return _gfxFunctionsType;
|
|
}
|
|
|
|
SciVersion GameFeatures::detectMessageFunctionType() {
|
|
if (_messageFunctionType != SCI_VERSION_NONE)
|
|
return _messageFunctionType;
|
|
|
|
if (getSciVersion() > SCI_VERSION_1_1) {
|
|
_messageFunctionType = SCI_VERSION_1_1;
|
|
return _messageFunctionType;
|
|
} else if (getSciVersion() < SCI_VERSION_1_1) {
|
|
_messageFunctionType = SCI_VERSION_1_LATE;
|
|
return _messageFunctionType;
|
|
}
|
|
|
|
Common::List<ResourceId> resources = g_sci->getResMan()->listResources(kResourceTypeMessage, -1);
|
|
|
|
if (resources.empty()) {
|
|
// No messages found, so this doesn't really matter anyway...
|
|
_messageFunctionType = SCI_VERSION_1_1;
|
|
return _messageFunctionType;
|
|
}
|
|
|
|
Resource *res = g_sci->getResMan()->findResource(*resources.begin(), false);
|
|
assert(res);
|
|
|
|
// Only v2 Message resources use the kGetMessage kernel function.
|
|
// v3-v5 use the kMessage kernel function.
|
|
|
|
if (res->getUint32SEAt(0) / 1000 == 2)
|
|
_messageFunctionType = SCI_VERSION_1_LATE;
|
|
else
|
|
_messageFunctionType = SCI_VERSION_1_1;
|
|
|
|
debugC(1, kDebugLevelVM, "Detected message function type: %s", getSciVersionDesc(_messageFunctionType));
|
|
return _messageFunctionType;
|
|
}
|
|
|
|
#ifdef ENABLE_SCI32
|
|
bool GameFeatures::autoDetectSci21KernelType() {
|
|
// First, check if the Sound object is loaded
|
|
reg_t soundObjAddr = _segMan->findObjectByName("Sound");
|
|
if (soundObjAddr.isNull()) {
|
|
// Usually, this means that the Sound object isn't loaded yet.
|
|
// This case doesn't occur in early SCI2.1 games, and we've only
|
|
// seen it happen in the RAMA demo, thus we can assume that the
|
|
// game is using a SCI2.1 table
|
|
|
|
// HACK: The Inside the Chest Demo and King's Questions minigame
|
|
// don't have sounds at all, but they're using a SCI2 kernel
|
|
if (g_sci->getGameId() == GID_CHEST || g_sci->getGameId() == GID_KQUESTIONS) {
|
|
_sci21KernelType = SCI_VERSION_2;
|
|
} else if (g_sci->getGameId() == GID_RAMA && g_sci->isDemo()) {
|
|
_sci21KernelType = SCI_VERSION_2_1_MIDDLE;
|
|
} else {
|
|
warning("autoDetectSci21KernelType(): Sound object not loaded, assuming a SCI2.1 table");
|
|
_sci21KernelType = SCI_VERSION_2_1_EARLY;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Look up the script address
|
|
reg_t addr = getDetectionAddr("Sound", SELECTOR(play));
|
|
|
|
if (!addr.getSegment())
|
|
return false;
|
|
|
|
uint32 offset = addr.getOffset();
|
|
Script *script = _segMan->getScript(addr.getSegment());
|
|
|
|
while (true) {
|
|
int16 opparams[4];
|
|
byte extOpcode;
|
|
byte opcode;
|
|
offset += readPMachineInstruction(script->getBuf(offset), extOpcode, opparams);
|
|
opcode = extOpcode >> 1;
|
|
|
|
// Check for end of script
|
|
// We don't check for op_ret here because the Phantasmagoria Mac script
|
|
// has an op_ret early on in its script (controlled by a branch).
|
|
if (offset >= script->getBufSize())
|
|
break;
|
|
|
|
if (opcode == op_callk) {
|
|
uint16 kFuncNum = opparams[0];
|
|
|
|
// Here we check for the kDoSound opcode that's used in SCI2.1.
|
|
// Finding 0x40 as kDoSound in the Sound::play() function means the
|
|
// game is using the modified SCI2 kernel table found in some older
|
|
// SCI2.1 games (GK2 demo, KQ7 v1.4).
|
|
// Finding 0x75 as kDoSound means the game is using the regular
|
|
// SCI2.1 kernel table.
|
|
if (kFuncNum == 0x40) {
|
|
_sci21KernelType = SCI_VERSION_2;
|
|
return true;
|
|
} else if (kFuncNum == 0x75) {
|
|
_sci21KernelType = SCI_VERSION_2_1_EARLY;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false; // not found
|
|
}
|
|
|
|
SciVersion GameFeatures::detectSci21KernelType() {
|
|
if (_sci21KernelType == SCI_VERSION_NONE) {
|
|
if (!autoDetectSci21KernelType())
|
|
error("Could not detect the SCI2.1 kernel table type");
|
|
|
|
debugC(1, kDebugLevelVM, "Detected SCI2.1 kernel type: %s", getSciVersionDesc(_sci21KernelType));
|
|
}
|
|
return _sci21KernelType;
|
|
}
|
|
#endif
|
|
|
|
bool GameFeatures::supportsSpeechWithSubtitles() const {
|
|
switch (g_sci->getGameId()) {
|
|
case GID_SQ4:
|
|
case GID_FREDDYPHARKAS:
|
|
case GID_ECOQUEST:
|
|
case GID_LSL6:
|
|
case GID_LAURABOW2:
|
|
case GID_KQ6:
|
|
#ifdef ENABLE_SCI32
|
|
// TODO: SCI3
|
|
case GID_GK1:
|
|
case GID_KQ7:
|
|
case GID_LSL6HIRES:
|
|
case GID_LSL7:
|
|
case GID_PQ4:
|
|
case GID_QFG4:
|
|
case GID_SQ6:
|
|
case GID_TORIN:
|
|
#endif
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool GameFeatures::audioVolumeSyncUsesGlobals() const {
|
|
switch (g_sci->getGameId()) {
|
|
case GID_GK1:
|
|
case GID_GK2:
|
|
case GID_HOYLE5:
|
|
case GID_LSL6HIRES:
|
|
case GID_LSL7:
|
|
case GID_PHANTASMAGORIA:
|
|
case GID_PHANTASMAGORIA2:
|
|
case GID_RAMA:
|
|
case GID_TORIN:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
MessageTypeSyncStrategy GameFeatures::getMessageTypeSyncStrategy() const {
|
|
if (getSciVersion() < SCI_VERSION_1_1) {
|
|
return kMessageTypeSyncStrategyNone;
|
|
}
|
|
|
|
if (getSciVersion() == SCI_VERSION_1_1 && g_sci->isCD()) {
|
|
return kMessageTypeSyncStrategyDefault;
|
|
}
|
|
|
|
#ifdef ENABLE_SCI32
|
|
switch (g_sci->getGameId()) {
|
|
// TODO: SCI3
|
|
case GID_GK1:
|
|
case GID_PQ4:
|
|
case GID_QFG4:
|
|
return g_sci->isCD() ? kMessageTypeSyncStrategyDefault : kMessageTypeSyncStrategyNone;
|
|
|
|
case GID_KQ7:
|
|
case GID_LSL7:
|
|
case GID_MOTHERGOOSEHIRES:
|
|
case GID_PHANTASMAGORIA:
|
|
case GID_SQ6:
|
|
case GID_TORIN:
|
|
return kMessageTypeSyncStrategyDefault;
|
|
|
|
case GID_LSL6HIRES:
|
|
return kMessageTypeSyncStrategyLSL6Hires;
|
|
|
|
case GID_SHIVERS:
|
|
return kMessageTypeSyncStrategyShivers;
|
|
|
|
case GID_GK2:
|
|
case GID_PQSWAT:
|
|
default:
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
return kMessageTypeSyncStrategyNone;
|
|
}
|
|
|
|
int GameFeatures::detectPlaneIdBase() {
|
|
if (getSciVersion() == SCI_VERSION_2 &&
|
|
g_sci->getGameId() != GID_PQ4)
|
|
return 0;
|
|
else
|
|
return 20000;
|
|
}
|
|
|
|
bool GameFeatures::autoDetectMoveCountType() {
|
|
// Look up the script address
|
|
reg_t addr = getDetectionAddr("Motion", SELECTOR(doit));
|
|
|
|
if (!addr.getSegment())
|
|
return false;
|
|
|
|
uint32 offset = addr.getOffset();
|
|
Script *script = _segMan->getScript(addr.getSegment());
|
|
bool foundTarget = false;
|
|
|
|
while (true) {
|
|
int16 opparams[4];
|
|
byte extOpcode;
|
|
byte opcode;
|
|
offset += readPMachineInstruction(script->getBuf(offset), extOpcode, opparams);
|
|
opcode = extOpcode >> 1;
|
|
|
|
// Check for end of script
|
|
if (opcode == op_ret || offset >= script->getBufSize())
|
|
break;
|
|
|
|
if (opcode == op_callk) {
|
|
uint16 kFuncNum = opparams[0];
|
|
|
|
// Games which ignore move count call kAbs before calling kDoBresen
|
|
if (_kernel->getKernelName(kFuncNum) == "Abs") {
|
|
foundTarget = true;
|
|
} else if (_kernel->getKernelName(kFuncNum) == "DoBresen") {
|
|
_moveCountType = foundTarget ? kIgnoreMoveCount : kIncrementMoveCount;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false; // not found
|
|
}
|
|
|
|
MoveCountType GameFeatures::detectMoveCountType() {
|
|
if (_moveCountType == kMoveCountUninitialized) {
|
|
// SCI0/SCI01 games always increment move count
|
|
if (getSciVersion() <= SCI_VERSION_01) {
|
|
_moveCountType = kIncrementMoveCount;
|
|
} else if (getSciVersion() >= SCI_VERSION_1_1) {
|
|
// SCI1.1 and newer games always ignore move count
|
|
_moveCountType = kIgnoreMoveCount;
|
|
} else {
|
|
if (!autoDetectMoveCountType()) {
|
|
error("Move count autodetection failed");
|
|
}
|
|
}
|
|
|
|
debugC(1, kDebugLevelVM, "Detected move count handling: %s", (_moveCountType == kIncrementMoveCount) ? "increment" : "ignore");
|
|
}
|
|
|
|
return _moveCountType;
|
|
}
|
|
|
|
bool GameFeatures::useAltWinGMSound() {
|
|
if (g_sci && g_sci->getPlatform() == Common::kPlatformWindows && g_sci->isCD() && !_forceDOSTracks) {
|
|
SciGameId id = g_sci->getGameId();
|
|
return (id == GID_ECOQUEST ||
|
|
id == GID_JONES ||
|
|
id == GID_KQ5 ||
|
|
//id == GID_FREDDYPHARKAS || // Has alternate tracks, but handles them differently
|
|
id == GID_SQ4);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool GameFeatures::generalMidiOnly() {
|
|
#ifdef ENABLE_SCI32
|
|
switch (g_sci->getGameId()) {
|
|
case GID_MOTHERGOOSEHIRES:
|
|
return true;
|
|
case GID_KQ7: {
|
|
if (g_sci->isDemo()) {
|
|
return false;
|
|
}
|
|
|
|
SoundResource sound(13, g_sci->getResMan(), detectDoSoundType());
|
|
return (sound.exists() && sound.getTrackByType(/* AdLib */ 0) == nullptr);
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
return false;
|
|
}
|
|
|
|
// PseudoMouse was added during SCI1
|
|
// PseudoMouseAbility is about a tiny difference in the keyboard driver, which sets the event type to either
|
|
// 40h (old behaviour) or 44h (the keyboard driver actually added 40h to the existing value).
|
|
// See engine/kevent.cpp, kMapKeyToDir - also script 933
|
|
|
|
// SCI1EGA:
|
|
// Quest for Glory 2 still used the old way.
|
|
//
|
|
// SCI1EARLY:
|
|
// King's Quest 5 0.000.062 uses the old way.
|
|
// Leisure Suit Larry 1 demo uses the new way, but no PseudoMouse class.
|
|
// Fairy Tales uses the new way.
|
|
// X-Mas 1990 uses the old way, no PseudoMouse class.
|
|
// Space Quest 4 floppy (1.1) uses the new way.
|
|
// Mixed Up Mother Goose uses the old way, no PseudoMouse class.
|
|
//
|
|
// SCI1MIDDLE:
|
|
// Leisure Suit Larry 5 demo uses the new way.
|
|
// Conquests of the Longbow demo uses the new way.
|
|
// Leisure Suit Larry 1 (2.0) uses the new way.
|
|
// Astro Chicken II uses the new way.
|
|
PseudoMouseAbilityType GameFeatures::detectPseudoMouseAbility() {
|
|
if (_pseudoMouseAbility == kPseudoMouseAbilityUninitialized) {
|
|
if (getSciVersion() < SCI_VERSION_1_EARLY) {
|
|
// SCI1 EGA or earlier -> pseudo mouse ability is always disabled
|
|
_pseudoMouseAbility = kPseudoMouseAbilityFalse;
|
|
|
|
} else if (getSciVersion() == SCI_VERSION_1_EARLY) {
|
|
// For SCI1 early some games had it enabled, some others didn't.
|
|
// We try to find an object called "PseudoMouse". If it's found, we enable the ability otherwise we don't.
|
|
reg_t pseudoMouseAddr = _segMan->findObjectByName("PseudoMouse", 0);
|
|
|
|
if (pseudoMouseAddr != NULL_REG) {
|
|
_pseudoMouseAbility = kPseudoMouseAbilityTrue;
|
|
} else {
|
|
_pseudoMouseAbility = kPseudoMouseAbilityFalse;
|
|
}
|
|
|
|
} else {
|
|
// SCI1 middle or later -> pseudo mouse ability is always enabled
|
|
_pseudoMouseAbility = kPseudoMouseAbilityTrue;
|
|
}
|
|
}
|
|
return _pseudoMouseAbility;
|
|
}
|
|
|
|
// GetLongest(), which calculates the number of characters in a string that can fit
|
|
// within a width, had two subtle changes which started to appear in interpreters
|
|
// in late 1990. An off-by-one bug was fixed where the character that exceeds the
|
|
// width would be applied to the result if a space character hadn't been reached.
|
|
// The pixel width test was also changed from a greater than or equals to greater
|
|
// than, but again only if a space character hadn't been reached.
|
|
//
|
|
// The notebook in LB1 (bug #10000) is currently the only known script that depended
|
|
// on the original behavior. This appears to be an isolated fix to an interpreter
|
|
// edge case, a corresponding script change to allow autodetection hasn't been found.
|
|
//
|
|
// The Japanese interpreters have their own versions of GetLongest() to support
|
|
// double byte characters which seems to be how QFG1 Japanese reintroduced it
|
|
// even though its interpreter is later than SQ3/LSL3 multilingual versions.
|
|
bool GameFeatures::useEarlyGetLongestTextCalculations() const {
|
|
switch (getSciVersion()) {
|
|
|
|
// All SCI0, confirmed:
|
|
// - LSL2 English PC 1.000.011
|
|
// - LB1 PC 1.000.046
|
|
// - ICEMAN PC 1.033
|
|
// - SQ3 English PC 1.018
|
|
// - PQ2 Japanese 1.000.052
|
|
case SCI_VERSION_0_EARLY:
|
|
case SCI_VERSION_0_LATE:
|
|
return true;
|
|
|
|
// SCI01: confirmed KQ1 and QFG1 Japanese,
|
|
// fixed in SQ3 and LSL3 multilingual PC
|
|
case SCI_VERSION_01:
|
|
return (g_sci->getGameId() == GID_KQ1 || g_sci->getGameId() == GID_QFG1);
|
|
|
|
// QFG2, confirmed 1.000 and 1.105 (first and last versions)
|
|
case SCI_VERSION_1_EGA_ONLY:
|
|
return true;
|
|
|
|
// SCI1 Early: just KQ5 English PC versions,
|
|
// confirmed fixed in:
|
|
// - LSL1 Demo
|
|
// - XMAS1990 EGA
|
|
// - SQ4 1.052
|
|
case SCI_VERSION_1_EARLY:
|
|
return (g_sci->getGameId() == GID_KQ5);
|
|
|
|
// Fixed in all other versions
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
} // End of namespace Sci
|