mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-13 21:31:53 +00:00
9414d7a6e2
Some backends may break as I only compiled SDL
823 lines
22 KiB
C++
823 lines
22 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.
|
|
*
|
|
* $URL$
|
|
* $Id$
|
|
*
|
|
*/
|
|
|
|
#include "mohawk/console.h"
|
|
#include "mohawk/graphics.h"
|
|
#include "mohawk/livingbooks.h"
|
|
#include "mohawk/sound.h"
|
|
#include "mohawk/video.h"
|
|
|
|
#include "common/system.h"
|
|
|
|
#ifdef ENABLE_CSTIME
|
|
#include "mohawk/cstime.h"
|
|
#endif
|
|
|
|
#ifdef ENABLE_MYST
|
|
#include "mohawk/myst.h"
|
|
#include "mohawk/myst_areas.h"
|
|
#include "mohawk/myst_scripts.h"
|
|
#endif
|
|
|
|
#ifdef ENABLE_RIVEN
|
|
#include "mohawk/riven.h"
|
|
#include "mohawk/riven_external.h"
|
|
#endif
|
|
|
|
namespace Mohawk {
|
|
|
|
#ifdef ENABLE_MYST
|
|
|
|
MystConsole::MystConsole(MohawkEngine_Myst *vm) : GUI::Debugger(), _vm(vm) {
|
|
DCmd_Register("changeCard", WRAP_METHOD(MystConsole, Cmd_ChangeCard));
|
|
DCmd_Register("curCard", WRAP_METHOD(MystConsole, Cmd_CurCard));
|
|
DCmd_Register("var", WRAP_METHOD(MystConsole, Cmd_Var));
|
|
DCmd_Register("curStack", WRAP_METHOD(MystConsole, Cmd_CurStack));
|
|
DCmd_Register("changeStack", WRAP_METHOD(MystConsole, Cmd_ChangeStack));
|
|
DCmd_Register("drawImage", WRAP_METHOD(MystConsole, Cmd_DrawImage));
|
|
DCmd_Register("drawRect", WRAP_METHOD(MystConsole, Cmd_DrawRect));
|
|
DCmd_Register("setResourceEnable", WRAP_METHOD(MystConsole, Cmd_SetResourceEnable));
|
|
DCmd_Register("playSound", WRAP_METHOD(MystConsole, Cmd_PlaySound));
|
|
DCmd_Register("stopSound", WRAP_METHOD(MystConsole, Cmd_StopSound));
|
|
DCmd_Register("playMovie", WRAP_METHOD(MystConsole, Cmd_PlayMovie));
|
|
DCmd_Register("disableInitOpcodes", WRAP_METHOD(MystConsole, Cmd_DisableInitOpcodes));
|
|
DCmd_Register("cache", WRAP_METHOD(MystConsole, Cmd_Cache));
|
|
DCmd_Register("resources", WRAP_METHOD(MystConsole, Cmd_Resources));
|
|
}
|
|
|
|
MystConsole::~MystConsole() {
|
|
}
|
|
|
|
bool MystConsole::Cmd_ChangeCard(int argc, const char **argv) {
|
|
if (argc < 2) {
|
|
DebugPrintf("Usage: changeCard <card>\n");
|
|
return true;
|
|
}
|
|
|
|
_vm->_sound->stopSound();
|
|
_vm->changeToCard((uint16)atoi(argv[1]), true);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool MystConsole::Cmd_CurCard(int argc, const char **argv) {
|
|
DebugPrintf("Current Card: %d\n", _vm->getCurCard());
|
|
return true;
|
|
}
|
|
|
|
bool MystConsole::Cmd_Var(int argc, const char **argv) {
|
|
if (argc == 1) {
|
|
DebugPrintf("Usage: var <var> (<value>)\n");
|
|
return true;
|
|
}
|
|
|
|
if (argc > 2)
|
|
_vm->_scriptParser->setVarValue((uint16)atoi(argv[1]), (uint16)atoi(argv[2]));
|
|
|
|
DebugPrintf("%d = %d\n", (uint16)atoi(argv[1]), _vm->_scriptParser->getVar((uint16)atoi(argv[1])));
|
|
|
|
return true;
|
|
}
|
|
|
|
static const char *mystStackNames[12] = {
|
|
"Channelwood",
|
|
"Credits",
|
|
"Demo",
|
|
"D'ni",
|
|
"Intro",
|
|
"MakingOf",
|
|
"Mechanical",
|
|
"Myst",
|
|
"Selenitic",
|
|
"Slideshow",
|
|
"SneakPreview",
|
|
"Stoneship"
|
|
};
|
|
|
|
static const uint16 default_start_card[12] = {
|
|
3137,
|
|
10000,
|
|
2001, // TODO: Should be 2000?
|
|
5038,
|
|
2, // TODO: Should be 1?
|
|
1,
|
|
6122,
|
|
4134,
|
|
1282,
|
|
1000,
|
|
3000,
|
|
2029
|
|
};
|
|
|
|
bool MystConsole::Cmd_CurStack(int argc, const char **argv) {
|
|
DebugPrintf("Current Stack: %s\n", mystStackNames[_vm->getCurStack()]);
|
|
return true;
|
|
}
|
|
|
|
bool MystConsole::Cmd_ChangeStack(int argc, const char **argv) {
|
|
if (argc != 2 && argc != 3) {
|
|
DebugPrintf("Usage: changeStack <stack> [<card>]\n\n");
|
|
DebugPrintf("Stacks:\n=======\n");
|
|
|
|
for (byte i = 0; i < ARRAYSIZE(mystStackNames); i++)
|
|
DebugPrintf(" %s\n", mystStackNames[i]);
|
|
|
|
DebugPrintf("\n");
|
|
|
|
return true;
|
|
}
|
|
|
|
byte stackNum = 0;
|
|
|
|
for (byte i = 1; i <= ARRAYSIZE(mystStackNames); i++)
|
|
if (!scumm_stricmp(argv[1], mystStackNames[i - 1])) {
|
|
stackNum = i;
|
|
break;
|
|
}
|
|
|
|
if (!stackNum) {
|
|
DebugPrintf("\'%s\' is not a stack name!\n", argv[1]);
|
|
return true;
|
|
}
|
|
|
|
// We need to stop any playing sound when we change the stack
|
|
// as the next card could continue playing it if it.
|
|
_vm->_sound->stopSound();
|
|
|
|
uint16 card = 0;
|
|
if (argc == 3)
|
|
card = (uint16)atoi(argv[2]);
|
|
else
|
|
card = default_start_card[stackNum - 1];
|
|
|
|
_vm->changeToStack(stackNum - 1, card, 0, 0);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool MystConsole::Cmd_DrawImage(int argc, const char **argv) {
|
|
if (argc != 2 && argc != 6) {
|
|
DebugPrintf("Usage: drawImage <image> [<left> <top> <right> <bottom>]\n");
|
|
return true;
|
|
}
|
|
|
|
Common::Rect rect;
|
|
|
|
if (argc == 2)
|
|
rect = Common::Rect(0, 0, 544, 333);
|
|
else
|
|
rect = Common::Rect((uint16)atoi(argv[2]), (uint16)atoi(argv[3]), (uint16)atoi(argv[4]), (uint16)atoi(argv[5]));
|
|
|
|
_vm->_gfx->copyImageToScreen((uint16)atoi(argv[1]), rect);
|
|
_vm->_system->updateScreen();
|
|
return false;
|
|
}
|
|
|
|
bool MystConsole::Cmd_DrawRect(int argc, const char **argv) {
|
|
if (argc != 5 && argc != 2) {
|
|
DebugPrintf("Usage: drawRect <left> <top> <right> <bottom>\n");
|
|
DebugPrintf("Usage: drawRect <resource id>\n");
|
|
return true;
|
|
}
|
|
|
|
if (argc == 5) {
|
|
_vm->_gfx->drawRect(Common::Rect((uint16)atoi(argv[1]), (uint16)atoi(argv[2]), (uint16)atoi(argv[3]), (uint16)atoi(argv[4])), kRectEnabled);
|
|
} else if (argc == 2) {
|
|
uint16 resourceId = (uint16)atoi(argv[1]);
|
|
if (resourceId < _vm->_resources.size())
|
|
_vm->_resources[resourceId]->drawBoundingRect();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool MystConsole::Cmd_SetResourceEnable(int argc, const char **argv) {
|
|
if (argc < 3) {
|
|
DebugPrintf("Usage: setResourceEnable <resource id> <bool>\n");
|
|
return true;
|
|
}
|
|
|
|
_vm->setResourceEnabled((uint16)atoi(argv[1]), atoi(argv[2]) == 1);
|
|
return true;
|
|
}
|
|
|
|
bool MystConsole::Cmd_PlaySound(int argc, const char **argv) {
|
|
if (argc == 1) {
|
|
DebugPrintf("Usage: playSound <value>\n");
|
|
|
|
return true;
|
|
}
|
|
|
|
_vm->_sound->replaceSoundMyst((uint16)atoi(argv[1]));
|
|
|
|
return false;
|
|
}
|
|
|
|
bool MystConsole::Cmd_StopSound(int argc, const char **argv) {
|
|
DebugPrintf("Stopping Sound\n");
|
|
|
|
_vm->_sound->stopSound();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool MystConsole::Cmd_PlayMovie(int argc, const char **argv) {
|
|
if (argc < 2) {
|
|
DebugPrintf("Usage: playMovie <name> [<stack>] [<left> <top>]\n");
|
|
DebugPrintf("NOTE: The movie will play *once* in the background.\n");
|
|
return true;
|
|
}
|
|
|
|
int8 stackNum = 0;
|
|
|
|
if (argc == 3 || argc > 4) {
|
|
for (byte i = 1; i <= ARRAYSIZE(mystStackNames); i++)
|
|
if (!scumm_stricmp(argv[2], mystStackNames[i - 1])) {
|
|
stackNum = i;
|
|
break;
|
|
}
|
|
|
|
if (!stackNum) {
|
|
DebugPrintf("\'%s\' is not a stack name!\n", argv[2]);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (argc == 2)
|
|
_vm->_video->playMovie(argv[1], 0, 0);
|
|
else if (argc == 3)
|
|
_vm->_video->playMovie(_vm->wrapMovieFilename(argv[1], stackNum - 1), 0, 0);
|
|
else if (argc == 4)
|
|
_vm->_video->playMovie(argv[1], atoi(argv[2]), atoi(argv[3]));
|
|
else
|
|
_vm->_video->playMovie(_vm->wrapMovieFilename(argv[1], stackNum - 1), atoi(argv[3]), atoi(argv[4]));
|
|
|
|
return false;
|
|
}
|
|
|
|
bool MystConsole::Cmd_DisableInitOpcodes(int argc, const char **argv) {
|
|
if (argc != 1) {
|
|
DebugPrintf("Usage: disableInitOpcodes\n");
|
|
|
|
return true;
|
|
}
|
|
|
|
_vm->_scriptParser->disablePersistentScripts();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool MystConsole::Cmd_Cache(int argc, const char **argv) {
|
|
if (argc > 2) {
|
|
DebugPrintf("Usage: cache on/off - Omit parameter to get current state\n");
|
|
return true;
|
|
}
|
|
|
|
bool state = false;
|
|
|
|
if (argc == 1) {
|
|
state = _vm->getCacheState();
|
|
} else {
|
|
if (!scumm_stricmp(argv[1], "on"))
|
|
state = true;
|
|
|
|
_vm->setCacheState(state);
|
|
}
|
|
|
|
DebugPrintf("Cache: %s\n", state ? "Enabled" : "Disabled");
|
|
return true;
|
|
}
|
|
|
|
bool MystConsole::Cmd_Resources(int argc, const char **argv) {
|
|
DebugPrintf("Resources in card %d:\n", _vm->getCurCard());
|
|
|
|
for (uint i = 0; i < _vm->_resources.size(); i++) {
|
|
DebugPrintf("#%2d %s\n", i, _vm->_resources[i]->describe().c_str());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endif // ENABLE_MYST
|
|
|
|
#ifdef ENABLE_RIVEN
|
|
|
|
RivenConsole::RivenConsole(MohawkEngine_Riven *vm) : GUI::Debugger(), _vm(vm) {
|
|
DCmd_Register("changeCard", WRAP_METHOD(RivenConsole, Cmd_ChangeCard));
|
|
DCmd_Register("curCard", WRAP_METHOD(RivenConsole, Cmd_CurCard));
|
|
DCmd_Register("var", WRAP_METHOD(RivenConsole, Cmd_Var));
|
|
DCmd_Register("playSound", WRAP_METHOD(RivenConsole, Cmd_PlaySound));
|
|
DCmd_Register("playSLST", WRAP_METHOD(RivenConsole, Cmd_PlaySLST));
|
|
DCmd_Register("stopSound", WRAP_METHOD(RivenConsole, Cmd_StopSound));
|
|
DCmd_Register("curStack", WRAP_METHOD(RivenConsole, Cmd_CurStack));
|
|
DCmd_Register("changeStack", WRAP_METHOD(RivenConsole, Cmd_ChangeStack));
|
|
DCmd_Register("hotspots", WRAP_METHOD(RivenConsole, Cmd_Hotspots));
|
|
DCmd_Register("zipMode", WRAP_METHOD(RivenConsole, Cmd_ZipMode));
|
|
DCmd_Register("dumpScript", WRAP_METHOD(RivenConsole, Cmd_DumpScript));
|
|
DCmd_Register("listZipCards", WRAP_METHOD(RivenConsole, Cmd_ListZipCards));
|
|
DCmd_Register("getRMAP", WRAP_METHOD(RivenConsole, Cmd_GetRMAP));
|
|
DCmd_Register("combos", WRAP_METHOD(RivenConsole, Cmd_Combos));
|
|
DCmd_Register("sliderState", WRAP_METHOD(RivenConsole, Cmd_SliderState));
|
|
}
|
|
|
|
RivenConsole::~RivenConsole() {
|
|
}
|
|
|
|
|
|
bool RivenConsole::Cmd_ChangeCard(int argc, const char **argv) {
|
|
if (argc < 2) {
|
|
DebugPrintf("Usage: changeCard <card>\n");
|
|
return true;
|
|
}
|
|
|
|
_vm->_sound->stopSound();
|
|
_vm->_sound->stopAllSLST();
|
|
_vm->changeToCard((uint16)atoi(argv[1]));
|
|
|
|
return false;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_CurCard(int argc, const char **argv) {
|
|
DebugPrintf("Current Card: %d\n", _vm->getCurCard());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_Var(int argc, const char **argv) {
|
|
if (argc == 1) {
|
|
DebugPrintf("Usage: var <var name> (<value>)\n");
|
|
return true;
|
|
}
|
|
|
|
if (!_vm->_vars.contains(argv[1])) {
|
|
DebugPrintf("Unknown variable '%s'\n", argv[1]);
|
|
return true;
|
|
}
|
|
|
|
uint32 &var = _vm->_vars[argv[1]];
|
|
|
|
if (argc > 2)
|
|
var = (uint32)atoi(argv[2]);
|
|
|
|
DebugPrintf("%s = %d\n", argv[1], var);
|
|
return true;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_PlaySound(int argc, const char **argv) {
|
|
if (argc < 2) {
|
|
DebugPrintf("Usage: playSound <value>\n");
|
|
return true;
|
|
}
|
|
|
|
_vm->_sound->stopSound();
|
|
_vm->_sound->stopAllSLST();
|
|
_vm->_sound->playSound((uint16)atoi(argv[1]));
|
|
return false;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_PlaySLST(int argc, const char **argv) {
|
|
if (argc < 2) {
|
|
DebugPrintf("Usage: playSLST <slst index> <card, default = current>\n");
|
|
|
|
return true;
|
|
}
|
|
|
|
_vm->_sound->stopSound();
|
|
_vm->_sound->stopAllSLST();
|
|
|
|
uint16 card = (argc == 3) ? (uint16)atoi(argv[2]) : _vm->getCurCard();
|
|
|
|
_vm->_sound->playSLST((uint16)atoi(argv[1]), card);
|
|
return false;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_StopSound(int argc, const char **argv) {
|
|
DebugPrintf("Stopping Sound\n");
|
|
|
|
_vm->_sound->stopSound();
|
|
_vm->_sound->stopAllSLST();
|
|
return true;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_CurStack(int argc, const char **argv) {
|
|
DebugPrintf("Current Stack: %s\n", _vm->getStackName(_vm->getCurStack()).c_str());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_ChangeStack(int argc, const char **argv) {
|
|
byte i;
|
|
|
|
if (argc < 3) {
|
|
DebugPrintf("Usage: changeStack <stack> <card>\n\n");
|
|
DebugPrintf("Stacks:\n=======\n");
|
|
|
|
for (i = 0; i <= tspit; i++)
|
|
DebugPrintf(" %s\n", _vm->getStackName(i).c_str());
|
|
|
|
DebugPrintf("\n");
|
|
|
|
return true;
|
|
}
|
|
|
|
byte stackNum = 0;
|
|
|
|
for (i = 1; i <= tspit + 1; i++)
|
|
if (!scumm_stricmp(argv[1], _vm->getStackName(i - 1).c_str())) {
|
|
stackNum = i;
|
|
break;
|
|
}
|
|
|
|
if (!stackNum) {
|
|
DebugPrintf("\'%s\' is not a stack name!\n", argv[1]);
|
|
return true;
|
|
}
|
|
|
|
_vm->changeToStack(stackNum - 1);
|
|
_vm->changeToCard((uint16)atoi(argv[2]));
|
|
|
|
return false;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_Hotspots(int argc, const char **argv) {
|
|
DebugPrintf("Current card (%d) has %d hotspots:\n", _vm->getCurCard(), _vm->getHotspotCount());
|
|
|
|
for (uint16 i = 0; i < _vm->getHotspotCount(); i++) {
|
|
DebugPrintf("Hotspot %d, index %d, BLST ID %d (", i, _vm->_hotspots[i].index, _vm->_hotspots[i].blstID);
|
|
|
|
if (_vm->_hotspots[i].enabled)
|
|
DebugPrintf("enabled");
|
|
else
|
|
DebugPrintf("disabled");
|
|
|
|
DebugPrintf(") - (%d, %d, %d, %d)\n", _vm->_hotspots[i].rect.left, _vm->_hotspots[i].rect.top, _vm->_hotspots[i].rect.right, _vm->_hotspots[i].rect.bottom);
|
|
DebugPrintf(" Name = %s\n", _vm->getHotspotName(i).c_str());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_ZipMode(int argc, const char **argv) {
|
|
uint32 &zipModeActive = _vm->_vars["azip"];
|
|
zipModeActive = !zipModeActive;
|
|
|
|
DebugPrintf("Zip Mode is ");
|
|
DebugPrintf(zipModeActive ? "Enabled" : "Disabled");
|
|
DebugPrintf("\n");
|
|
return true;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_DumpScript(int argc, const char **argv) {
|
|
if (argc < 4) {
|
|
DebugPrintf("Usage: dumpScript <stack> <CARD or HSPT> <card>\n");
|
|
return true;
|
|
}
|
|
|
|
uint16 oldStack = _vm->getCurStack();
|
|
|
|
byte newStack = 0;
|
|
|
|
for (byte i = 1; i <= tspit + 1; i++)
|
|
if (!scumm_stricmp(argv[1], _vm->getStackName(i - 1).c_str())) {
|
|
newStack = i;
|
|
break;
|
|
}
|
|
|
|
if (!newStack) {
|
|
DebugPrintf("\'%s\' is not a stack name!\n", argv[1]);
|
|
return true;
|
|
}
|
|
|
|
newStack--;
|
|
_vm->changeToStack(newStack);
|
|
|
|
// Load in Variable Names
|
|
Common::SeekableReadStream *nameStream = _vm->getResource(ID_NAME, VariableNames);
|
|
Common::StringArray varNames;
|
|
|
|
uint16 namesCount = nameStream->readUint16BE();
|
|
uint16 *stringOffsets = new uint16[namesCount];
|
|
for (uint16 i = 0; i < namesCount; i++)
|
|
stringOffsets[i] = nameStream->readUint16BE();
|
|
nameStream->seek(namesCount * 2, SEEK_CUR);
|
|
int32 curNamesPos = nameStream->pos();
|
|
|
|
for (uint32 i = 0; i < namesCount; i++) {
|
|
nameStream->seek(curNamesPos + stringOffsets[i]);
|
|
|
|
Common::String name;
|
|
for (char c = nameStream->readByte(); c; c = nameStream->readByte())
|
|
name += c;
|
|
varNames.push_back(name);
|
|
}
|
|
delete nameStream;
|
|
|
|
// Load in External Command Names
|
|
nameStream = _vm->getResource(ID_NAME, ExternalCommandNames);
|
|
Common::StringArray xNames;
|
|
|
|
namesCount = nameStream->readUint16BE();
|
|
stringOffsets = new uint16[namesCount];
|
|
for (uint16 i = 0; i < namesCount; i++)
|
|
stringOffsets[i] = nameStream->readUint16BE();
|
|
nameStream->seek(namesCount * 2, SEEK_CUR);
|
|
curNamesPos = nameStream->pos();
|
|
|
|
for (uint32 i = 0; i < namesCount; i++) {
|
|
nameStream->seek(curNamesPos + stringOffsets[i]);
|
|
|
|
Common::String name;
|
|
for (char c = nameStream->readByte(); c; c = nameStream->readByte())
|
|
name += c;
|
|
xNames.push_back(name);
|
|
}
|
|
delete nameStream;
|
|
|
|
// Get CARD/HSPT data and dump their scripts
|
|
if (!scumm_stricmp(argv[2], "CARD")) {
|
|
// Use debugN to print these because the scripts can get very large and would
|
|
// really be useless if the the text console is not used. A DumpFile could also
|
|
// theoretically be used, but I (clone2727) typically use this dynamically and
|
|
// don't want countless files laying around without game context. If one would
|
|
// want a file of a script they could just redirect stdout to a file or use
|
|
// deriven.
|
|
debugN("\n\nDumping scripts for %s\'s card %d!\n", argv[1], (uint16)atoi(argv[3]));
|
|
debugN("==================================\n\n");
|
|
Common::SeekableReadStream *cardStream = _vm->getResource(MKTAG('C','A','R','D'), (uint16)atoi(argv[3]));
|
|
cardStream->seek(4);
|
|
RivenScriptList scriptList = _vm->_scriptMan->readScripts(cardStream, false);
|
|
for (uint32 i = 0; i < scriptList.size(); i++) {
|
|
scriptList[i]->dumpScript(varNames, xNames, 0);
|
|
delete scriptList[i];
|
|
}
|
|
delete cardStream;
|
|
} else if (!scumm_stricmp(argv[2], "HSPT")) {
|
|
// See above for why this is printed via debugN
|
|
debugN("\n\nDumping scripts for %s\'s card %d hotspots!\n", argv[1], (uint16)atoi(argv[3]));
|
|
debugN("===========================================\n\n");
|
|
|
|
Common::SeekableReadStream *hsptStream = _vm->getResource(MKTAG('H','S','P','T'), (uint16)atoi(argv[3]));
|
|
|
|
uint16 hotspotCount = hsptStream->readUint16BE();
|
|
|
|
for (uint16 i = 0; i < hotspotCount; i++) {
|
|
debugN("Hotspot %d:\n", i);
|
|
hsptStream->seek(22, SEEK_CUR); // Skip non-script related stuff
|
|
RivenScriptList scriptList = _vm->_scriptMan->readScripts(hsptStream, false);
|
|
for (uint32 j = 0; j < scriptList.size(); j++) {
|
|
scriptList[j]->dumpScript(varNames, xNames, 1);
|
|
delete scriptList[j];
|
|
}
|
|
}
|
|
|
|
delete hsptStream;
|
|
} else {
|
|
DebugPrintf("%s doesn't have any scripts!\n", argv[2]);
|
|
}
|
|
|
|
// See above for why this is printed via debugN
|
|
debugN("\n\n");
|
|
|
|
_vm->changeToStack(oldStack);
|
|
|
|
DebugPrintf("Script dump complete.\n");
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_ListZipCards(int argc, const char **argv) {
|
|
if (_vm->_zipModeData.size() == 0) {
|
|
DebugPrintf("No zip card data.\n");
|
|
} else {
|
|
DebugPrintf("Listing zip cards:\n");
|
|
for (uint32 i = 0; i < _vm->_zipModeData.size(); i++)
|
|
DebugPrintf("ID = %d, Name = %s\n", _vm->_zipModeData[i].id, _vm->_zipModeData[i].name.c_str());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_GetRMAP(int argc, const char **argv) {
|
|
uint32 rmapCode = _vm->getCurCardRMAP();
|
|
DebugPrintf("RMAP for %s %d = %08x\n", _vm->getStackName(_vm->getCurStack()).c_str(), _vm->getCurCard(), rmapCode);
|
|
return true;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_Combos(int argc, const char **argv) {
|
|
// In the vain of SCUMM's 'drafts' command, this command will list
|
|
// out all combinations needed in Riven, decoded from the variables.
|
|
// You'll need to look up the Rebel Tunnel puzzle on your own; the
|
|
// solution is constant.
|
|
|
|
uint32 teleCombo = _vm->_vars["tcorrectorder"];
|
|
uint32 prisonCombo = _vm->_vars["pcorrectorder"];
|
|
uint32 domeCombo = _vm->_vars["adomecombo"];
|
|
|
|
DebugPrintf("Telescope Combo:\n ");
|
|
for (int i = 0; i < 5; i++)
|
|
DebugPrintf("%d ", _vm->_externalScriptHandler->getComboDigit(teleCombo, i));
|
|
|
|
DebugPrintf("\nPrison Combo:\n ");
|
|
for (int i = 0; i < 5; i++)
|
|
DebugPrintf("%d ", _vm->_externalScriptHandler->getComboDigit(prisonCombo, i));
|
|
|
|
DebugPrintf("\nDome Combo:\n ");
|
|
for (int i = 1; i <= 25; i++)
|
|
if (domeCombo & (1 << (25 - i)))
|
|
DebugPrintf("%d ", i);
|
|
|
|
DebugPrintf("\n");
|
|
return true;
|
|
}
|
|
|
|
bool RivenConsole::Cmd_SliderState(int argc, const char **argv) {
|
|
if (argc > 1)
|
|
_vm->_externalScriptHandler->setDomeSliderState((uint32)atoi(argv[1]));
|
|
|
|
DebugPrintf("Dome Slider State = %08x\n", _vm->_externalScriptHandler->getDomeSliderState());
|
|
return true;
|
|
}
|
|
|
|
#endif // ENABLE_RIVEN
|
|
|
|
LivingBooksConsole::LivingBooksConsole(MohawkEngine_LivingBooks *vm) : GUI::Debugger(), _vm(vm) {
|
|
DCmd_Register("playSound", WRAP_METHOD(LivingBooksConsole, Cmd_PlaySound));
|
|
DCmd_Register("stopSound", WRAP_METHOD(LivingBooksConsole, Cmd_StopSound));
|
|
DCmd_Register("drawImage", WRAP_METHOD(LivingBooksConsole, Cmd_DrawImage));
|
|
DCmd_Register("changePage", WRAP_METHOD(LivingBooksConsole, Cmd_ChangePage));
|
|
}
|
|
|
|
LivingBooksConsole::~LivingBooksConsole() {
|
|
}
|
|
|
|
bool LivingBooksConsole::Cmd_PlaySound(int argc, const char **argv) {
|
|
if (argc == 1) {
|
|
DebugPrintf("Usage: playSound <value>\n");
|
|
return true;
|
|
}
|
|
|
|
_vm->_sound->stopSound();
|
|
_vm->_sound->playSound((uint16)atoi(argv[1]));
|
|
return false;
|
|
}
|
|
|
|
bool LivingBooksConsole::Cmd_StopSound(int argc, const char **argv) {
|
|
DebugPrintf("Stopping Sound\n");
|
|
|
|
_vm->_sound->stopSound();
|
|
return true;
|
|
}
|
|
|
|
bool LivingBooksConsole::Cmd_DrawImage(int argc, const char **argv) {
|
|
if (argc == 1) {
|
|
DebugPrintf("Usage: drawImage <value>\n");
|
|
return true;
|
|
}
|
|
|
|
_vm->_gfx->copyAnimImageToScreen((uint16)atoi(argv[1]));
|
|
_vm->_system->updateScreen();
|
|
return false;
|
|
}
|
|
|
|
bool LivingBooksConsole::Cmd_ChangePage(int argc, const char **argv) {
|
|
if (argc == 1) {
|
|
DebugPrintf("Usage: changePage <page> [<mode>]\n");
|
|
return true;
|
|
}
|
|
|
|
if (_vm->tryLoadPageStart(argc == 2 ? _vm->getCurMode() : (LBMode)atoi(argv[2]), atoi(argv[1])))
|
|
return false;
|
|
DebugPrintf("no such page %d\n", atoi(argv[1]));
|
|
return true;
|
|
}
|
|
|
|
#ifdef ENABLE_CSTIME
|
|
|
|
CSTimeConsole::CSTimeConsole(MohawkEngine_CSTime *vm) : GUI::Debugger(), _vm(vm) {
|
|
DCmd_Register("playSound", WRAP_METHOD(CSTimeConsole, Cmd_PlaySound));
|
|
DCmd_Register("stopSound", WRAP_METHOD(CSTimeConsole, Cmd_StopSound));
|
|
DCmd_Register("drawImage", WRAP_METHOD(CSTimeConsole, Cmd_DrawImage));
|
|
DCmd_Register("drawSubimage", WRAP_METHOD(CSTimeConsole, Cmd_DrawSubimage));
|
|
DCmd_Register("changeCase", WRAP_METHOD(CSTimeConsole, Cmd_ChangeCase));
|
|
DCmd_Register("changeScene", WRAP_METHOD(CSTimeConsole, Cmd_ChangeScene));
|
|
DCmd_Register("caseVariable", WRAP_METHOD(CSTimeConsole, Cmd_CaseVariable));
|
|
DCmd_Register("invItem", WRAP_METHOD(CSTimeConsole, Cmd_InvItem));
|
|
}
|
|
|
|
CSTimeConsole::~CSTimeConsole() {
|
|
}
|
|
|
|
bool CSTimeConsole::Cmd_PlaySound(int argc, const char **argv) {
|
|
if (argc == 1) {
|
|
DebugPrintf("Usage: playSound <value>\n");
|
|
return true;
|
|
}
|
|
|
|
_vm->_sound->stopSound();
|
|
_vm->_sound->playSound((uint16)atoi(argv[1]));
|
|
return false;
|
|
}
|
|
|
|
bool CSTimeConsole::Cmd_StopSound(int argc, const char **argv) {
|
|
DebugPrintf("Stopping Sound\n");
|
|
|
|
_vm->_sound->stopSound();
|
|
return true;
|
|
}
|
|
|
|
bool CSTimeConsole::Cmd_DrawImage(int argc, const char **argv) {
|
|
if (argc == 1) {
|
|
DebugPrintf("Usage: drawImage <value>\n");
|
|
return true;
|
|
}
|
|
|
|
_vm->_gfx->copyAnimImageToScreen((uint16)atoi(argv[1]));
|
|
_vm->_system->updateScreen();
|
|
return false;
|
|
}
|
|
|
|
bool CSTimeConsole::Cmd_DrawSubimage(int argc, const char **argv) {
|
|
if (argc < 3) {
|
|
DebugPrintf("Usage: drawSubimage <value> <subimage>\n");
|
|
return true;
|
|
}
|
|
|
|
_vm->_gfx->copyAnimSubImageToScreen((uint16)atoi(argv[1]), (uint16)atoi(argv[2]));
|
|
_vm->_system->updateScreen();
|
|
return false;
|
|
}
|
|
|
|
bool CSTimeConsole::Cmd_ChangeCase(int argc, const char **argv) {
|
|
if (argc < 2) {
|
|
DebugPrintf("Usage: changeCase <value>\n");
|
|
return true;
|
|
}
|
|
|
|
error("Can't change case yet"); // FIXME
|
|
return false;
|
|
}
|
|
|
|
bool CSTimeConsole::Cmd_ChangeScene(int argc, const char **argv) {
|
|
if (argc < 2) {
|
|
DebugPrintf("Usage: changeScene <value>\n");
|
|
return true;
|
|
}
|
|
|
|
_vm->addEvent(CSTimeEvent(kCSTimeEventNewScene, 0xffff, atoi(argv[1])));
|
|
return false;
|
|
}
|
|
|
|
bool CSTimeConsole::Cmd_CaseVariable(int argc, const char **argv) {
|
|
if (argc < 2) {
|
|
DebugPrintf("Usage: caseVariable <id> [<value>]\n");
|
|
return true;
|
|
}
|
|
|
|
if (argc == 2) {
|
|
DebugPrintf("case variable %d has value %d\n", atoi(argv[1]), _vm->_caseVariable[atoi(argv[1])]);
|
|
} else {
|
|
_vm->_caseVariable[atoi(argv[1])] = atoi(argv[2]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CSTimeConsole::Cmd_InvItem(int argc, const char **argv) {
|
|
if (argc < 3) {
|
|
DebugPrintf("Usage: invItem <id> <0 or 1>\n");
|
|
return true;
|
|
}
|
|
|
|
if (atoi(argv[2])) {
|
|
_vm->addEvent(CSTimeEvent(kCSTimeEventDropItemInInventory, 0xffff, atoi(argv[1])));
|
|
} else {
|
|
_vm->addEvent(CSTimeEvent(kCSTimeEventRemoveItemFromInventory, 0xffff, atoi(argv[1])));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#endif // ENABLE_CSTIME
|
|
|
|
} // End of namespace Mohawk
|