diff options
38 files changed, 499 insertions, 499 deletions
diff --git a/engines/agi/console.cpp b/engines/agi/console.cpp index dce85b931c..6d7f9384cd 100644 --- a/engines/agi/console.cpp +++ b/engines/agi/console.cpp @@ -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) { diff --git a/engines/agos/debugger.cpp b/engines/agos/debugger.cpp index 99ea8a15b7..536a1f87bd 100644 --- a/engines/agos/debugger.cpp +++ b/engines/agos/debugger.cpp @@ -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)); } diff --git a/engines/avalanche/console.cpp b/engines/avalanche/console.cpp index 639ad63491..d4923affc1 100644 --- a/engines/avalanche/console.cpp +++ b/engines/avalanche/console.cpp @@ -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() { diff --git a/engines/cge/console.cpp b/engines/cge/console.cpp index 3d281df3ef..e926e89506 100644 --- a/engines/cge/console.cpp +++ b/engines/cge/console.cpp @@ -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() { diff --git a/engines/cine/console.cpp b/engines/cine/console.cpp index 82197693d4..4646bdf280 100644 --- a/engines/cine/console.cpp +++ b/engines/cine/console.cpp @@ -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; } diff --git a/engines/cruise/debugger.cpp b/engines/cruise/debugger.cpp index 0bda44d0df..0627432ef8 100644 --- a/engines/cruise/debugger.cpp +++ b/engines/cruise/debugger.cpp @@ -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)); } /** diff --git a/engines/drascula/console.cpp b/engines/drascula/console.cpp index 4c14fb74fb..b545c096d0 100644 --- a/engines/drascula/console.cpp +++ b/engines/drascula/console.cpp @@ -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() { diff --git a/engines/fullpipe/console.cpp b/engines/fullpipe/console.cpp index 3ff84dae5f..dd3d1bf693 100644 --- a/engines/fullpipe/console.cpp +++ b/engines/fullpipe/console.cpp @@ -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) { diff --git a/engines/gob/console.cpp b/engines/gob/console.cpp index 303c59c4da..2252606243 100644 --- a/engines/gob/console.cpp +++ b/engines/gob/console.cpp @@ -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() { diff --git a/engines/groovie/debug.cpp b/engines/groovie/debug.cpp index 85b9b87652..16db20413f 100644 --- a/engines/groovie/debug.cpp +++ b/engines/groovie/debug.cpp @@ -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() { diff --git a/engines/hopkins/debugger.cpp b/engines/hopkins/debugger.cpp index e5c19847fb..323afef70f 100644 --- a/engines/hopkins/debugger.cpp +++ b/engines/hopkins/debugger.cpp @@ -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 diff --git a/engines/hugo/console.cpp b/engines/hugo/console.cpp index 529fa4f7bd..d02c42658f 100644 --- a/engines/hugo/console.cpp +++ b/engines/hugo/console.cpp @@ -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() { diff --git a/engines/kyra/debugger.cpp b/engines/kyra/debugger.cpp index 598eb1c1b0..f14c42beea 100644 --- a/engines/kyra/debugger.cpp +++ b/engines/kyra/debugger.cpp @@ -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) { diff --git a/engines/lastexpress/debug.cpp b/engines/lastexpress/debug.cpp index e13a2f6194..2fb2cd834b 100644 --- a/engines/lastexpress/debug.cpp +++ b/engines/lastexpress/debug.cpp @@ -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(); diff --git a/engines/lure/debugger.cpp b/engines/lure/debugger.cpp index d2b0cd473b..7ab32125b5 100644 --- a/engines/lure/debugger.cpp +++ b/engines/lure/debugger.cpp @@ -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) { diff --git a/engines/mads/debugger.cpp b/engines/mads/debugger.cpp index 798cd004b4..e82b39f8c2 100644 --- a/engines/mads/debugger.cpp +++ b/engines/mads/debugger.cpp @@ -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) { diff --git a/engines/mohawk/console.cpp b/engines/mohawk/console.cpp index ec0b5a0ab2..d49f3e8637 100644 --- a/engines/mohawk/console.cpp +++ b/engines/mohawk/console.cpp @@ -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() { diff --git a/engines/mortevielle/debugger.cpp b/engines/mortevielle/debugger.cpp index c8f75918ab..8418ae056c 100644 --- a/engines/mortevielle/debugger.cpp +++ b/engines/mortevielle/debugger.cpp @@ -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) { diff --git a/engines/neverhood/console.cpp b/engines/neverhood/console.cpp index b35c29bd5c..91ab3e767a 100644 --- a/engines/neverhood/console.cpp +++ b/engines/neverhood/console.cpp @@ -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() { diff --git a/engines/parallaction/debug.cpp b/engines/parallaction/debug.cpp index c5e694168e..e4239eb786 100644 --- a/engines/parallaction/debug.cpp +++ b/engines/parallaction/debug.cpp @@ -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)); } diff --git a/engines/pegasus/console.cpp b/engines/pegasus/console.cpp index 8a465c58a1..e5a0cfec98 100644 --- a/engines/pegasus/console.cpp +++ b/engines/pegasus/console.cpp @@ -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() { diff --git a/engines/queen/debug.cpp b/engines/queen/debug.cpp index 20638589e1..125ddf30c6 100644 --- a/engines/queen/debug.cpp +++ b/engines/queen/debug.cpp @@ -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__ diff --git a/engines/saga/console.cpp b/engines/saga/console.cpp index 48aa9f9c4e..042635e3e3 100644 --- a/engines/saga/console.cpp +++ b/engines/saga/console.cpp @@ -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() { diff --git a/engines/sci/console.cpp b/engines/sci/console.cpp index b02429c2a1..1a2ee21fba 100644 --- a/engines/sci/console.cpp +++ b/engines/sci/console.cpp @@ -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; diff --git a/engines/scumm/debugger.cpp b/engines/scumm/debugger.cpp index 01535bf60a..fed523fad2 100644 --- a/engines/scumm/debugger.cpp +++ b/engines/scumm/debugger.cpp @@ -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)); - - 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("continue", WRAP_METHOD(ScummDebugger, Cmd_Exit)); + registerCmd("restart", WRAP_METHOD(ScummDebugger, Cmd_Restart)); + + 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() { diff --git a/engines/sky/debug.cpp b/engines/sky/debug.cpp index f79ce2b53e..d663bd206d 100644 --- a/engines/sky/debug.cpp +++ b/engines/sky/debug.cpp @@ -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__ diff --git a/engines/sword2/console.cpp b/engines/sword2/console.cpp index 7c45368951..810b40c583 100644 --- a/engines/sword2/console.cpp +++ b/engines/sword2/console.cpp @@ -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) { diff --git a/engines/teenagent/console.cpp b/engines/teenagent/console.cpp index 294b9f923b..2304829782 100644 --- a/engines/teenagent/console.cpp +++ b/engines/teenagent/console.cpp @@ -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) { diff --git a/engines/tinsel/debugger.cpp b/engines/tinsel/debugger.cpp index ab2e0f19cd..1dbb19d383 100644 --- a/engines/tinsel/debugger.cpp +++ b/engines/tinsel/debugger.cpp @@ -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() { diff --git a/engines/toltecs/console.cpp b/engines/toltecs/console.cpp index 5dcd9233a5..5a0c66c7b0 100644 --- a/engines/toltecs/console.cpp +++ b/engines/toltecs/console.cpp @@ -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() { diff --git a/engines/tony/debugger.cpp b/engines/tony/debugger.cpp index 2a9086888a..0e59fb8470 100644 --- a/engines/tony/debugger.cpp +++ b/engines/tony/debugger.cpp @@ -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) { diff --git a/engines/touche/console.cpp b/engines/touche/console.cpp index 2cd8572253..472863c817 100644 --- a/engines/touche/console.cpp +++ b/engines/touche/console.cpp @@ -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() { diff --git a/engines/tsage/debugger.cpp b/engines/tsage/debugger.cpp index b014e4e947..b0e741198b 100644 --- a/engines/tsage/debugger.cpp +++ b/engines/tsage/debugger.cpp @@ -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) { diff --git a/engines/voyeur/debugger.cpp b/engines/voyeur/debugger.cpp index 90b9255e9f..71a0e7e853 100644 --- a/engines/voyeur/debugger.cpp +++ b/engines/voyeur/debugger.cpp @@ -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; diff --git a/engines/wintermute/debugger.cpp b/engines/wintermute/debugger.cpp index f1f300c18e..a313314a8b 100644 --- a/engines/wintermute/debugger.cpp +++ b/engines/wintermute/debugger.cpp @@ -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) { diff --git a/engines/zvision/core/console.cpp b/engines/zvision/core/console.cpp index a1037a1e96..e610f34474 100644 --- a/engines/zvision/core/console.cpp +++ b/engines/zvision/core/console.cpp @@ -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) { diff --git a/gui/debugger.cpp b/gui/debugger.cpp index 1d74db30cc..a419ef4dfb 100644 --- a/gui/debugger.cpp +++ b/gui/debugger.cpp @@ -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); } diff --git a/gui/debugger.h b/gui/debugger.h index 6ccc77b129..9dbc4084e8 100644 --- a/gui/debugger.h +++ b/gui/debugger.h @@ -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: |