thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ALL: Rename Debugger::DCmd_Register to Debugger::registerCmd.

Browse source
This commit is contained in:
Johannes Schickel 2014-05-27 02:04:08 +02:00
parent 0adca2c579
commit ae4ffe01f0
38 changed files with 498 additions and 498 deletions
Download patch file Download diff file Expand all files Collapse all files

40
engines/agi/console.cpp
View file

@ -32,22 +32,22 @@ namespace Agi {
Console::Console(AgiEngine *vm) : GUI::Debugger() {
_vm = vm;
DCmd_Register("debug", WRAP_METHOD(Console, Cmd_Debug));
DCmd_Register("cont", WRAP_METHOD(Console, Cmd_Cont));
DCmd_Register("agiver", WRAP_METHOD(Console, Cmd_Agiver));
DCmd_Register("flags", WRAP_METHOD(Console, Cmd_Flags));
DCmd_Register("logic0", WRAP_METHOD(Console, Cmd_Logic0));
DCmd_Register("objs", WRAP_METHOD(Console, Cmd_Objs));
DCmd_Register("runopcode", WRAP_METHOD(Console, Cmd_RunOpcode));
DCmd_Register("opcode", WRAP_METHOD(Console, Cmd_Opcode));
DCmd_Register("step", WRAP_METHOD(Console, Cmd_Step));
DCmd_Register("trigger", WRAP_METHOD(Console, Cmd_Trigger));
DCmd_Register("vars", WRAP_METHOD(Console, Cmd_Vars));
DCmd_Register("setvar", WRAP_METHOD(Console, Cmd_SetVar));
DCmd_Register("setflag", WRAP_METHOD(Console, Cmd_SetFlag));
DCmd_Register("setobj", WRAP_METHOD(Console, Cmd_SetObj));
DCmd_Register("room", WRAP_METHOD(Console, Cmd_Room));
DCmd_Register("bt", WRAP_METHOD(Console, Cmd_BT));
registerCmd("debug", WRAP_METHOD(Console, Cmd_Debug));
registerCmd("cont", WRAP_METHOD(Console, Cmd_Cont));
registerCmd("agiver", WRAP_METHOD(Console, Cmd_Agiver));
registerCmd("flags", WRAP_METHOD(Console, Cmd_Flags));
registerCmd("logic0", WRAP_METHOD(Console, Cmd_Logic0));
registerCmd("objs", WRAP_METHOD(Console, Cmd_Objs));
registerCmd("runopcode", WRAP_METHOD(Console, Cmd_RunOpcode));
registerCmd("opcode", WRAP_METHOD(Console, Cmd_Opcode));
registerCmd("step", WRAP_METHOD(Console, Cmd_Step));
registerCmd("trigger", WRAP_METHOD(Console, Cmd_Trigger));
registerCmd("vars", WRAP_METHOD(Console, Cmd_Vars));
registerCmd("setvar", WRAP_METHOD(Console, Cmd_SetVar));
registerCmd("setflag", WRAP_METHOD(Console, Cmd_SetFlag));
registerCmd("setobj", WRAP_METHOD(Console, Cmd_SetObj));
registerCmd("room", WRAP_METHOD(Console, Cmd_Room));
registerCmd("bt", WRAP_METHOD(Console, Cmd_BT));
}
bool Console::Cmd_SetVar(int argc, const char **argv) {
@ -271,9 +271,9 @@ bool Console::Cmd_BT(int argc, const char **argv) {
MickeyConsole::MickeyConsole(MickeyEngine *mickey) : GUI::Debugger() {
_mickey = mickey;
DCmd_Register("room", WRAP_METHOD(MickeyConsole, Cmd_Room));
DCmd_Register("drawPic", WRAP_METHOD(MickeyConsole, Cmd_DrawPic));
DCmd_Register("drawObj", WRAP_METHOD(MickeyConsole, Cmd_DrawObj));
registerCmd("room", WRAP_METHOD(MickeyConsole, Cmd_Room));
registerCmd("drawPic", WRAP_METHOD(MickeyConsole, Cmd_DrawPic));
registerCmd("drawObj", WRAP_METHOD(MickeyConsole, Cmd_DrawObj));
}
bool MickeyConsole::Cmd_Room(int argc, const char **argv) {
@ -304,7 +304,7 @@ bool MickeyConsole::Cmd_DrawObj(int argc, const char **argv) {
WinnieConsole::WinnieConsole(WinnieEngine *winnie) : GUI::Debugger() {
_winnie = winnie;
DCmd_Register("curRoom", WRAP_METHOD(WinnieConsole, Cmd_CurRoom));
registerCmd("curRoom", WRAP_METHOD(WinnieConsole, Cmd_CurRoom));
}
bool WinnieConsole::Cmd_CurRoom(int argc, const char **argv) {

24
engines/agos/debugger.cpp
View file

@ -32,18 +32,18 @@ Debugger::Debugger(AGOSEngine *vm)
: GUI::Debugger() {
_vm = vm;
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("music", WRAP_METHOD(Debugger, Cmd_PlayMusic));
DCmd_Register("sound", WRAP_METHOD(Debugger, Cmd_PlaySound));
DCmd_Register("voice", WRAP_METHOD(Debugger, Cmd_PlayVoice));
DCmd_Register("bit", WRAP_METHOD(Debugger, Cmd_SetBit));
DCmd_Register("bit2", WRAP_METHOD(Debugger, Cmd_SetBit2));
DCmd_Register("bit3", WRAP_METHOD(Debugger, Cmd_SetBit3));
DCmd_Register("var", WRAP_METHOD(Debugger, Cmd_SetVar));
DCmd_Register("obj", WRAP_METHOD(Debugger, Cmd_SetObjectFlag));
DCmd_Register("sub", WRAP_METHOD(Debugger, Cmd_StartSubroutine));
DCmd_Register("dumpimage", WRAP_METHOD(Debugger, Cmd_dumpImage));
DCmd_Register("dumpscript", WRAP_METHOD(Debugger, Cmd_dumpScript));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("music", WRAP_METHOD(Debugger, Cmd_PlayMusic));
registerCmd("sound", WRAP_METHOD(Debugger, Cmd_PlaySound));
registerCmd("voice", WRAP_METHOD(Debugger, Cmd_PlayVoice));
registerCmd("bit", WRAP_METHOD(Debugger, Cmd_SetBit));
registerCmd("bit2", WRAP_METHOD(Debugger, Cmd_SetBit2));
registerCmd("bit3", WRAP_METHOD(Debugger, Cmd_SetBit3));
registerCmd("var", WRAP_METHOD(Debugger, Cmd_SetVar));
registerCmd("obj", WRAP_METHOD(Debugger, Cmd_SetObjectFlag));
registerCmd("sub", WRAP_METHOD(Debugger, Cmd_StartSubroutine));
registerCmd("dumpimage", WRAP_METHOD(Debugger, Cmd_dumpImage));
registerCmd("dumpscript", WRAP_METHOD(Debugger, Cmd_dumpScript));
}

2
engines/avalanche/console.cpp
View file

@ -31,7 +31,7 @@
namespace Avalanche {
AvalancheConsole::AvalancheConsole(AvalancheEngine *vm) : GUI::Debugger(), _vm(vm) {
DCmd_Register("magic_lines", WRAP_METHOD(AvalancheConsole, Cmd_MagicLines));
registerCmd("magic_lines", WRAP_METHOD(AvalancheConsole, Cmd_MagicLines));
}
AvalancheConsole::~AvalancheConsole() {

2
engines/cge/console.cpp
View file

@ -26,7 +26,7 @@
namespace CGE {
CGEConsole::CGEConsole(CGEEngine *vm) : GUI::Debugger(), _vm(vm) {
DCmd_Register("Boundaries", WRAP_METHOD(CGEConsole, Cmd_boundaries));
registerCmd("Boundaries", WRAP_METHOD(CGEConsole, Cmd_boundaries));
}
CGEConsole::~CGEConsole() {

2
engines/cine/console.cpp
View file

@ -29,7 +29,7 @@ bool labyrinthCheat;
CineConsole::CineConsole(CineEngine *vm) : GUI::Debugger(), _vm(vm) {
assert(_vm);
DCmd_Register("labyrinthCheat", WRAP_METHOD(CineConsole, Cmd_LabyrinthCheat));
registerCmd("labyrinthCheat", WRAP_METHOD(CineConsole, Cmd_LabyrinthCheat));
labyrinthCheat = false;
}

6
engines/cruise/debugger.cpp
View file

@ -29,9 +29,9 @@
namespace Cruise {
Debugger::Debugger(): GUI::Debugger() {
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("hotspots", WRAP_METHOD(Debugger, cmd_hotspots));
DCmd_Register("items", WRAP_METHOD(Debugger, cmd_items));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("hotspots", WRAP_METHOD(Debugger, cmd_hotspots));
registerCmd("items", WRAP_METHOD(Debugger, cmd_items));
}
/**

2
engines/drascula/console.cpp
View file

@ -27,7 +27,7 @@
namespace Drascula {
Console::Console(DrasculaEngine *vm) : GUI::Debugger(), _vm(vm) {
DCmd_Register("room", WRAP_METHOD(Console, Cmd_Room));
registerCmd("room", WRAP_METHOD(Console, Cmd_Room));
}
Console::~Console() {

2
engines/fullpipe/console.cpp
View file

@ -28,7 +28,7 @@
namespace Fullpipe {
Console::Console(FullpipeEngine *vm) : GUI::Debugger(), _vm(vm) {
DCmd_Register("scene", WRAP_METHOD(Console, Cmd_Scene));
registerCmd("scene", WRAP_METHOD(Console, Cmd_Scene));
}
bool Console::Cmd_Scene(int argc, const char **argv) {

16
engines/gob/console.cpp
View file

@ -29,14 +29,14 @@
namespace Gob {
GobConsole::GobConsole(GobEngine *vm) : GUI::Debugger(), _vm(vm), _cheater(0) {
DCmd_Register("varSize", WRAP_METHOD(GobConsole, cmd_varSize));
DCmd_Register("dumpVars", WRAP_METHOD(GobConsole, cmd_dumpVars));
DCmd_Register("var8", WRAP_METHOD(GobConsole, cmd_var8));
DCmd_Register("var16", WRAP_METHOD(GobConsole, cmd_var16));
DCmd_Register("var32", WRAP_METHOD(GobConsole, cmd_var32));
DCmd_Register("varString", WRAP_METHOD(GobConsole, cmd_varString));
DCmd_Register("cheat", WRAP_METHOD(GobConsole, cmd_cheat));
DCmd_Register("listArchives", WRAP_METHOD(GobConsole, cmd_listArchives));
registerCmd("varSize", WRAP_METHOD(GobConsole, cmd_varSize));
registerCmd("dumpVars", WRAP_METHOD(GobConsole, cmd_dumpVars));
registerCmd("var8", WRAP_METHOD(GobConsole, cmd_var8));
registerCmd("var16", WRAP_METHOD(GobConsole, cmd_var16));
registerCmd("var32", WRAP_METHOD(GobConsole, cmd_var32));
registerCmd("varString", WRAP_METHOD(GobConsole, cmd_varString));
registerCmd("cheat", WRAP_METHOD(GobConsole, cmd_cheat));
registerCmd("listArchives", WRAP_METHOD(GobConsole, cmd_listArchives));
}
GobConsole::~GobConsole() {

20
engines/groovie/debug.cpp
View file

@ -36,16 +36,16 @@ Debugger::Debugger(GroovieEngine *vm) :
_vm(vm), _script(_vm->_script) {
// Register the debugger comands
DCmd_Register("step", WRAP_METHOD(Debugger, cmd_step));
DCmd_Register("go", WRAP_METHOD(Debugger, cmd_go));
DCmd_Register("pc", WRAP_METHOD(Debugger, cmd_pc));
DCmd_Register("fg", WRAP_METHOD(Debugger, cmd_fg));
DCmd_Register("bg", WRAP_METHOD(Debugger, cmd_bg));
DCmd_Register("mem", WRAP_METHOD(Debugger, cmd_mem));
DCmd_Register("load", WRAP_METHOD(Debugger, cmd_loadgame));
DCmd_Register("save", WRAP_METHOD(Debugger, cmd_savegame));
DCmd_Register("playref", WRAP_METHOD(Debugger, cmd_playref));
DCmd_Register("dumppal", WRAP_METHOD(Debugger, cmd_dumppal));
registerCmd("step", WRAP_METHOD(Debugger, cmd_step));
registerCmd("go", WRAP_METHOD(Debugger, cmd_go));
registerCmd("pc", WRAP_METHOD(Debugger, cmd_pc));
registerCmd("fg", WRAP_METHOD(Debugger, cmd_fg));
registerCmd("bg", WRAP_METHOD(Debugger, cmd_bg));
registerCmd("mem", WRAP_METHOD(Debugger, cmd_mem));
registerCmd("load", WRAP_METHOD(Debugger, cmd_loadgame));
registerCmd("save", WRAP_METHOD(Debugger, cmd_savegame));
registerCmd("playref", WRAP_METHOD(Debugger, cmd_playref));
registerCmd("dumppal", WRAP_METHOD(Debugger, cmd_dumppal));
}
Debugger::~Debugger() {

12
engines/hopkins/debugger.cpp
View file

@ -30,12 +30,12 @@ namespace Hopkins {
Debugger::Debugger(HopkinsEngine *vm) : GUI::Debugger() {
_vm = vm;
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("rects", WRAP_METHOD(Debugger, cmd_DirtyRects));
DCmd_Register("teleport", WRAP_METHOD(Debugger, cmd_Teleport));
DCmd_Register("show_room", WRAP_METHOD(Debugger, cmd_ShowCurrentRoom));
DCmd_Register("zones", WRAP_METHOD(Debugger, cmd_Zones));
DCmd_Register("lines", WRAP_METHOD(Debugger, cmd_Lines));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("rects", WRAP_METHOD(Debugger, cmd_DirtyRects));
registerCmd("teleport", WRAP_METHOD(Debugger, cmd_Teleport));
registerCmd("show_room", WRAP_METHOD(Debugger, cmd_ShowCurrentRoom));
registerCmd("zones", WRAP_METHOD(Debugger, cmd_Zones));
registerCmd("lines", WRAP_METHOD(Debugger, cmd_Lines));
}
// Turns dirty rects on or off

12
engines/hugo/console.cpp
View file

@ -30,12 +30,12 @@
namespace Hugo {
HugoConsole::HugoConsole(HugoEngine *vm) : GUI::Debugger(), _vm(vm) {
DCmd_Register("listscreens", WRAP_METHOD(HugoConsole, Cmd_listScreens));
DCmd_Register("listobjects", WRAP_METHOD(HugoConsole, Cmd_listObjects));
DCmd_Register("getobject", WRAP_METHOD(HugoConsole, Cmd_getObject));
DCmd_Register("getallobjects", WRAP_METHOD(HugoConsole, Cmd_getAllObjects));
DCmd_Register("gotoscreen", WRAP_METHOD(HugoConsole, Cmd_gotoScreen));
DCmd_Register("Boundaries", WRAP_METHOD(HugoConsole, Cmd_boundaries));
registerCmd("listscreens", WRAP_METHOD(HugoConsole, Cmd_listScreens));
registerCmd("listobjects", WRAP_METHOD(HugoConsole, Cmd_listObjects));
registerCmd("getobject", WRAP_METHOD(HugoConsole, Cmd_getObject));
registerCmd("getallobjects", WRAP_METHOD(HugoConsole, Cmd_getAllObjects));
registerCmd("gotoscreen", WRAP_METHOD(HugoConsole, Cmd_gotoScreen));
registerCmd("Boundaries", WRAP_METHOD(HugoConsole, Cmd_boundaries));
}
HugoConsole::~HugoConsole() {

62
engines/kyra/debugger.cpp
View file

@ -40,16 +40,16 @@ Debugger::Debugger(KyraEngine_v1 *vm)
}
void Debugger::initialize() {
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("screen_debug_mode", WRAP_METHOD(Debugger, cmd_setScreenDebug));
DCmd_Register("load_palette", WRAP_METHOD(Debugger, cmd_loadPalette));
DCmd_Register("facings", WRAP_METHOD(Debugger, cmd_showFacings));
DCmd_Register("gamespeed", WRAP_METHOD(Debugger, cmd_gameSpeed));
DCmd_Register("flags", WRAP_METHOD(Debugger, cmd_listFlags));
DCmd_Register("toggleflag", WRAP_METHOD(Debugger, cmd_toggleFlag));
DCmd_Register("queryflag", WRAP_METHOD(Debugger, cmd_queryFlag));
DCmd_Register("timers", WRAP_METHOD(Debugger, cmd_listTimers));
DCmd_Register("settimercountdown", WRAP_METHOD(Debugger, cmd_setTimerCountdown));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("screen_debug_mode", WRAP_METHOD(Debugger, cmd_setScreenDebug));
registerCmd("load_palette", WRAP_METHOD(Debugger, cmd_loadPalette));
registerCmd("facings", WRAP_METHOD(Debugger, cmd_showFacings));
registerCmd("gamespeed", WRAP_METHOD(Debugger, cmd_gameSpeed));
registerCmd("flags", WRAP_METHOD(Debugger, cmd_listFlags));
registerCmd("toggleflag", WRAP_METHOD(Debugger, cmd_toggleFlag));
registerCmd("queryflag", WRAP_METHOD(Debugger, cmd_queryFlag));
registerCmd("timers", WRAP_METHOD(Debugger, cmd_listTimers));
registerCmd("settimercountdown", WRAP_METHOD(Debugger, cmd_setTimerCountdown));
}
bool Debugger::cmd_setScreenDebug(int argc, const char **argv) {
@ -204,10 +204,10 @@ Debugger_LoK::Debugger_LoK(KyraEngine_LoK *vm)
}
void Debugger_LoK::initialize() {
DCmd_Register("enter", WRAP_METHOD(Debugger_LoK, cmd_enterRoom));
DCmd_Register("scenes", WRAP_METHOD(Debugger_LoK, cmd_listScenes));
DCmd_Register("give", WRAP_METHOD(Debugger_LoK, cmd_giveItem));
DCmd_Register("birthstones", WRAP_METHOD(Debugger_LoK, cmd_listBirthstones));
registerCmd("enter", WRAP_METHOD(Debugger_LoK, cmd_enterRoom));
registerCmd("scenes", WRAP_METHOD(Debugger_LoK, cmd_listScenes));
registerCmd("give", WRAP_METHOD(Debugger_LoK, cmd_giveItem));
registerCmd("birthstones", WRAP_METHOD(Debugger_LoK, cmd_listBirthstones));
Debugger::initialize();
}
@ -293,12 +293,12 @@ Debugger_v2::Debugger_v2(KyraEngine_v2 *vm) : Debugger(vm), _vm(vm) {
}
void Debugger_v2::initialize() {
DCmd_Register("character_info", WRAP_METHOD(Debugger_v2, cmd_characterInfo));
DCmd_Register("enter", WRAP_METHOD(Debugger_v2, cmd_enterScene));
DCmd_Register("scenes", WRAP_METHOD(Debugger_v2, cmd_listScenes));
DCmd_Register("scene_info", WRAP_METHOD(Debugger_v2, cmd_sceneInfo));
DCmd_Register("scene_to_facing", WRAP_METHOD(Debugger_v2, cmd_sceneToFacing));
DCmd_Register("give", WRAP_METHOD(Debugger_v2, cmd_giveItem));
registerCmd("character_info", WRAP_METHOD(Debugger_v2, cmd_characterInfo));
registerCmd("enter", WRAP_METHOD(Debugger_v2, cmd_enterScene));
registerCmd("scenes", WRAP_METHOD(Debugger_v2, cmd_listScenes));
registerCmd("scene_info", WRAP_METHOD(Debugger_v2, cmd_sceneInfo));
registerCmd("scene_to_facing", WRAP_METHOD(Debugger_v2, cmd_sceneToFacing));
registerCmd("give", WRAP_METHOD(Debugger_v2, cmd_giveItem));
Debugger::initialize();
}
@ -449,7 +449,7 @@ Debugger_HoF::Debugger_HoF(KyraEngine_HoF *vm) : Debugger_v2(vm), _vm(vm) {
}
void Debugger_HoF::initialize() {
DCmd_Register("pass_codes", WRAP_METHOD(Debugger_HoF, cmd_passcodes));
registerCmd("pass_codes", WRAP_METHOD(Debugger_HoF, cmd_passcodes));
Debugger_v2::initialize();
}
@ -482,16 +482,16 @@ Debugger_EoB::Debugger_EoB(EoBCoreEngine *vm) : Debugger(vm), _vm(vm) {
}
void Debugger_EoB::initialize() {
DCmd_Register("import_savefile", WRAP_METHOD(Debugger_EoB, cmd_importSaveFile));
DCmd_Register("save_original", WRAP_METHOD(Debugger_EoB, cmd_saveOriginal));
DCmd_Register("list_monsters", WRAP_METHOD(Debugger_EoB, cmd_listMonsters));
DCmd_Register("show_position", WRAP_METHOD(Debugger_EoB, cmd_showPosition));
DCmd_Register("set_position", WRAP_METHOD(Debugger_EoB, cmd_setPosition));
DCmd_Register("open_door", WRAP_METHOD(Debugger_EoB, cmd_openDoor));
DCmd_Register("close_door", WRAP_METHOD(Debugger_EoB, cmd_closeDoor));
DCmd_Register("list_flags", WRAP_METHOD(Debugger_EoB, cmd_listFlags));
DCmd_Register("set_flag", WRAP_METHOD(Debugger_EoB, cmd_setFlag));
DCmd_Register("clear_flag", WRAP_METHOD(Debugger_EoB, cmd_clearFlag));
registerCmd("import_savefile", WRAP_METHOD(Debugger_EoB, cmd_importSaveFile));
registerCmd("save_original", WRAP_METHOD(Debugger_EoB, cmd_saveOriginal));
registerCmd("list_monsters", WRAP_METHOD(Debugger_EoB, cmd_listMonsters));
registerCmd("show_position", WRAP_METHOD(Debugger_EoB, cmd_showPosition));
registerCmd("set_position", WRAP_METHOD(Debugger_EoB, cmd_setPosition));
registerCmd("open_door", WRAP_METHOD(Debugger_EoB, cmd_openDoor));
registerCmd("close_door", WRAP_METHOD(Debugger_EoB, cmd_closeDoor));
registerCmd("list_flags", WRAP_METHOD(Debugger_EoB, cmd_listFlags));
registerCmd("set_flag", WRAP_METHOD(Debugger_EoB, cmd_setFlag));
registerCmd("clear_flag", WRAP_METHOD(Debugger_EoB, cmd_clearFlag));
}
bool Debugger_EoB::cmd_importSaveFile(int argc, const char **argv) {

36
engines/lastexpress/debug.cpp
View file

@ -60,33 +60,33 @@ Debugger::Debugger(LastExpressEngine *engine) : _engine(engine), _command(NULL),
// Register the debugger commands
// General
DCmd_Register("help", WRAP_METHOD(Debugger, cmdHelp));
registerCmd("help", WRAP_METHOD(Debugger, cmdHelp));
// Data
DCmd_Register("ls", WRAP_METHOD(Debugger, cmdListFiles));
DCmd_Register("dump", WRAP_METHOD(Debugger, cmdDumpFiles));
registerCmd("ls", WRAP_METHOD(Debugger, cmdListFiles));
registerCmd("dump", WRAP_METHOD(Debugger, cmdDumpFiles));
DCmd_Register("showframe", WRAP_METHOD(Debugger, cmdShowFrame));
DCmd_Register("showbg", WRAP_METHOD(Debugger, cmdShowBg));
DCmd_Register("playseq", WRAP_METHOD(Debugger, cmdPlaySeq));
DCmd_Register("playsnd", WRAP_METHOD(Debugger, cmdPlaySnd));
DCmd_Register("playsbe", WRAP_METHOD(Debugger, cmdPlaySbe));
DCmd_Register("playnis", WRAP_METHOD(Debugger, cmdPlayNis));
registerCmd("showframe", WRAP_METHOD(Debugger, cmdShowFrame));
registerCmd("showbg", WRAP_METHOD(Debugger, cmdShowBg));
registerCmd("playseq", WRAP_METHOD(Debugger, cmdPlaySeq));
registerCmd("playsnd", WRAP_METHOD(Debugger, cmdPlaySnd));
registerCmd("playsbe", WRAP_METHOD(Debugger, cmdPlaySbe));
registerCmd("playnis", WRAP_METHOD(Debugger, cmdPlayNis));
// Scene & interaction
DCmd_Register("loadscene", WRAP_METHOD(Debugger, cmdLoadScene));
DCmd_Register("fight", WRAP_METHOD(Debugger, cmdFight));
DCmd_Register("beetle", WRAP_METHOD(Debugger, cmdBeetle));
registerCmd("loadscene", WRAP_METHOD(Debugger, cmdLoadScene));
registerCmd("fight", WRAP_METHOD(Debugger, cmdFight));
registerCmd("beetle", WRAP_METHOD(Debugger, cmdBeetle));
// Game
DCmd_Register("delta", WRAP_METHOD(Debugger, cmdTimeDelta));
DCmd_Register("time", WRAP_METHOD(Debugger, cmdTime));
DCmd_Register("show", WRAP_METHOD(Debugger, cmdShow));
DCmd_Register("entity", WRAP_METHOD(Debugger, cmdEntity));
registerCmd("delta", WRAP_METHOD(Debugger, cmdTimeDelta));
registerCmd("time", WRAP_METHOD(Debugger, cmdTime));
registerCmd("show", WRAP_METHOD(Debugger, cmdShow));
registerCmd("entity", WRAP_METHOD(Debugger, cmdEntity));
// Misc
DCmd_Register("chapter", WRAP_METHOD(Debugger, cmdSwitchChapter));
DCmd_Register("clear", WRAP_METHOD(Debugger, cmdClear));
registerCmd("chapter", WRAP_METHOD(Debugger, cmdSwitchChapter));
registerCmd("clear", WRAP_METHOD(Debugger, cmdClear));
resetCommand();

28
engines/lure/debugger.cpp
View file

@ -35,20 +35,20 @@
namespace Lure {
Debugger::Debugger(): GUI::Debugger() {
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("enter", WRAP_METHOD(Debugger, cmd_enterRoom));
DCmd_Register("rooms", WRAP_METHOD(Debugger, cmd_listRooms));
DCmd_Register("fields", WRAP_METHOD(Debugger, cmd_listFields));
DCmd_Register("setfield", WRAP_METHOD(Debugger, cmd_setField));
DCmd_Register("queryfield", WRAP_METHOD(Debugger, cmd_queryField));
DCmd_Register("give", WRAP_METHOD(Debugger, cmd_giveItem));
DCmd_Register("hotspots", WRAP_METHOD(Debugger, cmd_hotspots));
DCmd_Register("hotspot", WRAP_METHOD(Debugger, cmd_hotspot));
DCmd_Register("room", WRAP_METHOD(Debugger, cmd_room));
DCmd_Register("showanim", WRAP_METHOD(Debugger, cmd_showAnim));
DCmd_Register("strings", WRAP_METHOD(Debugger, cmd_saveStrings));
DCmd_Register("debug", WRAP_METHOD(Debugger, cmd_debug));
DCmd_Register("script", WRAP_METHOD(Debugger, cmd_script));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("enter", WRAP_METHOD(Debugger, cmd_enterRoom));
registerCmd("rooms", WRAP_METHOD(Debugger, cmd_listRooms));
registerCmd("fields", WRAP_METHOD(Debugger, cmd_listFields));
registerCmd("setfield", WRAP_METHOD(Debugger, cmd_setField));
registerCmd("queryfield", WRAP_METHOD(Debugger, cmd_queryField));
registerCmd("give", WRAP_METHOD(Debugger, cmd_giveItem));
registerCmd("hotspots", WRAP_METHOD(Debugger, cmd_hotspots));
registerCmd("hotspot", WRAP_METHOD(Debugger, cmd_hotspot));
registerCmd("room", WRAP_METHOD(Debugger, cmd_room));
registerCmd("showanim", WRAP_METHOD(Debugger, cmd_showAnim));
registerCmd("strings", WRAP_METHOD(Debugger, cmd_saveStrings));
registerCmd("debug", WRAP_METHOD(Debugger, cmd_debug));
registerCmd("script", WRAP_METHOD(Debugger, cmd_script));
}
static int strToInt(const char *s) {

32
engines/mads/debugger.cpp
View file

@ -29,22 +29,22 @@ namespace MADS {
Debugger::Debugger(MADSEngine *vm) : GUI::Debugger(), _vm(vm) {
_showMousePos = false;
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("mouse", WRAP_METHOD(Debugger, Cmd_Mouse));
DCmd_Register("scene", WRAP_METHOD(Debugger, Cmd_LoadScene));
DCmd_Register("show_hotspots", WRAP_METHOD(Debugger, Cmd_ShowHotSpots));
DCmd_Register("list_hotspots", WRAP_METHOD(Debugger, Cmd_ListHotSpots));
DCmd_Register("play_sound", WRAP_METHOD(Debugger, Cmd_PlaySound));
DCmd_Register("play_audio", WRAP_METHOD(Debugger, Cmd_PlayAudio));
DCmd_Register("show_codes", WRAP_METHOD(Debugger, Cmd_ShowCodes));
DCmd_Register("dump_file", WRAP_METHOD(Debugger, Cmd_DumpFile));
DCmd_Register("show_quote", WRAP_METHOD(Debugger, Cmd_ShowQuote));
DCmd_Register("show_vocab", WRAP_METHOD(Debugger, Cmd_ShowVocab));
DCmd_Register("dump_vocab", WRAP_METHOD(Debugger, Cmd_DumpVocab));
DCmd_Register("show_message", WRAP_METHOD(Debugger, Cmd_ShowMessage));
DCmd_Register("show_item", WRAP_METHOD(Debugger, Cmd_ShowItem));
DCmd_Register("dump_items", WRAP_METHOD(Debugger, Cmd_DumpItems));
DCmd_Register("item", WRAP_METHOD(Debugger, Cmd_Item));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("mouse", WRAP_METHOD(Debugger, Cmd_Mouse));
registerCmd("scene", WRAP_METHOD(Debugger, Cmd_LoadScene));
registerCmd("show_hotspots", WRAP_METHOD(Debugger, Cmd_ShowHotSpots));
registerCmd("list_hotspots", WRAP_METHOD(Debugger, Cmd_ListHotSpots));
registerCmd("play_sound", WRAP_METHOD(Debugger, Cmd_PlaySound));
registerCmd("play_audio", WRAP_METHOD(Debugger, Cmd_PlayAudio));
registerCmd("show_codes", WRAP_METHOD(Debugger, Cmd_ShowCodes));
registerCmd("dump_file", WRAP_METHOD(Debugger, Cmd_DumpFile));
registerCmd("show_quote", WRAP_METHOD(Debugger, Cmd_ShowQuote));
registerCmd("show_vocab", WRAP_METHOD(Debugger, Cmd_ShowVocab));
registerCmd("dump_vocab", WRAP_METHOD(Debugger, Cmd_DumpVocab));
registerCmd("show_message", WRAP_METHOD(Debugger, Cmd_ShowMessage));
registerCmd("show_item", WRAP_METHOD(Debugger, Cmd_ShowItem));
registerCmd("dump_items", WRAP_METHOD(Debugger, Cmd_DumpItems));
registerCmd("item", WRAP_METHOD(Debugger, Cmd_Item));
}
static int strToInt(const char *s) {

82
engines/mohawk/console.cpp
View file

@ -49,20 +49,20 @@ 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));
registerCmd("changeCard", WRAP_METHOD(MystConsole, Cmd_ChangeCard));
registerCmd("curCard", WRAP_METHOD(MystConsole, Cmd_CurCard));
registerCmd("var", WRAP_METHOD(MystConsole, Cmd_Var));
registerCmd("curStack", WRAP_METHOD(MystConsole, Cmd_CurStack));
registerCmd("changeStack", WRAP_METHOD(MystConsole, Cmd_ChangeStack));
registerCmd("drawImage", WRAP_METHOD(MystConsole, Cmd_DrawImage));
registerCmd("drawRect", WRAP_METHOD(MystConsole, Cmd_DrawRect));
registerCmd("setResourceEnable", WRAP_METHOD(MystConsole, Cmd_SetResourceEnable));
registerCmd("playSound", WRAP_METHOD(MystConsole, Cmd_PlaySound));
registerCmd("stopSound", WRAP_METHOD(MystConsole, Cmd_StopSound));
registerCmd("playMovie", WRAP_METHOD(MystConsole, Cmd_PlayMovie));
registerCmd("disableInitOpcodes", WRAP_METHOD(MystConsole, Cmd_DisableInitOpcodes));
registerCmd("cache", WRAP_METHOD(MystConsole, Cmd_Cache));
registerCmd("resources", WRAP_METHOD(MystConsole, Cmd_Resources));
}
MystConsole::~MystConsole() {
@ -323,21 +323,21 @@ bool MystConsole::Cmd_Resources(int argc, const char **argv) {
#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));
registerCmd("changeCard", WRAP_METHOD(RivenConsole, Cmd_ChangeCard));
registerCmd("curCard", WRAP_METHOD(RivenConsole, Cmd_CurCard));
registerCmd("var", WRAP_METHOD(RivenConsole, Cmd_Var));
registerCmd("playSound", WRAP_METHOD(RivenConsole, Cmd_PlaySound));
registerCmd("playSLST", WRAP_METHOD(RivenConsole, Cmd_PlaySLST));
registerCmd("stopSound", WRAP_METHOD(RivenConsole, Cmd_StopSound));
registerCmd("curStack", WRAP_METHOD(RivenConsole, Cmd_CurStack));
registerCmd("changeStack", WRAP_METHOD(RivenConsole, Cmd_ChangeStack));
registerCmd("hotspots", WRAP_METHOD(RivenConsole, Cmd_Hotspots));
registerCmd("zipMode", WRAP_METHOD(RivenConsole, Cmd_ZipMode));
registerCmd("dumpScript", WRAP_METHOD(RivenConsole, Cmd_DumpScript));
registerCmd("listZipCards", WRAP_METHOD(RivenConsole, Cmd_ListZipCards));
registerCmd("getRMAP", WRAP_METHOD(RivenConsole, Cmd_GetRMAP));
registerCmd("combos", WRAP_METHOD(RivenConsole, Cmd_Combos));
registerCmd("sliderState", WRAP_METHOD(RivenConsole, Cmd_SliderState));
}
RivenConsole::~RivenConsole() {
@ -661,10 +661,10 @@ bool RivenConsole::Cmd_SliderState(int argc, const char **argv) {
#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));
registerCmd("playSound", WRAP_METHOD(LivingBooksConsole, Cmd_PlaySound));
registerCmd("stopSound", WRAP_METHOD(LivingBooksConsole, Cmd_StopSound));
registerCmd("drawImage", WRAP_METHOD(LivingBooksConsole, Cmd_DrawImage));
registerCmd("changePage", WRAP_METHOD(LivingBooksConsole, Cmd_ChangePage));
}
LivingBooksConsole::~LivingBooksConsole() {
@ -725,14 +725,14 @@ bool LivingBooksConsole::Cmd_ChangePage(int argc, const char **argv) {
#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));
registerCmd("playSound", WRAP_METHOD(CSTimeConsole, Cmd_PlaySound));
registerCmd("stopSound", WRAP_METHOD(CSTimeConsole, Cmd_StopSound));
registerCmd("drawImage", WRAP_METHOD(CSTimeConsole, Cmd_DrawImage));
registerCmd("drawSubimage", WRAP_METHOD(CSTimeConsole, Cmd_DrawSubimage));
registerCmd("changeCase", WRAP_METHOD(CSTimeConsole, Cmd_ChangeCase));
registerCmd("changeScene", WRAP_METHOD(CSTimeConsole, Cmd_ChangeScene));
registerCmd("caseVariable", WRAP_METHOD(CSTimeConsole, Cmd_CaseVariable));
registerCmd("invItem", WRAP_METHOD(CSTimeConsole, Cmd_InvItem));
}
CSTimeConsole::~CSTimeConsole() {

6
engines/mortevielle/debugger.cpp
View file

@ -27,9 +27,9 @@ namespace Mortevielle {
Debugger::Debugger(MortevielleEngine *vm) : GUI::Debugger() {
_vm = vm;
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("show_questions", WRAP_METHOD(Debugger, Cmd_showAllQuestions));
DCmd_Register("reset_parano", WRAP_METHOD(Debugger, Cmd_resetParano));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("show_questions", WRAP_METHOD(Debugger, Cmd_showAllQuestions));
registerCmd("reset_parano", WRAP_METHOD(Debugger, Cmd_resetParano));
}
bool Debugger::Cmd_showAllQuestions(int argc, const char **argv) {

14
engines/neverhood/console.cpp
View file

@ -34,13 +34,13 @@
namespace Neverhood {
Console::Console(NeverhoodEngine *vm) : GUI::Debugger(), _vm(vm) {
DCmd_Register("cheat", WRAP_METHOD(Console, Cmd_Cheat));
DCmd_Register("checkresource", WRAP_METHOD(Console, Cmd_CheckResource));
DCmd_Register("dumpresource", WRAP_METHOD(Console, Cmd_DumpResource));
DCmd_Register("dumpvars", WRAP_METHOD(Console, Cmd_Dumpvars));
DCmd_Register("playsound", WRAP_METHOD(Console, Cmd_PlaySound));
DCmd_Register("scene", WRAP_METHOD(Console, Cmd_Scene));
DCmd_Register("surfaces", WRAP_METHOD(Console, Cmd_Surfaces));
registerCmd("cheat", WRAP_METHOD(Console, Cmd_Cheat));
registerCmd("checkresource", WRAP_METHOD(Console, Cmd_CheckResource));
registerCmd("dumpresource", WRAP_METHOD(Console, Cmd_DumpResource));
registerCmd("dumpvars", WRAP_METHOD(Console, Cmd_Dumpvars));
registerCmd("playsound", WRAP_METHOD(Console, Cmd_PlaySound));
registerCmd("scene", WRAP_METHOD(Console, Cmd_Scene));
registerCmd("surfaces", WRAP_METHOD(Console, Cmd_Surfaces));
}
Console::~Console() {

24
engines/parallaction/debug.cpp
View file

@ -33,18 +33,18 @@ Debugger::Debugger(Parallaction *vm)
: GUI::Debugger() {
_vm = vm;
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("location", WRAP_METHOD(Debugger, Cmd_Location));
DCmd_Register("give", WRAP_METHOD(Debugger, Cmd_Give));
DCmd_Register("zones", WRAP_METHOD(Debugger, Cmd_Zones));
DCmd_Register("animations", WRAP_METHOD(Debugger, Cmd_Animations));
DCmd_Register("globalflags",WRAP_METHOD(Debugger, Cmd_GlobalFlags));
DCmd_Register("toggleglobalflag",WRAP_METHOD(Debugger, Cmd_ToggleGlobalFlag));
DCmd_Register("localflags", WRAP_METHOD(Debugger, Cmd_LocalFlags));
DCmd_Register("locations", WRAP_METHOD(Debugger, Cmd_Locations));
DCmd_Register("gfxobjects", WRAP_METHOD(Debugger, Cmd_GfxObjects));
DCmd_Register("programs", WRAP_METHOD(Debugger, Cmd_Programs));
DCmd_Register("showmouse", WRAP_METHOD(Debugger, Cmd_ShowMouse));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("location", WRAP_METHOD(Debugger, Cmd_Location));
registerCmd("give", WRAP_METHOD(Debugger, Cmd_Give));
registerCmd("zones", WRAP_METHOD(Debugger, Cmd_Zones));
registerCmd("animations", WRAP_METHOD(Debugger, Cmd_Animations));
registerCmd("globalflags",WRAP_METHOD(Debugger, Cmd_GlobalFlags));
registerCmd("toggleglobalflag",WRAP_METHOD(Debugger, Cmd_ToggleGlobalFlag));
registerCmd("localflags", WRAP_METHOD(Debugger, Cmd_LocalFlags));
registerCmd("locations", WRAP_METHOD(Debugger, Cmd_Locations));
registerCmd("gfxobjects", WRAP_METHOD(Debugger, Cmd_GfxObjects));
registerCmd("programs", WRAP_METHOD(Debugger, Cmd_Programs));
registerCmd("showmouse", WRAP_METHOD(Debugger, Cmd_ShowMouse));
}

4
engines/pegasus/console.cpp
View file

@ -28,11 +28,11 @@
namespace Pegasus {
PegasusConsole::PegasusConsole(PegasusEngine *vm) : GUI::Debugger(), _vm(vm) {
DCmd_Register("die", WRAP_METHOD(PegasusConsole, Cmd_Die));
registerCmd("die", WRAP_METHOD(PegasusConsole, Cmd_Die));
// These functions are non-demo specific
if (!_vm->isDemo())
DCmd_Register("jump", WRAP_METHOD(PegasusConsole, Cmd_Jump));
registerCmd("jump", WRAP_METHOD(PegasusConsole, Cmd_Jump));
}
PegasusConsole::~PegasusConsole() {

18
engines/queen/debug.cpp
View file

@ -36,15 +36,15 @@ namespace Queen {
Debugger::Debugger(QueenEngine *vm)
: _vm(vm), _flags(0) {
DCmd_Register("areas", WRAP_METHOD(Debugger, Cmd_Areas));
DCmd_Register("asm", WRAP_METHOD(Debugger, Cmd_Asm));
DCmd_Register("bob", WRAP_METHOD(Debugger, Cmd_Bob));
DCmd_Register("bobs", WRAP_METHOD(Debugger, Cmd_PrintBobs));
DCmd_Register("gs", WRAP_METHOD(Debugger, Cmd_GameState));
DCmd_Register("info", WRAP_METHOD(Debugger, Cmd_Info));
DCmd_Register("items", WRAP_METHOD(Debugger, Cmd_Items));
DCmd_Register("room", WRAP_METHOD(Debugger, Cmd_Room));
DCmd_Register("song", WRAP_METHOD(Debugger, Cmd_Song));
registerCmd("areas", WRAP_METHOD(Debugger, Cmd_Areas));
registerCmd("asm", WRAP_METHOD(Debugger, Cmd_Asm));
registerCmd("bob", WRAP_METHOD(Debugger, Cmd_Bob));
registerCmd("bobs", WRAP_METHOD(Debugger, Cmd_PrintBobs));
registerCmd("gs", WRAP_METHOD(Debugger, Cmd_GameState));
registerCmd("info", WRAP_METHOD(Debugger, Cmd_Info));
registerCmd("items", WRAP_METHOD(Debugger, Cmd_Items));
registerCmd("room", WRAP_METHOD(Debugger, Cmd_Room));
registerCmd("song", WRAP_METHOD(Debugger, Cmd_Song));
}
Debugger::~Debugger() {} // we need this here for __SYMBIAN32__

36
engines/saga/console.cpp
View file

@ -35,15 +35,15 @@ namespace Saga {
Console::Console(SagaEngine *vm) : GUI::Debugger() {
_vm = vm;
DCmd_Register("continue", WRAP_METHOD(Console, Cmd_Exit));
registerCmd("continue", WRAP_METHOD(Console, Cmd_Exit));
// Actor commands
DCmd_Register("actor_walk_to", WRAP_METHOD(Console, cmdActorWalkTo));
registerCmd("actor_walk_to", WRAP_METHOD(Console, cmdActorWalkTo));
// Animation commands
DCmd_Register("anim_info", WRAP_METHOD(Console, cmdAnimInfo));
DCmd_Register("cutaway_info", WRAP_METHOD(Console, cmdCutawayInfo));
DCmd_Register("play_cutaway", WRAP_METHOD(Console, cmdPlayCutaway));
registerCmd("anim_info", WRAP_METHOD(Console, cmdAnimInfo));
registerCmd("cutaway_info", WRAP_METHOD(Console, cmdCutawayInfo));
registerCmd("play_cutaway", WRAP_METHOD(Console, cmdPlayCutaway));
// Game stuff
@ -60,28 +60,28 @@ Console::Console(SagaEngine *vm) : GUI::Debugger() {
#endif
// Scene commands
DCmd_Register("current_scene", WRAP_METHOD(Console, cmdCurrentScene));
DCmd_Register("current_chapter", WRAP_METHOD(Console, cmdCurrentChapter));
DCmd_Register("scene_change", WRAP_METHOD(Console, cmdSceneChange));
DCmd_Register("chapter_change", WRAP_METHOD(Console, cmdChapterChange));
registerCmd("current_scene", WRAP_METHOD(Console, cmdCurrentScene));
registerCmd("current_chapter", WRAP_METHOD(Console, cmdCurrentChapter));
registerCmd("scene_change", WRAP_METHOD(Console, cmdSceneChange));
registerCmd("chapter_change", WRAP_METHOD(Console, cmdChapterChange));
DCmd_Register("action_map_info", WRAP_METHOD(Console, cmdActionMapInfo));
DCmd_Register("object_map_info", WRAP_METHOD(Console, cmdObjectMapInfo));
registerCmd("action_map_info", WRAP_METHOD(Console, cmdActionMapInfo));
registerCmd("object_map_info", WRAP_METHOD(Console, cmdObjectMapInfo));
// Script commands
DCmd_Register("wake_up_threads", WRAP_METHOD(Console, cmdWakeUpThreads));
registerCmd("wake_up_threads", WRAP_METHOD(Console, cmdWakeUpThreads));
// Panel commands
DCmd_Register("current_panel_mode", WRAP_METHOD(Console, cmdCurrentPanelMode));
DCmd_Register("set_panel_mode", WRAP_METHOD(Console, cmdSetPanelMode));
registerCmd("current_panel_mode", WRAP_METHOD(Console, cmdCurrentPanelMode));
registerCmd("set_panel_mode", WRAP_METHOD(Console, cmdSetPanelMode));
// Font commands
DCmd_Register("set_font_mapping", WRAP_METHOD(Console, cmdSetFontMapping));
registerCmd("set_font_mapping", WRAP_METHOD(Console, cmdSetFontMapping));
// Global flags commands
DCmd_Register("global_flags_info", WRAP_METHOD(Console, cmdGlobalFlagsInfo));
DCmd_Register("set_global_flag", WRAP_METHOD(Console, cmdSetGlobalFlag));
DCmd_Register("clear_global_flag", WRAP_METHOD(Console, cmdClearGlobalFlag));
registerCmd("global_flags_info", WRAP_METHOD(Console, cmdGlobalFlagsInfo));
registerCmd("set_global_flag", WRAP_METHOD(Console, cmdSetGlobalFlag));
registerCmd("clear_global_flag", WRAP_METHOD(Console, cmdClearGlobalFlag));
}
Console::~Console() {

248
engines/sci/console.cpp
View file

@ -86,141 +86,141 @@ Console::Console(SciEngine *engine) : GUI::Debugger(),
registerVar("script_abort_flag", &_engine->_gamestate->abortScriptProcessing, DVAR_INT, 0);
// General
DCmd_Register("help", WRAP_METHOD(Console, cmdHelp));
registerCmd("help", WRAP_METHOD(Console, cmdHelp));
// Kernel
// DCmd_Register("classes", WRAP_METHOD(Console, cmdClasses)); // TODO
DCmd_Register("opcodes", WRAP_METHOD(Console, cmdOpcodes));
DCmd_Register("selector", WRAP_METHOD(Console, cmdSelector));
DCmd_Register("selectors", WRAP_METHOD(Console, cmdSelectors));
DCmd_Register("functions", WRAP_METHOD(Console, cmdKernelFunctions));
DCmd_Register("class_table", WRAP_METHOD(Console, cmdClassTable));
// registerCmd("classes", WRAP_METHOD(Console, cmdClasses)); // TODO
registerCmd("opcodes", WRAP_METHOD(Console, cmdOpcodes));
registerCmd("selector", WRAP_METHOD(Console, cmdSelector));
registerCmd("selectors", WRAP_METHOD(Console, cmdSelectors));
registerCmd("functions", WRAP_METHOD(Console, cmdKernelFunctions));
registerCmd("class_table", WRAP_METHOD(Console, cmdClassTable));
// Parser
DCmd_Register("suffixes", WRAP_METHOD(Console, cmdSuffixes));
DCmd_Register("parse_grammar", WRAP_METHOD(Console, cmdParseGrammar));
DCmd_Register("parser_nodes", WRAP_METHOD(Console, cmdParserNodes));
DCmd_Register("parser_words", WRAP_METHOD(Console, cmdParserWords));
DCmd_Register("sentence_fragments", WRAP_METHOD(Console, cmdSentenceFragments));
DCmd_Register("parse", WRAP_METHOD(Console, cmdParse));
DCmd_Register("set_parse_nodes", WRAP_METHOD(Console, cmdSetParseNodes));
DCmd_Register("said", WRAP_METHOD(Console, cmdSaid));
registerCmd("suffixes", WRAP_METHOD(Console, cmdSuffixes));
registerCmd("parse_grammar", WRAP_METHOD(Console, cmdParseGrammar));
registerCmd("parser_nodes", WRAP_METHOD(Console, cmdParserNodes));
registerCmd("parser_words", WRAP_METHOD(Console, cmdParserWords));
registerCmd("sentence_fragments", WRAP_METHOD(Console, cmdSentenceFragments));
registerCmd("parse", WRAP_METHOD(Console, cmdParse));
registerCmd("set_parse_nodes", WRAP_METHOD(Console, cmdSetParseNodes));
registerCmd("said", WRAP_METHOD(Console, cmdSaid));
// Resources
DCmd_Register("diskdump", WRAP_METHOD(Console, cmdDiskDump));
DCmd_Register("hexdump", WRAP_METHOD(Console, cmdHexDump));
DCmd_Register("resource_id", WRAP_METHOD(Console, cmdResourceId));
DCmd_Register("resource_info", WRAP_METHOD(Console, cmdResourceInfo));
DCmd_Register("resource_types", WRAP_METHOD(Console, cmdResourceTypes));
DCmd_Register("list", WRAP_METHOD(Console, cmdList));
DCmd_Register("hexgrep", WRAP_METHOD(Console, cmdHexgrep));
DCmd_Register("verify_scripts", WRAP_METHOD(Console, cmdVerifyScripts));
registerCmd("diskdump", WRAP_METHOD(Console, cmdDiskDump));
registerCmd("hexdump", WRAP_METHOD(Console, cmdHexDump));
registerCmd("resource_id", WRAP_METHOD(Console, cmdResourceId));
registerCmd("resource_info", WRAP_METHOD(Console, cmdResourceInfo));
registerCmd("resource_types", WRAP_METHOD(Console, cmdResourceTypes));
registerCmd("list", WRAP_METHOD(Console, cmdList));
registerCmd("hexgrep", WRAP_METHOD(Console, cmdHexgrep));
registerCmd("verify_scripts", WRAP_METHOD(Console, cmdVerifyScripts));
// Game
DCmd_Register("save_game", WRAP_METHOD(Console, cmdSaveGame));
DCmd_Register("restore_game", WRAP_METHOD(Console, cmdRestoreGame));
DCmd_Register("restart_game", WRAP_METHOD(Console, cmdRestartGame));
DCmd_Register("version", WRAP_METHOD(Console, cmdGetVersion));
DCmd_Register("room", WRAP_METHOD(Console, cmdRoomNumber));
DCmd_Register("quit", WRAP_METHOD(Console, cmdQuit));
DCmd_Register("list_saves", WRAP_METHOD(Console, cmdListSaves));
registerCmd("save_game", WRAP_METHOD(Console, cmdSaveGame));
registerCmd("restore_game", WRAP_METHOD(Console, cmdRestoreGame));
registerCmd("restart_game", WRAP_METHOD(Console, cmdRestartGame));
registerCmd("version", WRAP_METHOD(Console, cmdGetVersion));
registerCmd("room", WRAP_METHOD(Console, cmdRoomNumber));
registerCmd("quit", WRAP_METHOD(Console, cmdQuit));
registerCmd("list_saves", WRAP_METHOD(Console, cmdListSaves));
// Graphics
DCmd_Register("show_map", WRAP_METHOD(Console, cmdShowMap));
DCmd_Register("set_palette", WRAP_METHOD(Console, cmdSetPalette));
DCmd_Register("draw_pic", WRAP_METHOD(Console, cmdDrawPic));
DCmd_Register("draw_cel", WRAP_METHOD(Console, cmdDrawCel));
DCmd_Register("undither", WRAP_METHOD(Console, cmdUndither));
DCmd_Register("pic_visualize", WRAP_METHOD(Console, cmdPicVisualize));
DCmd_Register("play_video", WRAP_METHOD(Console, cmdPlayVideo));
DCmd_Register("animate_list", WRAP_METHOD(Console, cmdAnimateList));
DCmd_Register("al", WRAP_METHOD(Console, cmdAnimateList)); // alias
DCmd_Register("window_list", WRAP_METHOD(Console, cmdWindowList));
DCmd_Register("wl", WRAP_METHOD(Console, cmdWindowList)); // alias
DCmd_Register("plane_list", WRAP_METHOD(Console, cmdPlaneList));
DCmd_Register("pl", WRAP_METHOD(Console, cmdPlaneList)); // alias
DCmd_Register("plane_items", WRAP_METHOD(Console, cmdPlaneItemList));
DCmd_Register("pi", WRAP_METHOD(Console, cmdPlaneItemList)); // alias
DCmd_Register("saved_bits", WRAP_METHOD(Console, cmdSavedBits));
DCmd_Register("show_saved_bits", WRAP_METHOD(Console, cmdShowSavedBits));
registerCmd("show_map", WRAP_METHOD(Console, cmdShowMap));
registerCmd("set_palette", WRAP_METHOD(Console, cmdSetPalette));
registerCmd("draw_pic", WRAP_METHOD(Console, cmdDrawPic));
registerCmd("draw_cel", WRAP_METHOD(Console, cmdDrawCel));
registerCmd("undither", WRAP_METHOD(Console, cmdUndither));
registerCmd("pic_visualize", WRAP_METHOD(Console, cmdPicVisualize));
registerCmd("play_video", WRAP_METHOD(Console, cmdPlayVideo));
registerCmd("animate_list", WRAP_METHOD(Console, cmdAnimateList));
registerCmd("al", WRAP_METHOD(Console, cmdAnimateList)); // alias
registerCmd("window_list", WRAP_METHOD(Console, cmdWindowList));
registerCmd("wl", WRAP_METHOD(Console, cmdWindowList)); // alias
registerCmd("plane_list", WRAP_METHOD(Console, cmdPlaneList));
registerCmd("pl", WRAP_METHOD(Console, cmdPlaneList)); // alias
registerCmd("plane_items", WRAP_METHOD(Console, cmdPlaneItemList));
registerCmd("pi", WRAP_METHOD(Console, cmdPlaneItemList)); // alias
registerCmd("saved_bits", WRAP_METHOD(Console, cmdSavedBits));
registerCmd("show_saved_bits", WRAP_METHOD(Console, cmdShowSavedBits));
// Segments
DCmd_Register("segment_table", WRAP_METHOD(Console, cmdPrintSegmentTable));
DCmd_Register("segtable", WRAP_METHOD(Console, cmdPrintSegmentTable)); // alias
DCmd_Register("segment_info", WRAP_METHOD(Console, cmdSegmentInfo));
DCmd_Register("seginfo", WRAP_METHOD(Console, cmdSegmentInfo)); // alias
DCmd_Register("segment_kill", WRAP_METHOD(Console, cmdKillSegment));
DCmd_Register("segkill", WRAP_METHOD(Console, cmdKillSegment)); // alias
registerCmd("segment_table", WRAP_METHOD(Console, cmdPrintSegmentTable));
registerCmd("segtable", WRAP_METHOD(Console, cmdPrintSegmentTable)); // alias
registerCmd("segment_info", WRAP_METHOD(Console, cmdSegmentInfo));
registerCmd("seginfo", WRAP_METHOD(Console, cmdSegmentInfo)); // alias
registerCmd("segment_kill", WRAP_METHOD(Console, cmdKillSegment));
registerCmd("segkill", WRAP_METHOD(Console, cmdKillSegment)); // alias
// Garbage collection
DCmd_Register("gc", WRAP_METHOD(Console, cmdGCInvoke));
DCmd_Register("gc_objects", WRAP_METHOD(Console, cmdGCObjects));
DCmd_Register("gc_reachable", WRAP_METHOD(Console, cmdGCShowReachable));
DCmd_Register("gc_freeable", WRAP_METHOD(Console, cmdGCShowFreeable));
DCmd_Register("gc_normalize", WRAP_METHOD(Console, cmdGCNormalize));
registerCmd("gc", WRAP_METHOD(Console, cmdGCInvoke));
registerCmd("gc_objects", WRAP_METHOD(Console, cmdGCObjects));
registerCmd("gc_reachable", WRAP_METHOD(Console, cmdGCShowReachable));
registerCmd("gc_freeable", WRAP_METHOD(Console, cmdGCShowFreeable));
registerCmd("gc_normalize", WRAP_METHOD(Console, cmdGCNormalize));
// Music/SFX
DCmd_Register("songlib", WRAP_METHOD(Console, cmdSongLib));
DCmd_Register("songinfo", WRAP_METHOD(Console, cmdSongInfo));
DCmd_Register("is_sample", WRAP_METHOD(Console, cmdIsSample));
DCmd_Register("startsound", WRAP_METHOD(Console, cmdStartSound));
DCmd_Register("togglesound", WRAP_METHOD(Console, cmdToggleSound));
DCmd_Register("stopallsounds", WRAP_METHOD(Console, cmdStopAllSounds));
DCmd_Register("sfx01_header", WRAP_METHOD(Console, cmdSfx01Header));
DCmd_Register("sfx01_track", WRAP_METHOD(Console, cmdSfx01Track));
DCmd_Register("show_instruments", WRAP_METHOD(Console, cmdShowInstruments));
DCmd_Register("map_instrument", WRAP_METHOD(Console, cmdMapInstrument));
registerCmd("songlib", WRAP_METHOD(Console, cmdSongLib));
registerCmd("songinfo", WRAP_METHOD(Console, cmdSongInfo));
registerCmd("is_sample", WRAP_METHOD(Console, cmdIsSample));
registerCmd("startsound", WRAP_METHOD(Console, cmdStartSound));
registerCmd("togglesound", WRAP_METHOD(Console, cmdToggleSound));
registerCmd("stopallsounds", WRAP_METHOD(Console, cmdStopAllSounds));
registerCmd("sfx01_header", WRAP_METHOD(Console, cmdSfx01Header));
registerCmd("sfx01_track", WRAP_METHOD(Console, cmdSfx01Track));
registerCmd("show_instruments", WRAP_METHOD(Console, cmdShowInstruments));
registerCmd("map_instrument", WRAP_METHOD(Console, cmdMapInstrument));
// Script
DCmd_Register("addresses", WRAP_METHOD(Console, cmdAddresses));
DCmd_Register("registers", WRAP_METHOD(Console, cmdRegisters));
DCmd_Register("dissect_script", WRAP_METHOD(Console, cmdDissectScript));
DCmd_Register("backtrace", WRAP_METHOD(Console, cmdBacktrace));
DCmd_Register("bt", WRAP_METHOD(Console, cmdBacktrace)); // alias
DCmd_Register("trace", WRAP_METHOD(Console, cmdTrace));
DCmd_Register("t", WRAP_METHOD(Console, cmdTrace)); // alias
DCmd_Register("s", WRAP_METHOD(Console, cmdTrace)); // alias
DCmd_Register("stepover", WRAP_METHOD(Console, cmdStepOver));
DCmd_Register("p", WRAP_METHOD(Console, cmdStepOver)); // alias
DCmd_Register("step_ret", WRAP_METHOD(Console, cmdStepRet));
DCmd_Register("pret", WRAP_METHOD(Console, cmdStepRet)); // alias
DCmd_Register("step_event", WRAP_METHOD(Console, cmdStepEvent));
DCmd_Register("se", WRAP_METHOD(Console, cmdStepEvent)); // alias
DCmd_Register("step_global", WRAP_METHOD(Console, cmdStepGlobal));
DCmd_Register("sg", WRAP_METHOD(Console, cmdStepGlobal)); // alias
DCmd_Register("step_callk", WRAP_METHOD(Console, cmdStepCallk));
DCmd_Register("snk", WRAP_METHOD(Console, cmdStepCallk)); // alias
DCmd_Register("disasm", WRAP_METHOD(Console, cmdDisassemble));
DCmd_Register("disasm_addr", WRAP_METHOD(Console, cmdDisassembleAddress));
DCmd_Register("find_callk", WRAP_METHOD(Console, cmdFindKernelFunctionCall));
DCmd_Register("send", WRAP_METHOD(Console, cmdSend));
DCmd_Register("go", WRAP_METHOD(Console, cmdGo));
DCmd_Register("logkernel", WRAP_METHOD(Console, cmdLogKernel));
registerCmd("addresses", WRAP_METHOD(Console, cmdAddresses));
registerCmd("registers", WRAP_METHOD(Console, cmdRegisters));
registerCmd("dissect_script", WRAP_METHOD(Console, cmdDissectScript));
registerCmd("backtrace", WRAP_METHOD(Console, cmdBacktrace));
registerCmd("bt", WRAP_METHOD(Console, cmdBacktrace)); // alias
registerCmd("trace", WRAP_METHOD(Console, cmdTrace));
registerCmd("t", WRAP_METHOD(Console, cmdTrace)); // alias
registerCmd("s", WRAP_METHOD(Console, cmdTrace)); // alias
registerCmd("stepover", WRAP_METHOD(Console, cmdStepOver));
registerCmd("p", WRAP_METHOD(Console, cmdStepOver)); // alias
registerCmd("step_ret", WRAP_METHOD(Console, cmdStepRet));
registerCmd("pret", WRAP_METHOD(Console, cmdStepRet)); // alias
registerCmd("step_event", WRAP_METHOD(Console, cmdStepEvent));
registerCmd("se", WRAP_METHOD(Console, cmdStepEvent)); // alias
registerCmd("step_global", WRAP_METHOD(Console, cmdStepGlobal));
registerCmd("sg", WRAP_METHOD(Console, cmdStepGlobal)); // alias
registerCmd("step_callk", WRAP_METHOD(Console, cmdStepCallk));
registerCmd("snk", WRAP_METHOD(Console, cmdStepCallk)); // alias
registerCmd("disasm", WRAP_METHOD(Console, cmdDisassemble));
registerCmd("disasm_addr", WRAP_METHOD(Console, cmdDisassembleAddress));
registerCmd("find_callk", WRAP_METHOD(Console, cmdFindKernelFunctionCall));
registerCmd("send", WRAP_METHOD(Console, cmdSend));
registerCmd("go", WRAP_METHOD(Console, cmdGo));
registerCmd("logkernel", WRAP_METHOD(Console, cmdLogKernel));
// Breakpoints
DCmd_Register("bp_list", WRAP_METHOD(Console, cmdBreakpointList));
DCmd_Register("bplist", WRAP_METHOD(Console, cmdBreakpointList)); // alias
DCmd_Register("bl", WRAP_METHOD(Console, cmdBreakpointList)); // alias
DCmd_Register("bp_del", WRAP_METHOD(Console, cmdBreakpointDelete));
DCmd_Register("bpdel", WRAP_METHOD(Console, cmdBreakpointDelete)); // alias
DCmd_Register("bc", WRAP_METHOD(Console, cmdBreakpointDelete)); // alias
DCmd_Register("bp_method", WRAP_METHOD(Console, cmdBreakpointMethod));
DCmd_Register("bpx", WRAP_METHOD(Console, cmdBreakpointMethod)); // alias
DCmd_Register("bp_read", WRAP_METHOD(Console, cmdBreakpointRead));
DCmd_Register("bpr", WRAP_METHOD(Console, cmdBreakpointRead)); // alias
DCmd_Register("bp_write", WRAP_METHOD(Console, cmdBreakpointWrite));
DCmd_Register("bpw", WRAP_METHOD(Console, cmdBreakpointWrite)); // alias
DCmd_Register("bp_kernel", WRAP_METHOD(Console, cmdBreakpointKernel));
DCmd_Register("bpk", WRAP_METHOD(Console, cmdBreakpointKernel)); // alias
DCmd_Register("bp_function", WRAP_METHOD(Console, cmdBreakpointFunction));
DCmd_Register("bpe", WRAP_METHOD(Console, cmdBreakpointFunction)); // alias
registerCmd("bp_list", WRAP_METHOD(Console, cmdBreakpointList));
registerCmd("bplist", WRAP_METHOD(Console, cmdBreakpointList)); // alias
registerCmd("bl", WRAP_METHOD(Console, cmdBreakpointList)); // alias
registerCmd("bp_del", WRAP_METHOD(Console, cmdBreakpointDelete));
registerCmd("bpdel", WRAP_METHOD(Console, cmdBreakpointDelete)); // alias
registerCmd("bc", WRAP_METHOD(Console, cmdBreakpointDelete)); // alias
registerCmd("bp_method", WRAP_METHOD(Console, cmdBreakpointMethod));
registerCmd("bpx", WRAP_METHOD(Console, cmdBreakpointMethod)); // alias
registerCmd("bp_read", WRAP_METHOD(Console, cmdBreakpointRead));
registerCmd("bpr", WRAP_METHOD(Console, cmdBreakpointRead)); // alias
registerCmd("bp_write", WRAP_METHOD(Console, cmdBreakpointWrite));
registerCmd("bpw", WRAP_METHOD(Console, cmdBreakpointWrite)); // alias
registerCmd("bp_kernel", WRAP_METHOD(Console, cmdBreakpointKernel));
registerCmd("bpk", WRAP_METHOD(Console, cmdBreakpointKernel)); // alias
registerCmd("bp_function", WRAP_METHOD(Console, cmdBreakpointFunction));
registerCmd("bpe", WRAP_METHOD(Console, cmdBreakpointFunction)); // alias
// VM
DCmd_Register("script_steps", WRAP_METHOD(Console, cmdScriptSteps));
DCmd_Register("vm_varlist", WRAP_METHOD(Console, cmdVMVarlist));
DCmd_Register("vmvarlist", WRAP_METHOD(Console, cmdVMVarlist)); // alias
DCmd_Register("vl", WRAP_METHOD(Console, cmdVMVarlist)); // alias
DCmd_Register("vm_vars", WRAP_METHOD(Console, cmdVMVars));
DCmd_Register("vmvars", WRAP_METHOD(Console, cmdVMVars)); // alias
DCmd_Register("vv", WRAP_METHOD(Console, cmdVMVars)); // alias
DCmd_Register("stack", WRAP_METHOD(Console, cmdStack));
DCmd_Register("value_type", WRAP_METHOD(Console, cmdValueType));
DCmd_Register("view_listnode", WRAP_METHOD(Console, cmdViewListNode));
DCmd_Register("view_reference", WRAP_METHOD(Console, cmdViewReference));
DCmd_Register("vr", WRAP_METHOD(Console, cmdViewReference)); // alias
DCmd_Register("view_object", WRAP_METHOD(Console, cmdViewObject));
DCmd_Register("vo", WRAP_METHOD(Console, cmdViewObject)); // alias
DCmd_Register("active_object", WRAP_METHOD(Console, cmdViewActiveObject));
DCmd_Register("acc_object", WRAP_METHOD(Console, cmdViewAccumulatorObject));
registerCmd("script_steps", WRAP_METHOD(Console, cmdScriptSteps));
registerCmd("vm_varlist", WRAP_METHOD(Console, cmdVMVarlist));
registerCmd("vmvarlist", WRAP_METHOD(Console, cmdVMVarlist)); // alias
registerCmd("vl", WRAP_METHOD(Console, cmdVMVarlist)); // alias
registerCmd("vm_vars", WRAP_METHOD(Console, cmdVMVars));
registerCmd("vmvars", WRAP_METHOD(Console, cmdVMVars)); // alias
registerCmd("vv", WRAP_METHOD(Console, cmdVMVars)); // alias
registerCmd("stack", WRAP_METHOD(Console, cmdStack));
registerCmd("value_type", WRAP_METHOD(Console, cmdValueType));
registerCmd("view_listnode", WRAP_METHOD(Console, cmdViewListNode));
registerCmd("view_reference", WRAP_METHOD(Console, cmdViewReference));
registerCmd("vr", WRAP_METHOD(Console, cmdViewReference)); // alias
registerCmd("view_object", WRAP_METHOD(Console, cmdViewObject));
registerCmd("vo", WRAP_METHOD(Console, cmdViewObject)); // alias
registerCmd("active_object", WRAP_METHOD(Console, cmdViewActiveObject));
registerCmd("acc_object", WRAP_METHOD(Console, cmdViewAccumulatorObject));
_debugState.seeking = kDebugSeekNothing;
_debugState.seekLevel = 0;

46
engines/scumm/debugger.cpp
View file

@ -64,39 +64,39 @@ ScummDebugger::ScummDebugger(ScummEngine *s)
registerVar("scumm_vars", &_vm->_scummVars, DVAR_INTARRAY, _vm->_numVariables);
// Register commands
DCmd_Register("continue", WRAP_METHOD(ScummDebugger, Cmd_Exit));
DCmd_Register("restart", WRAP_METHOD(ScummDebugger, Cmd_Restart));
registerCmd("continue", WRAP_METHOD(ScummDebugger, Cmd_Exit));
registerCmd("restart", WRAP_METHOD(ScummDebugger, Cmd_Restart));
DCmd_Register("actor", WRAP_METHOD(ScummDebugger, Cmd_Actor));
DCmd_Register("actors", WRAP_METHOD(ScummDebugger, Cmd_PrintActor));
DCmd_Register("box", WRAP_METHOD(ScummDebugger, Cmd_PrintBox));
DCmd_Register("matrix", WRAP_METHOD(ScummDebugger, Cmd_PrintBoxMatrix));
DCmd_Register("camera", WRAP_METHOD(ScummDebugger, Cmd_Camera));
DCmd_Register("room", WRAP_METHOD(ScummDebugger, Cmd_Room));
DCmd_Register("objects", WRAP_METHOD(ScummDebugger, Cmd_PrintObjects));
DCmd_Register("object", WRAP_METHOD(ScummDebugger, Cmd_Object));
DCmd_Register("script", WRAP_METHOD(ScummDebugger, Cmd_Script));
DCmd_Register("scr", WRAP_METHOD(ScummDebugger, Cmd_Script));
DCmd_Register("scripts", WRAP_METHOD(ScummDebugger, Cmd_PrintScript));
DCmd_Register("importres", WRAP_METHOD(ScummDebugger, Cmd_ImportRes));
registerCmd("actor", WRAP_METHOD(ScummDebugger, Cmd_Actor));
registerCmd("actors", WRAP_METHOD(ScummDebugger, Cmd_PrintActor));
registerCmd("box", WRAP_METHOD(ScummDebugger, Cmd_PrintBox));
registerCmd("matrix", WRAP_METHOD(ScummDebugger, Cmd_PrintBoxMatrix));
registerCmd("camera", WRAP_METHOD(ScummDebugger, Cmd_Camera));
registerCmd("room", WRAP_METHOD(ScummDebugger, Cmd_Room));
registerCmd("objects", WRAP_METHOD(ScummDebugger, Cmd_PrintObjects));
registerCmd("object", WRAP_METHOD(ScummDebugger, Cmd_Object));
registerCmd("script", WRAP_METHOD(ScummDebugger, Cmd_Script));
registerCmd("scr", WRAP_METHOD(ScummDebugger, Cmd_Script));
registerCmd("scripts", WRAP_METHOD(ScummDebugger, Cmd_PrintScript));
registerCmd("importres", WRAP_METHOD(ScummDebugger, Cmd_ImportRes));
if (_vm->_game.id == GID_LOOM)
DCmd_Register("drafts", WRAP_METHOD(ScummDebugger, Cmd_PrintDraft));
registerCmd("drafts", WRAP_METHOD(ScummDebugger, Cmd_PrintDraft));
if (_vm->_game.id == GID_MONKEY && _vm->_game.platform == Common::kPlatformSegaCD)
DCmd_Register("passcode", WRAP_METHOD(ScummDebugger, Cmd_Passcode));
registerCmd("passcode", WRAP_METHOD(ScummDebugger, Cmd_Passcode));
DCmd_Register("loadgame", WRAP_METHOD(ScummDebugger, Cmd_LoadGame));
DCmd_Register("savegame", WRAP_METHOD(ScummDebugger, Cmd_SaveGame));
registerCmd("loadgame", WRAP_METHOD(ScummDebugger, Cmd_LoadGame));
registerCmd("savegame", WRAP_METHOD(ScummDebugger, Cmd_SaveGame));
DCmd_Register("debug", WRAP_METHOD(ScummDebugger, Cmd_Debug));
registerCmd("debug", WRAP_METHOD(ScummDebugger, Cmd_Debug));
DCmd_Register("show", WRAP_METHOD(ScummDebugger, Cmd_Show));
DCmd_Register("hide", WRAP_METHOD(ScummDebugger, Cmd_Hide));
registerCmd("show", WRAP_METHOD(ScummDebugger, Cmd_Show));
registerCmd("hide", WRAP_METHOD(ScummDebugger, Cmd_Hide));
DCmd_Register("imuse", WRAP_METHOD(ScummDebugger, Cmd_IMuse));
registerCmd("imuse", WRAP_METHOD(ScummDebugger, Cmd_IMuse));
DCmd_Register("resetcursors", WRAP_METHOD(ScummDebugger, Cmd_ResetCursors));
registerCmd("resetcursors", WRAP_METHOD(ScummDebugger, Cmd_ResetCursors));
}
ScummDebugger::~ScummDebugger() {

16
engines/sky/debug.cpp
View file

@ -1087,14 +1087,14 @@ void Debug::mcode(uint32 mcode, uint32 a, uint32 b, uint32 c) {
Debugger::Debugger(Logic *logic, Mouse *mouse, Screen *screen, SkyCompact *skyCompact)
: GUI::Debugger(), _logic(logic), _mouse(mouse), _screen(screen), _skyCompact(skyCompact), _showGrid(false) {
DCmd_Register("info", WRAP_METHOD(Debugger, Cmd_Info));
DCmd_Register("showgrid", WRAP_METHOD(Debugger, Cmd_ShowGrid));
DCmd_Register("reloadgrid", WRAP_METHOD(Debugger, Cmd_ReloadGrid));
DCmd_Register("compact", WRAP_METHOD(Debugger, Cmd_ShowCompact));
DCmd_Register("logiccmd", WRAP_METHOD(Debugger, Cmd_LogicCommand));
DCmd_Register("scriptvar", WRAP_METHOD(Debugger, Cmd_ScriptVar));
DCmd_Register("section", WRAP_METHOD(Debugger, Cmd_Section));
DCmd_Register("logiclist", WRAP_METHOD(Debugger, Cmd_LogicList));
registerCmd("info", WRAP_METHOD(Debugger, Cmd_Info));
registerCmd("showgrid", WRAP_METHOD(Debugger, Cmd_ShowGrid));
registerCmd("reloadgrid", WRAP_METHOD(Debugger, Cmd_ReloadGrid));
registerCmd("compact", WRAP_METHOD(Debugger, Cmd_ShowCompact));
registerCmd("logiccmd", WRAP_METHOD(Debugger, Cmd_LogicCommand));
registerCmd("scriptvar", WRAP_METHOD(Debugger, Cmd_ScriptVar));
registerCmd("section", WRAP_METHOD(Debugger, Cmd_Section));
registerCmd("logiclist", WRAP_METHOD(Debugger, Cmd_LogicList));
}
Debugger::~Debugger() {} // we need this here for __SYMBIAN32__

78
engines/sword2/console.cpp
View file

@ -82,45 +82,45 @@ Debugger::Debugger(Sword2Engine *vm)
// Register commands
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("q", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("mem", WRAP_METHOD(Debugger, Cmd_Mem));
DCmd_Register("tony", WRAP_METHOD(Debugger, Cmd_Tony));
DCmd_Register("res", WRAP_METHOD(Debugger, Cmd_Res));
DCmd_Register("reslist", WRAP_METHOD(Debugger, Cmd_ResList));
DCmd_Register("starts", WRAP_METHOD(Debugger, Cmd_Starts));
DCmd_Register("start", WRAP_METHOD(Debugger, Cmd_Start));
DCmd_Register("s", WRAP_METHOD(Debugger, Cmd_Start));
DCmd_Register("info", WRAP_METHOD(Debugger, Cmd_Info));
DCmd_Register("walkgrid", WRAP_METHOD(Debugger, Cmd_WalkGrid));
DCmd_Register("mouse", WRAP_METHOD(Debugger, Cmd_Mouse));
DCmd_Register("player", WRAP_METHOD(Debugger, Cmd_Player));
DCmd_Register("reslook", WRAP_METHOD(Debugger, Cmd_ResLook));
DCmd_Register("cur", WRAP_METHOD(Debugger, Cmd_CurrentInfo));
DCmd_Register("runlist", WRAP_METHOD(Debugger, Cmd_RunList));
DCmd_Register("kill", WRAP_METHOD(Debugger, Cmd_Kill));
DCmd_Register("nuke", WRAP_METHOD(Debugger, Cmd_Nuke));
DCmd_Register("var", WRAP_METHOD(Debugger, Cmd_Var));
DCmd_Register("rect", WRAP_METHOD(Debugger, Cmd_Rect));
DCmd_Register("clear", WRAP_METHOD(Debugger, Cmd_Clear));
DCmd_Register("debugon", WRAP_METHOD(Debugger, Cmd_DebugOn));
DCmd_Register("debugoff", WRAP_METHOD(Debugger, Cmd_DebugOff));
DCmd_Register("saverest", WRAP_METHOD(Debugger, Cmd_SaveRest));
DCmd_Register("timeon", WRAP_METHOD(Debugger, Cmd_TimeOn));
DCmd_Register("timeoff", WRAP_METHOD(Debugger, Cmd_TimeOff));
DCmd_Register("text", WRAP_METHOD(Debugger, Cmd_Text));
DCmd_Register("showvar", WRAP_METHOD(Debugger, Cmd_ShowVar));
DCmd_Register("hidevar", WRAP_METHOD(Debugger, Cmd_HideVar));
DCmd_Register("version", WRAP_METHOD(Debugger, Cmd_Version));
DCmd_Register("animtest", WRAP_METHOD(Debugger, Cmd_AnimTest));
DCmd_Register("texttest", WRAP_METHOD(Debugger, Cmd_TextTest));
DCmd_Register("linetest", WRAP_METHOD(Debugger, Cmd_LineTest));
DCmd_Register("events", WRAP_METHOD(Debugger, Cmd_Events));
DCmd_Register("sfx", WRAP_METHOD(Debugger, Cmd_Sfx));
DCmd_Register("english", WRAP_METHOD(Debugger, Cmd_English));
DCmd_Register("finnish", WRAP_METHOD(Debugger, Cmd_Finnish));
DCmd_Register("polish", WRAP_METHOD(Debugger, Cmd_Polish));
DCmd_Register("fxq", WRAP_METHOD(Debugger, Cmd_FxQueue));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("q", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("mem", WRAP_METHOD(Debugger, Cmd_Mem));
registerCmd("tony", WRAP_METHOD(Debugger, Cmd_Tony));
registerCmd("res", WRAP_METHOD(Debugger, Cmd_Res));
registerCmd("reslist", WRAP_METHOD(Debugger, Cmd_ResList));
registerCmd("starts", WRAP_METHOD(Debugger, Cmd_Starts));
registerCmd("start", WRAP_METHOD(Debugger, Cmd_Start));
registerCmd("s", WRAP_METHOD(Debugger, Cmd_Start));
registerCmd("info", WRAP_METHOD(Debugger, Cmd_Info));
registerCmd("walkgrid", WRAP_METHOD(Debugger, Cmd_WalkGrid));
registerCmd("mouse", WRAP_METHOD(Debugger, Cmd_Mouse));
registerCmd("player", WRAP_METHOD(Debugger, Cmd_Player));
registerCmd("reslook", WRAP_METHOD(Debugger, Cmd_ResLook));
registerCmd("cur", WRAP_METHOD(Debugger, Cmd_CurrentInfo));
registerCmd("runlist", WRAP_METHOD(Debugger, Cmd_RunList));
registerCmd("kill", WRAP_METHOD(Debugger, Cmd_Kill));
registerCmd("nuke", WRAP_METHOD(Debugger, Cmd_Nuke));
registerCmd("var", WRAP_METHOD(Debugger, Cmd_Var));
registerCmd("rect", WRAP_METHOD(Debugger, Cmd_Rect));
registerCmd("clear", WRAP_METHOD(Debugger, Cmd_Clear));
registerCmd("debugon", WRAP_METHOD(Debugger, Cmd_DebugOn));
registerCmd("debugoff", WRAP_METHOD(Debugger, Cmd_DebugOff));
registerCmd("saverest", WRAP_METHOD(Debugger, Cmd_SaveRest));
registerCmd("timeon", WRAP_METHOD(Debugger, Cmd_TimeOn));
registerCmd("timeoff", WRAP_METHOD(Debugger, Cmd_TimeOff));
registerCmd("text", WRAP_METHOD(Debugger, Cmd_Text));
registerCmd("showvar", WRAP_METHOD(Debugger, Cmd_ShowVar));
registerCmd("hidevar", WRAP_METHOD(Debugger, Cmd_HideVar));
registerCmd("version", WRAP_METHOD(Debugger, Cmd_Version));
registerCmd("animtest", WRAP_METHOD(Debugger, Cmd_AnimTest));
registerCmd("texttest", WRAP_METHOD(Debugger, Cmd_TextTest));
registerCmd("linetest", WRAP_METHOD(Debugger, Cmd_LineTest));
registerCmd("events", WRAP_METHOD(Debugger, Cmd_Events));
registerCmd("sfx", WRAP_METHOD(Debugger, Cmd_Sfx));
registerCmd("english", WRAP_METHOD(Debugger, Cmd_English));
registerCmd("finnish", WRAP_METHOD(Debugger, Cmd_Finnish));
registerCmd("polish", WRAP_METHOD(Debugger, Cmd_Polish));
registerCmd("fxq", WRAP_METHOD(Debugger, Cmd_FxQueue));
}
void Debugger::varGet(int var) {

14
engines/teenagent/console.cpp
View file

@ -26,13 +26,13 @@
namespace TeenAgent {
Console::Console(TeenAgentEngine *engine) : _engine(engine) {
DCmd_Register("enable_object", WRAP_METHOD(Console, enableObject));
DCmd_Register("disable_object", WRAP_METHOD(Console, enableObject));
DCmd_Register("set_ons", WRAP_METHOD(Console, setOns));
DCmd_Register("set_music", WRAP_METHOD(Console, setMusic));
DCmd_Register("animation", WRAP_METHOD(Console, playAnimation));
DCmd_Register("actor_animation", WRAP_METHOD(Console, playActorAnimation));
DCmd_Register("call", WRAP_METHOD(Console, call));
registerCmd("enable_object", WRAP_METHOD(Console, enableObject));
registerCmd("disable_object", WRAP_METHOD(Console, enableObject));
registerCmd("set_ons", WRAP_METHOD(Console, setOns));
registerCmd("set_music", WRAP_METHOD(Console, setMusic));
registerCmd("animation", WRAP_METHOD(Console, playAnimation));
registerCmd("actor_animation", WRAP_METHOD(Console, playActorAnimation));
registerCmd("call", WRAP_METHOD(Console, call));
}
bool Console::enableObject(int argc, const char **argv) {

10
engines/tinsel/debugger.cpp
View file

@ -62,11 +62,11 @@ int strToInt(const char *s) {
//----------------- CONSOLE CLASS ---------------------
Console::Console() : GUI::Debugger() {
DCmd_Register("item", WRAP_METHOD(Console, cmd_item));
DCmd_Register("scene", WRAP_METHOD(Console, cmd_scene));
DCmd_Register("music", WRAP_METHOD(Console, cmd_music));
DCmd_Register("sound", WRAP_METHOD(Console, cmd_sound));
DCmd_Register("string", WRAP_METHOD(Console, cmd_string));
registerCmd("item", WRAP_METHOD(Console, cmd_item));
registerCmd("scene", WRAP_METHOD(Console, cmd_scene));
registerCmd("music", WRAP_METHOD(Console, cmd_music));
registerCmd("sound", WRAP_METHOD(Console, cmd_sound));
registerCmd("string", WRAP_METHOD(Console, cmd_string));
}
Console::~Console() {

4
engines/toltecs/console.cpp
View file

@ -31,8 +31,8 @@
namespace Toltecs {
Console::Console(ToltecsEngine *vm) : GUI::Debugger(), _vm(vm) {
DCmd_Register("room", WRAP_METHOD(Console, Cmd_Room));
DCmd_Register("dump", WRAP_METHOD(Console, Cmd_Dump));
registerCmd("room", WRAP_METHOD(Console, Cmd_Room));
registerCmd("dump", WRAP_METHOD(Console, Cmd_Dump));
}
Console::~Console() {

6
engines/tony/debugger.cpp
View file

@ -28,9 +28,9 @@
namespace Tony {
Debugger::Debugger() : GUI::Debugger() {
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("scene", WRAP_METHOD(Debugger, Cmd_Scene));
DCmd_Register("dirty_rects", WRAP_METHOD(Debugger, Cmd_DirtyRects));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("scene", WRAP_METHOD(Debugger, Cmd_Scene));
registerCmd("dirty_rects", WRAP_METHOD(Debugger, Cmd_DirtyRects));
}
static int strToInt(const char *s) {

4
engines/touche/console.cpp
View file

@ -26,8 +26,8 @@
namespace Touche {
ToucheConsole::ToucheConsole(ToucheEngine *vm) : GUI::Debugger(), _vm(vm) {
DCmd_Register("startMusic", WRAP_METHOD(ToucheConsole, Cmd_StartMusic));
DCmd_Register("stopMusic", WRAP_METHOD(ToucheConsole, Cmd_StopMusic));
registerCmd("startMusic", WRAP_METHOD(ToucheConsole, Cmd_StartMusic));
registerCmd("stopMusic", WRAP_METHOD(ToucheConsole, Cmd_StopMusic));
}
ToucheConsole::~ToucheConsole() {

26
engines/tsage/debugger.cpp
View file

@ -30,19 +30,19 @@
namespace TsAGE {
Debugger::Debugger() : GUI::Debugger() {
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("scene", WRAP_METHOD(Debugger, Cmd_Scene));
DCmd_Register("walk_regions", WRAP_METHOD(Debugger, Cmd_WalkRegions));
DCmd_Register("priority_regions", WRAP_METHOD(Debugger, Cmd_PriorityRegions));
DCmd_Register("scene_regions", WRAP_METHOD(Debugger, Cmd_SceneRegions));
DCmd_Register("setflag", WRAP_METHOD(Debugger, Cmd_SetFlag));
DCmd_Register("getflag", WRAP_METHOD(Debugger, Cmd_GetFlag));
DCmd_Register("clearflag", WRAP_METHOD(Debugger, Cmd_ClearFlag));
DCmd_Register("listobjects", WRAP_METHOD(Debugger, Cmd_ListObjects));
DCmd_Register("moveobject", WRAP_METHOD(Debugger, Cmd_MoveObject));
DCmd_Register("hotspots", WRAP_METHOD(Debugger, Cmd_Hotspots));
DCmd_Register("sound", WRAP_METHOD(Debugger, Cmd_Sound));
DCmd_Register("setdebug", WRAP_METHOD(Debugger, Cmd_SetDebug));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("scene", WRAP_METHOD(Debugger, Cmd_Scene));
registerCmd("walk_regions", WRAP_METHOD(Debugger, Cmd_WalkRegions));
registerCmd("priority_regions", WRAP_METHOD(Debugger, Cmd_PriorityRegions));
registerCmd("scene_regions", WRAP_METHOD(Debugger, Cmd_SceneRegions));
registerCmd("setflag", WRAP_METHOD(Debugger, Cmd_SetFlag));
registerCmd("getflag", WRAP_METHOD(Debugger, Cmd_GetFlag));
registerCmd("clearflag", WRAP_METHOD(Debugger, Cmd_ClearFlag));
registerCmd("listobjects", WRAP_METHOD(Debugger, Cmd_ListObjects));
registerCmd("moveobject", WRAP_METHOD(Debugger, Cmd_MoveObject));
registerCmd("hotspots", WRAP_METHOD(Debugger, Cmd_Hotspots));
registerCmd("sound", WRAP_METHOD(Debugger, Cmd_Sound));
registerCmd("setdebug", WRAP_METHOD(Debugger, Cmd_SetDebug));
}
static int strToInt(const char *s) {

10
engines/voyeur/debugger.cpp
View file

@ -29,11 +29,11 @@ namespace Voyeur {
Debugger::Debugger(VoyeurEngine *vm) : GUI::Debugger(), _vm(vm) {
// Register methods
DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("exit", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("time", WRAP_METHOD(Debugger, Cmd_Time));
DCmd_Register("hotspots", WRAP_METHOD(Debugger, Cmd_Hotspots));
DCmd_Register("mouse", WRAP_METHOD(Debugger, Cmd_Mouse));
registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("exit", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("time", WRAP_METHOD(Debugger, Cmd_Time));
registerCmd("hotspots", WRAP_METHOD(Debugger, Cmd_Hotspots));
registerCmd("mouse", WRAP_METHOD(Debugger, Cmd_Mouse));
// Set fields
_isTimeActive = true;

4
engines/wintermute/debugger.cpp
View file

@ -29,8 +29,8 @@
namespace Wintermute {
Console::Console(WintermuteEngine *vm) : GUI::Debugger(), _engineRef(vm) {
DCmd_Register("show_fps", WRAP_METHOD(Console, Cmd_ShowFps));
DCmd_Register("dump_file", WRAP_METHOD(Console, Cmd_DumpFile));
registerCmd("show_fps", WRAP_METHOD(Console, Cmd_ShowFps));
registerCmd("dump_file", WRAP_METHOD(Console, Cmd_DumpFile));
}
Console::~Console(void) {

24
engines/zvision/core/console.cpp
View file

@ -45,18 +45,18 @@
namespace ZVision {
Console::Console(ZVision *engine) : GUI::Debugger(), _engine(engine) {
DCmd_Register("loadimage", WRAP_METHOD(Console, cmdLoadImage));
DCmd_Register("loadvideo", WRAP_METHOD(Console, cmdLoadVideo));
DCmd_Register("loadsound", WRAP_METHOD(Console, cmdLoadSound));
DCmd_Register("raw2wav", WRAP_METHOD(Console, cmdRawToWav));
DCmd_Register("setrenderstate", WRAP_METHOD(Console, cmdSetRenderState));
DCmd_Register("generaterendertable", WRAP_METHOD(Console, cmdGenerateRenderTable));
DCmd_Register("setpanoramafov", WRAP_METHOD(Console, cmdSetPanoramaFoV));
DCmd_Register("setpanoramascale", WRAP_METHOD(Console, cmdSetPanoramaScale));
DCmd_Register("changelocation", WRAP_METHOD(Console, cmdChangeLocation));
DCmd_Register("dumpfile", WRAP_METHOD(Console, cmdDumpFile));
DCmd_Register("parseallscrfiles", WRAP_METHOD(Console, cmdParseAllScrFiles));
DCmd_Register("rendertext", WRAP_METHOD(Console, cmdRenderText));
registerCmd("loadimage", WRAP_METHOD(Console, cmdLoadImage));
registerCmd("loadvideo", WRAP_METHOD(Console, cmdLoadVideo));
registerCmd("loadsound", WRAP_METHOD(Console, cmdLoadSound));
registerCmd("raw2wav", WRAP_METHOD(Console, cmdRawToWav));
registerCmd("setrenderstate", WRAP_METHOD(Console, cmdSetRenderState));
registerCmd("generaterendertable", WRAP_METHOD(Console, cmdGenerateRenderTable));
registerCmd("setpanoramafov", WRAP_METHOD(Console, cmdSetPanoramaFoV));
registerCmd("setpanoramascale", WRAP_METHOD(Console, cmdSetPanoramaScale));
registerCmd("changelocation", WRAP_METHOD(Console, cmdChangeLocation));
registerCmd("dumpfile", WRAP_METHOD(Console, cmdDumpFile));
registerCmd("parseallscrfiles", WRAP_METHOD(Console, cmdParseAllScrFiles));
registerCmd("rendertext", WRAP_METHOD(Console, cmdRenderText));
}
bool Console::cmdLoadImage(int argc, const char **argv) {

20
gui/debugger.cpp
View file

@ -55,17 +55,17 @@ Debugger::Debugger() {
registerVar("debug_countdown", &_frameCountdown, DVAR_INT, 0);
// Register commands
//DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("exit", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("quit", WRAP_METHOD(Debugger, Cmd_Exit));
//registerCmd("continue", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("exit", WRAP_METHOD(Debugger, Cmd_Exit));
registerCmd("quit", WRAP_METHOD(Debugger, Cmd_Exit));
DCmd_Register("help", WRAP_METHOD(Debugger, Cmd_Help));
DCmd_Register("openlog", WRAP_METHOD(Debugger, Cmd_OpenLog));
registerCmd("help", WRAP_METHOD(Debugger, Cmd_Help));
registerCmd("openlog", WRAP_METHOD(Debugger, Cmd_OpenLog));
DCmd_Register("debuglevel", WRAP_METHOD(Debugger, Cmd_DebugLevel));
DCmd_Register("debugflag_list", WRAP_METHOD(Debugger, Cmd_DebugFlagsList));
DCmd_Register("debugflag_enable", WRAP_METHOD(Debugger, Cmd_DebugFlagEnable));
DCmd_Register("debugflag_disable", WRAP_METHOD(Debugger, Cmd_DebugFlagDisable));
registerCmd("debuglevel", WRAP_METHOD(Debugger, Cmd_DebugLevel));
registerCmd("debugflag_list", WRAP_METHOD(Debugger, Cmd_DebugFlagsList));
registerCmd("debugflag_enable", WRAP_METHOD(Debugger, Cmd_DebugFlagEnable));
registerCmd("debugflag_disable", WRAP_METHOD(Debugger, Cmd_DebugFlagDisable));
}
Debugger::~Debugger() {
@ -421,7 +421,7 @@ void Debugger::registerVar(const Common::String &varname, void *pointer, VarType
}
// Command registration function
void Debugger::DCmd_Register(const Common::String &cmdname, Debuglet *debuglet) {
void Debugger::registerCmd(const Common::String &cmdname, Debuglet *debuglet) {
assert(debuglet && debuglet->isValid());
_cmds[cmdname] = Common::SharedPtr<Debuglet>(debuglet);
}

4
gui/debugger.h
View file

@ -74,7 +74,7 @@ protected:
* Convenience macro that makes it easier to register a method
* of a debugger subclass as a command.
* Usage example:
* DCmd_Register("COMMAND", WRAP_METHOD(MyDebugger, MyCmd));
* registerCmd("COMMAND", WRAP_METHOD(MyDebugger, MyCmd));
* would register the method MyDebugger::MyCmd(int, const char **)
* under the command name "COMMAND".
*/
@ -108,7 +108,7 @@ protected:
* @todo replace this single method by type safe variants.
*/
void registerVar(const Common::String &varname, void *variable, VarType type, int arraySize);
void DCmd_Register(const Common::String &cmdname, Debuglet *debuglet);
void registerCmd(const Common::String &cmdname, Debuglet *debuglet);
private: