/* ScummVM - Graphic Adventure Engine * * ScummVM is the legal property of its developers, whose names * are too numerous to list here. Please refer to the COPYRIGHT * file distributed with this source distribution. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * * $URL$ * $Id$ * */ #include "common/config-manager.h" #include "common/system.h" #include "kyra/debugger.h" #include "kyra/kyra_v1.h" #include "kyra/kyra_v2.h" #include "kyra/screen.h" #include "kyra/timer.h" namespace Kyra { Debugger::Debugger(KyraEngine *vm) : GUI::Debugger() { _vm = vm; DCmd_Register("screen_debug_mode", WRAP_METHOD(Debugger, cmd_setScreenDebug)); DCmd_Register("facings", WRAP_METHOD(Debugger, cmd_showFacings)); } bool Debugger::cmd_setScreenDebug(int argc, const char **argv) { if (argc > 1) { if (scumm_stricmp(argv[1], "enable") == 0) _vm->screen()->enableScreenDebug(true); else if (scumm_stricmp(argv[1], "disable") == 0) _vm->screen()->enableScreenDebug(false); else DebugPrintf("Use screen_debug_mode to enable or disable it.\n"); } else { DebugPrintf("Screen debug mode is %s.\n", (_vm->screen()->queryScreenDebug() ? "enabled" : "disabled")); DebugPrintf("Use screen_debug_mode to enable or disable it.\n"); } return true; } bool Debugger::cmd_showFacings(int argc, const char **argv) { DebugPrintf("Facing directions:\n"); DebugPrintf("7 0 1\n"); DebugPrintf(" \\ | / \n"); DebugPrintf("6--*--2\n"); DebugPrintf(" / | \\\n"); DebugPrintf("5 4 3\n"); return true; } #pragma mark - Debugger_v1::Debugger_v1(KyraEngine_v1 *vm) : Debugger(vm) { _vm = vm; DCmd_Register("continue", WRAP_METHOD(Debugger_v1, Cmd_Exit)); DCmd_Register("enter", WRAP_METHOD(Debugger_v1, cmd_enterRoom)); DCmd_Register("rooms", WRAP_METHOD(Debugger_v1, cmd_listRooms)); DCmd_Register("flags", WRAP_METHOD(Debugger_v1, cmd_listFlags)); DCmd_Register("toggleflag", WRAP_METHOD(Debugger_v1, cmd_toggleFlag)); DCmd_Register("queryflag", WRAP_METHOD(Debugger_v1, cmd_queryFlag)); DCmd_Register("timers", WRAP_METHOD(Debugger_v1, cmd_listTimers)); DCmd_Register("settimercountdown", WRAP_METHOD(Debugger_v1, cmd_setTimerCountdown)); DCmd_Register("give", WRAP_METHOD(Debugger_v1, cmd_giveItem)); DCmd_Register("birthstones", WRAP_METHOD(Debugger_v1, cmd_listBirthstones)); } void Debugger_v1::preEnter() { //_vm->midi.pause(1); } void Debugger_v1::postEnter() { //_vm->midi.pause(0); } bool Debugger_v1::cmd_enterRoom(int argc, const char **argv) { uint direction = 0; if (argc > 1) { int room = atoi(argv[1]); // game will crash if entering a non-existent room if (room >= _vm->_roomTableSize) { DebugPrintf("room number must be any value between (including) 0 and %d\n", _vm->_roomTableSize-1); return true; } if (argc > 2) { direction = atoi(argv[2]); } else { if (_vm->_roomTable[room].northExit != 0xFFFF) direction = 3; else if (_vm->_roomTable[room].eastExit != 0xFFFF) direction = 4; else if (_vm->_roomTable[room].southExit != 0xFFFF) direction = 1; else if (_vm->_roomTable[room].westExit != 0xFFFF) direction = 2; } _vm->_system->hideOverlay(); _vm->_currentCharacter->facing = direction; _vm->enterNewScene(room, _vm->_currentCharacter->facing, 0, 0, 1); _vm->_screen->_mouseLockCount = 0; _detach_now = true; return false; } DebugPrintf("Syntax: room \n"); return true; } bool Debugger_v1::cmd_listRooms(int argc, const char **argv) { for (int i = 0; i < _vm->_roomTableSize; i++) { DebugPrintf("%-3i: %-10s", i, _vm->_roomFilenameTable[_vm->_roomTable[i].nameIndex]); if (!(i % 8)) DebugPrintf("\n"); } DebugPrintf("\n"); DebugPrintf("Current room: %i\n", _vm->_currentRoom); return true; } bool Debugger_v1::cmd_listFlags(int argc, const char **argv) { for (int i = 0; i < (int)sizeof(_vm->_flagsTable)*8; i++) { DebugPrintf("(%-3i): %-5i", i, _vm->queryGameFlag(i)); if (!(i % 10)) DebugPrintf("\n"); } DebugPrintf("\n"); return true; } bool Debugger_v1::cmd_toggleFlag(int argc, const char **argv) { if (argc > 1) { uint flag = atoi(argv[1]); if (_vm->queryGameFlag(flag)) _vm->resetGameFlag(flag); else _vm->setGameFlag(flag); DebugPrintf("Flag %i is now %i\n", flag, _vm->queryGameFlag(flag)); } else { DebugPrintf("Syntax: toggleflag \n"); } return true; } bool Debugger_v1::cmd_queryFlag(int argc, const char **argv) { if (argc > 1) { uint flag = atoi(argv[1]); DebugPrintf("Flag %i is %i\n", flag, _vm->queryGameFlag(flag)); } else { DebugPrintf("Syntax: queryflag \n"); } return true; } bool Debugger_v1::cmd_listTimers(int argc, const char **argv) { for (int i = 0; i < _vm->timer()->count(); i++) DebugPrintf("Timer %-2i: Active: %-3s Countdown: %-6i\n", i, _vm->timer()->isEnabled(i) ? "Yes" : "No", _vm->timer()->getDelay(i)); return true; } bool Debugger_v1::cmd_setTimerCountdown(int argc, const char **argv) { if (argc > 2) { uint timer = atoi(argv[1]); uint countdown = atoi(argv[2]); _vm->timer()->setCountdown(timer, countdown); DebugPrintf("Timer %i now has countdown %i\n", timer, _vm->timer()->getDelay(timer)); } else { DebugPrintf("Syntax: settimercountdown \n"); } return true; } bool Debugger_v1::cmd_giveItem(int argc, const char **argv) { if (argc == 2) { int item = atoi(argv[1]); // Kyrandia 1 has only 108 items (-1 to 106), otherwise it will crash if (item < -1 || item > 106) { DebugPrintf("itemid must be any value between (including) -1 and 106\n"); return true; } _vm->setMouseItem(item); _vm->_itemInHand = item; } else { DebugPrintf("Syntax: give \n"); } return true; } bool Debugger_v1::cmd_listBirthstones(int argc, const char **argv) { DebugPrintf("Needed Birthstone gems:\n"); for (int i = 0; i < ARRAYSIZE(_vm->_birthstoneGemTable); ++i) DebugPrintf("%-2d '%s'\n", _vm->_birthstoneGemTable[i], _vm->_itemList[_vm->_birthstoneGemTable[i]]); return true; } #pragma mark - Debugger_v2::Debugger_v2(KyraEngine_v2 *vm) : Debugger(vm), _vm(vm) { DCmd_Register("continue", WRAP_METHOD(Debugger_v2, Cmd_Exit)); DCmd_Register("character_info", WRAP_METHOD(Debugger_v2, cmd_characterInfo)); DCmd_Register("enter", WRAP_METHOD(Debugger_v2, cmd_enterScene)); DCmd_Register("rooms", WRAP_METHOD(Debugger_v2, cmd_listScenes)); // for consistency with kyra_v1 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)); } bool Debugger_v2::cmd_enterScene(int argc, const char **argv) { uint direction = 0; if (argc > 1) { int scene = atoi(argv[1]); // game will crash if entering a non-existent scene if (scene >= _vm->_sceneListSize) { DebugPrintf("scene number must be any value between (including) 0 and %d\n", _vm->_sceneListSize-1); return true; } if (argc > 2) { direction = atoi(argv[2]); } else { if (_vm->_sceneList[scene].exit1 != 0xFFFF) direction = 4; else if (_vm->_sceneList[scene].exit2 != 0xFFFF) direction = 6; else if (_vm->_sceneList[scene].exit3 != 0xFFFF) direction = 0; else if (_vm->_sceneList[scene].exit4 != 0xFFFF) direction = 2; } _vm->_system->hideOverlay(); _vm->_mainCharacter.facing = direction; _vm->enterNewScene(scene, _vm->_mainCharacter.facing, 0, 0, 1); _vm->_screen->_mouseLockCount = 0; _detach_now = true; return false; } DebugPrintf("Syntax: %d \n", argv[0]); return true; } bool Debugger_v2::cmd_listScenes(int argc, const char **argv) { int shown = 1; for (int i = 0; i < _vm->_sceneListSize; ++i) { if (_vm->_sceneList[i].filename[0]) { DebugPrintf("%-2i: %-10s", i, _vm->_sceneList[i].filename); if (!(shown % 5)) DebugPrintf("\n"); ++shown; } } DebugPrintf("\n"); DebugPrintf("Current scene: %i\n", _vm->_currentScene); return true; } bool Debugger_v2::cmd_sceneInfo(int argc, const char **argv) { DebugPrintf("Current scene: %d '%s'\n", _vm->_currentScene, _vm->_sceneList[_vm->_currentScene].filename); DebugPrintf("\n"); DebugPrintf("Exit information:\n"); DebugPrintf("Exit1: leads to %d, position %dx%d\n", int16(_vm->_sceneExit1), _vm->_sceneEnterX1, _vm->_sceneEnterY1); DebugPrintf("Exit2: leads to %d, position %dx%d\n", int16(_vm->_sceneExit2), _vm->_sceneEnterX2, _vm->_sceneEnterY2); DebugPrintf("Exit3: leads to %d, position %dx%d\n", int16(_vm->_sceneExit3), _vm->_sceneEnterX3, _vm->_sceneEnterY3); DebugPrintf("Exit4: leads to %d, position %dx%d\n", int16(_vm->_sceneExit4), _vm->_sceneEnterX4, _vm->_sceneEnterY4); DebugPrintf("Special exit information:\n"); if (!_vm->_specialExitCount) { DebugPrintf("No special exits.\n"); } else { DebugPrintf("This scene has %d special exits.\n", _vm->_specialExitCount); for (int i = 0; i < _vm->_specialExitCount; ++i) { DebugPrintf("SpecialExit%d: facing %d, position (x1/y1/x2/y2): %d/%d/%d/%d\n", i, _vm->_specialExitTable[20+i], _vm->_specialExitTable[0+i], _vm->_specialExitTable[5+i], _vm->_specialExitTable[10+i], _vm->_specialExitTable[15+i]); } } return true; } bool Debugger_v2::cmd_characterInfo(int argc, const char **argv) { DebugPrintf("Main character is in scene: %d '%s'\n", _vm->_mainCharacter.sceneId, _vm->_sceneList[_vm->_mainCharacter.sceneId].filename); DebugPrintf("Position: %dx%d\n", _vm->_mainCharacter.x1, _vm->_mainCharacter.y1); DebugPrintf("Facing: %d\n", _vm->_mainCharacter.facing); DebugPrintf("Inventory:\n"); for (int i = 0; i < 20; ++i) { DebugPrintf("%-2d ", int8(_vm->_mainCharacter.inventory[i])); if (i == 9 || i == 19) DebugPrintf("\n"); } return true; } bool Debugger_v2::cmd_sceneToFacing(int argc, const char **argv) { if (argc == 2) { int facing = atoi(argv[1]); int16 exit = -1; switch (facing) { case 0: case 1: case 7: exit = _vm->_sceneList[_vm->_currentScene].exit1; break; case 6: exit = _vm->_sceneList[_vm->_currentScene].exit2; break; case 3: case 4: case 5: exit = _vm->_sceneList[_vm->_currentScene].exit3; break; case 2: exit = _vm->_sceneList[_vm->_currentScene].exit4; break; default: break; } DebugPrintf("Exit to facing %d leads to room %d.\n", facing, exit); } else { DebugPrintf("Usage: %s \n", argv[0]); } return true; } bool Debugger_v2::cmd_giveItem(int argc, const char **argv) { if (argc == 2) { int item = atoi(argv[1]); // Kyrandia 2 has only 178 items (-1 to 176), otherwise it will crash if (item < -1 || item > 176) { DebugPrintf("itemid must be any value between (including) -1 and 176\n"); return true; } _vm->setHandItem(item); } else { DebugPrintf("Syntax: give \n"); } return true; } } // End of namespace Kyra