/* ScummVM - Graphic Adventure Engine * * ScummVM is the legal property of its developers, whose names * are too numerous to list here. Please refer to the COPYRIGHT * file distributed with this source distribution. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * */ #include "glk/adrift/adrift.h" #include "glk/adrift/scprotos.h" #include "glk/adrift/scgamest.h" namespace Glk { namespace Adrift { /* Assorted definitions and constants. */ static const sc_uint DEBUG_MAGIC = 0xc4584d2e; enum { DEBUG_BUFFER_SIZE = 256 }; /* Debugging command and command argument type. */ enum sc_command_t { DEBUG_NONE = 0, DEBUG_CONTINUE, DEBUG_STEP, DEBUG_BUFFER, DEBUG_RESOURCES, DEBUG_HELP, DEBUG_GAME, DEBUG_PLAYER, DEBUG_ROOMS, DEBUG_OBJECTS, DEBUG_NPCS, DEBUG_EVENTS, DEBUG_TASKS, DEBUG_VARIABLES, DEBUG_OLDPLAYER, DEBUG_OLDROOMS, DEBUG_OLDOBJECTS, DEBUG_OLDNPCS, DEBUG_OLDEVENTS, DEBUG_OLDTASKS, DEBUG_OLDVARIABLES, DEBUG_WATCHPLAYER, DEBUG_WATCHOBJECTS, DEBUG_WATCHNPCS, DEBUG_WATCHEVENTS, DEBUG_WATCHTASKS, DEBUG_WATCHVARIABLES, DEBUG_CLEARPLAYER, DEBUG_CLEAROBJECTS, DEBUG_CLEARNPCS, DEBUG_CLEAREVENTS, DEBUG_CLEARTASKS, DEBUG_CLEARVARIABLES, DEBUG_WATCHALL, DEBUG_CLEARALL, DEBUG_RANDOM, DEBUG_QUIT }; enum sc_command_type_t { COMMAND_QUERY = 0, COMMAND_RANGE, COMMAND_ONE, COMMAND_ALL }; /* Table connecting debugging command strings to commands. */ struct sc_strings_t { const sc_char *const command_string; const sc_command_t command; }; static const sc_strings_t DEBUG_COMMANDS[] = { {"continue", DEBUG_CONTINUE}, {"step", DEBUG_STEP}, {"buffer", DEBUG_BUFFER}, {"resources", DEBUG_RESOURCES}, {"help", DEBUG_HELP}, {"game", DEBUG_GAME}, {"player", DEBUG_PLAYER}, {"rooms", DEBUG_ROOMS}, {"objects", DEBUG_OBJECTS}, {"npcs", DEBUG_NPCS}, {"events", DEBUG_EVENTS}, {"tasks", DEBUG_TASKS}, {"variables", DEBUG_VARIABLES}, {"oldplayer", DEBUG_OLDPLAYER}, {"oldrooms", DEBUG_OLDROOMS}, {"oldobjects", DEBUG_OLDOBJECTS}, {"oldnpcs", DEBUG_OLDNPCS}, {"oldevents", DEBUG_OLDEVENTS}, {"oldtasks", DEBUG_OLDTASKS}, {"oldvariables", DEBUG_OLDVARIABLES}, {"watchplayer", DEBUG_WATCHPLAYER}, {"clearplayer", DEBUG_CLEARPLAYER}, {"watchobjects", DEBUG_WATCHOBJECTS}, {"watchnpcs", DEBUG_WATCHNPCS}, {"watchevents", DEBUG_WATCHEVENTS}, {"watchtasks", DEBUG_WATCHTASKS}, {"watchvariables", DEBUG_WATCHVARIABLES}, {"clearobjects", DEBUG_CLEAROBJECTS}, {"clearnpcs", DEBUG_CLEARNPCS}, {"clearevents", DEBUG_CLEAREVENTS}, {"cleartasks", DEBUG_CLEARTASKS}, {"clearvariables", DEBUG_CLEARVARIABLES}, {"watchall", DEBUG_WATCHALL}, {"clearall", DEBUG_CLEARALL}, {"random", DEBUG_RANDOM}, {"quit", DEBUG_QUIT}, {NULL, DEBUG_NONE} }; /* * Debugging control information structure. The structure is created and * added to the game on enabling debug, and removed and destroyed on * disabling debugging. */ struct sc_debugger_s { sc_uint magic; sc_bool *watch_objects; sc_bool *watch_npcs; sc_bool *watch_events; sc_bool *watch_tasks; sc_bool *watch_variables; sc_bool watch_player; sc_bool single_step; sc_bool quit_pending; sc_uint elapsed_seconds; }; typedef sc_debugger_s sc_debugger_t; /* * debug_is_valid() * * Return TRUE if pointer is a valid debugger, FALSE otherwise. */ static sc_bool debug_is_valid(sc_debuggerref_t debug) { return debug && debug->magic == DEBUG_MAGIC; } /* * debug_get_debugger() * * Return the debugger reference from a game, or NULL if none. */ static sc_debuggerref_t debug_get_debugger(sc_gameref_t game) { assert(gs_is_game_valid(game)); return game->debugger; } /* * debug_variable_count() * * Common helper to return the count of variables defined in a game. */ static sc_int debug_variable_count(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key; sc_int variable_count; /* Find and return the variables count. */ vt_key.string = "Variables"; variable_count = prop_get_child_count(bundle, "I<-s", &vt_key); return variable_count; } /* * debug_initialize() * * Create a new set of debug control information, and append it to the * game passed in. */ static void debug_initialize(sc_gameref_t game) { sc_debuggerref_t debug; /* Create the easy bits of the new debugging set. */ debug = (sc_debuggerref_t)sc_malloc(sizeof(*debug)); debug->magic = DEBUG_MAGIC; debug->watch_player = FALSE; debug->single_step = FALSE; debug->quit_pending = FALSE; debug->elapsed_seconds = 0; /* Allocate watchpoints for everything we can watch. */ debug->watch_objects = (sc_bool *)sc_malloc(gs_object_count(game) * sizeof(*debug->watch_objects)); debug->watch_npcs = (sc_bool *)sc_malloc(gs_npc_count(game) * sizeof(*debug->watch_npcs)); debug->watch_events = (sc_bool *)sc_malloc(gs_event_count(game) * sizeof(*debug->watch_events)); debug->watch_tasks = (sc_bool *)sc_malloc(gs_task_count(game) * sizeof(*debug->watch_tasks)); debug->watch_variables = (sc_bool *)sc_malloc(debug_variable_count(game) * sizeof(*debug->watch_variables)); /* Clear all watchpoint arrays. */ memset(debug->watch_objects, FALSE, gs_object_count(game) * sizeof(*debug->watch_objects)); memset(debug->watch_npcs, FALSE, gs_npc_count(game) * sizeof(*debug->watch_npcs)); memset(debug->watch_events, FALSE, gs_event_count(game) * sizeof(*debug->watch_events)); memset(debug->watch_tasks, FALSE, gs_task_count(game) * sizeof(*debug->watch_tasks)); memset(debug->watch_variables, FALSE, debug_variable_count(game) * sizeof(*debug->watch_variables)); /* Append the new debugger set to the game. */ assert(!game->debugger); game->debugger = debug; } /* * debug_finalize() * * Destroy a debug data set, free its heap memory, and remove its reference * from the game. */ static void debug_finalize(sc_gameref_t game) { sc_debuggerref_t debug = debug_get_debugger(game); assert(debug_is_valid(debug)); /* Free all allocated watchpoint arrays. */ sc_free(debug->watch_objects); sc_free(debug->watch_npcs); sc_free(debug->watch_events); sc_free(debug->watch_tasks); sc_free(debug->watch_variables); /* Poison and free the debugger itself. */ memset(debug, 0xaa, sizeof(*debug)); sc_free(debug); /* Remove the debug reference from the game. */ game->debugger = NULL; } /* * debug_help() * * Print debugging help. */ static void debug_help(sc_command_t topic) { /* Is help general, or specific? */ if (topic == DEBUG_NONE) { if_print_debug( "The following debugging commands examine game state:\n\n"); if_print_debug( " game -- Print general game information," " and class counts\n" " player -- Show the player location and position\n" " rooms [Range] -- Print information on game rooms\n" " objects [Range] -- Print information on objects in the game\n" " npcs [Range] -- Print information on game NPCs\n" " events [Range] -- Print information on the game's events\n" " tasks [Range] -- Print information on the game's tasks\n" " variables [Range] -- Show variables defined by the game\n\n"); if_print_debug( "Most commands take range inputs. This can be a single number, to" " apply the command to just that item, a range such as '0 to 10' (or" " '0 - 10', '0 .. 10', or simply '0 10') to apply to that range of" " items, or '*' to apply the command to all items of the class. If" " omitted, the command is applied only to the items of the class" " 'relevant' to the current game state; see the help for specific" " commands for more on what is 'relevant'.\n\n"); if_print_debug( "The 'player', 'objects', 'npcs', 'events', 'tasks', and 'variables'" " commands may be prefixed with 'old', in which case the values" " printed will be those for the previous game turn, rather than the" " current values.\n\n"); if_print_debug( "These debugging commands manage watchpoints:\n\n"); if_print_debug( "The 'player', 'objects', 'npcs', 'events', 'tasks', and 'variables'" " commands may be prefixed with 'watch', to set watchpoints." " Watchpoints automatically enter the debugger when the item changes" " state during a game turn. For example 'watchobject 10' monitors" " object 10 for changes, and 'watchnpc *' monitors all NPCs. A" " 'watch' command with no range prints out all watchpoints set for" " that class.\n\n"); if_print_debug( "Prefix commands with 'clear' to clear watchpoints, for example" " 'clearnpcs *'. Use 'watchall' to obtain a complete list of every" " watchpoint set, and 'clearall' to clear all watchpoints in one go." " A 'clear' command with no range behaves the same as a 'watch'" " command with no range.\n\n"); if_print_debug( "These debugging commands print details of game output and control the" " debugger and interpreter:\n\n"); if_print_debug( " buffer -- Show the current buffered game text\n" " resources -- Show current and requested game resources\n" " random [Seed] -- Control the random number generator\n" " step -- Run one game turn, then re-enter the debugger\n" " continue -- Leave the debugger and resume the game\n" " quit -- Exit the interpreter main loop\n" " help [Command] -- Print help specific to Command\n\n"); if_print_debug( "Debugging commands may be abbreviated to their shortest unambiguous" " form.\n\n"); if_print_debug( "Use the 'debug' or '#debug' command in a game, typed at the usual" " game prompt, to return to the debugger.\n"); return; } /* Command-specific help. */ switch (topic) { case DEBUG_HELP: if_print_debug( "Give the name of the command you want help on, for example 'help" " continue'.\n"); break; case DEBUG_CONTINUE: if_print_debug( "Leave the debugger and resume the game. Use the 'debug' or '#debug'" " command in a game, typed at the usual game prompt, to return to the" " debugger.\n"); break; case DEBUG_STEP: if_print_debug( "Run one game turn, then re-enter the debugger. Useful for games that" " intercept empty input lines, which otherwise catch the 'debug'" " command before SCARE can get to it.\n"); break; case DEBUG_QUIT: if_print_debug( "Exit the interpreter main loop. Equivalent to a confirmed 'quit'" " from within the game itself, this ends the interpreter session.\n"); break; case DEBUG_BUFFER: if_print_debug( "Print the current text that the game has buffered for output. The" " debugger catches games before they have printed their turn output" " -- this is the text that will be filtered and printed on exiting the" " debugger.\n"); break; case DEBUG_RESOURCES: if_print_debug( "Print any resources currently active, and any requested by the game" " on the current turn. The requested resources will become the active" " ones on exiting the debugger.\n"); break; case DEBUG_RANDOM: if_print_debug( "If no seed is given, report the current random number generator" " setting. Otherwise, seed the random number generator with the value" " given. This is useful for persuading games with random sections to" " behave predictably. A new seed value of zero is invalid.\n"); break; case DEBUG_GAME: if_print_debug( "Print general game information, including the number of rooms," " objects, events, tasks, and variables that the game defines\n"); break; case DEBUG_PLAYER: if_print_debug( "Print out the current player room and position, and any parent object" " of the player character.\n"); break; case DEBUG_OLDPLAYER: if_print_debug( "Print out the player room and position from the previous turn, and" " any parent object of the player character.\n"); break; case DEBUG_ROOMS: if_print_debug( "Print out the name and contents of rooms in the range. If no range," " print details of the room containing the player.\n"); break; case DEBUG_OLDROOMS: if_print_debug( "Print out the name and contents of rooms in the range for the" " previous turn. If no range, print details of the room that" " contained the player on the previous turn.\n"); break; case DEBUG_OBJECTS: if_print_debug( "Print out details of all objects in the range. If no range, print" " details of objects in the room containing the player, and visible to" " the player.\n"); break; case DEBUG_OLDOBJECTS: if_print_debug( "Print out details of all objects in the range for the previous turn." " If no range, print details of objects in the room that contained" " the player, and were visible to the player.\n"); break; case DEBUG_NPCS: if_print_debug( "Print out details of all NPCs in the range. If no range, print" " details of only NPCs in the room containing the player.\n"); break; case DEBUG_OLDNPCS: if_print_debug( "Print out details of all NPCs in the range for the previous turn." " If no range, print details of only NPCs in the room that contained" " the player.\n"); break; case DEBUG_EVENTS: if_print_debug( "Print out details of all events in the range. If no range, print" " details of only events currently running.\n"); break; case DEBUG_OLDEVENTS: if_print_debug( "Print out details of all events in the range for the previous turn." " If no range, print details of only events running on the previous" " turn.\n"); break; case DEBUG_TASKS: if_print_debug( "Print out details of all tasks in the range. If no range, print" " details of only tasks that are runnable, for the current state of" " the game.\n"); break; case DEBUG_OLDTASKS: if_print_debug( "Print out details of all tasks in the range for the previous turn." " If no range, print details of only tasks that were runnable, for" " the previous state of the game.\n"); break; case DEBUG_VARIABLES: if_print_debug( "Print out the names, types, and values of all game variables in the" " range. If no range, print details of all variables (equivalent to" " 'variables *').\n"); break; case DEBUG_OLDVARIABLES: if_print_debug( "Print out the names, types, and values at the previous turn of all" " game variables in the range. If no range, print details of all" " variables (equivalent to 'variables *').\n"); break; case DEBUG_WATCHPLAYER: if_print_debug( "If no range is given, list any watchpoint on player movement. If" " range '0' is given, set a watchpoint on player movement. Other" " usages of 'watchplayer' behave as if no range is given.\n"); break; case DEBUG_WATCHOBJECTS: if_print_debug( "Set watchpoints on all objects in the range. If no range, list out" " object watchpoints currently set.\n"); break; case DEBUG_WATCHNPCS: if_print_debug( "Set watchpoints on all NPCs in the range. If no range, list out NPC" " watchpoints currently set.\n"); break; case DEBUG_WATCHEVENTS: if_print_debug( "Set watchpoints on all events in the range. If no range, list out" " event watchpoints currently set.\n"); break; case DEBUG_WATCHTASKS: if_print_debug( "Set watchpoints on all tasks in the range. If no range, list out" " task watchpoints currently set.\n"); break; case DEBUG_WATCHVARIABLES: if_print_debug( "Set watchpoints on all game variables in the range. If no range," " list variable watchpoints currently set.\n"); break; case DEBUG_CLEARPLAYER: if_print_debug( "Clear any watchpoint set on player movements.\n"); break; case DEBUG_CLEAROBJECTS: if_print_debug( "Clear watchpoints on all objects in the range. If no range, list" " out object watchpoints currently set.\n"); break; case DEBUG_CLEARNPCS: if_print_debug( "Clear watchpoints on all NPCs in the range. If no range, list out" " NPC watchpoints currently set.\n"); break; case DEBUG_CLEAREVENTS: if_print_debug( "Clear watchpoints on all events in the range. If no range, list out" " event watchpoints currently set.\n"); break; case DEBUG_CLEARTASKS: if_print_debug( "Clear watchpoints on all tasks in the range. If no range, list out" " task watchpoints currently set.\n"); break; case DEBUG_CLEARVARIABLES: if_print_debug( "Clear watchpoints on all game variables in the range. If no range," " list variable watchpoints currently set.\n"); break; case DEBUG_WATCHALL: if_print_debug( "Print out a list of all all watchpoints set for all the classes of" " item on which watchpoints can be used.\n"); break; case DEBUG_CLEARALL: if_print_debug( "Clear all watchpoints set, on all classes of item on which" " watchpoints can be used.\n"); break; default: if_print_debug( "Sorry, there is no help available on that at the moment.\n"); break; } } /* * debug_print_quoted() * debug_print_player() * debug_print_room() * debug_print_object() * debug_print_npc() * debug_print_event() * debug_print_task() * debug_print_variable() * * Low level output helpers. */ static void debug_print_quoted(const sc_char *string) { if_print_debug_character('"'); if_print_debug(string); if_print_debug_character('"'); } static void debug_print_player(sc_gameref_t game) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[2]; const sc_char *playername; vt_key[0].string = "Globals"; vt_key[1].string = "PlayerName"; playername = prop_get_string(bundle, "S<-ss", vt_key); if_print_debug("Player "); debug_print_quoted(playername); } static void debug_print_room(sc_gameref_t game, sc_int room) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_char buffer[32]; const sc_char *name; if_print_debug("Room "); if (room < 0 || room >= gs_room_count(game)) { sprintf(buffer, "%ld ", room); if_print_debug(buffer); if_print_debug("[Out of range]"); return; } vt_key[0].string = "Rooms"; vt_key[1].integer = room; vt_key[2].string = "Short"; name = prop_get_string(bundle, "S<-sis", vt_key); sprintf(buffer, "%ld ", room); if_print_debug(buffer); debug_print_quoted(name); } static void debug_print_object(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_bool bstatic; sc_char buffer[32]; const sc_char *prefix, *name; if (object < 0 || object >= gs_object_count(game)) { if_print_debug("Object "); sprintf(buffer, "%ld ", object); if_print_debug(buffer); if_print_debug("[Out of range]"); return; } vt_key[0].string = "Objects"; vt_key[1].integer = object; vt_key[2].string = "Static"; bstatic = prop_get_boolean(bundle, "B<-sis", vt_key); vt_key[2].string = "Prefix"; prefix = prop_get_string(bundle, "S<-sis", vt_key); vt_key[2].string = "Short"; name = prop_get_string(bundle, "S<-sis", vt_key); if (bstatic) if_print_debug("Static "); else if_print_debug("Dynamic "); sprintf(buffer, "%ld ", object); if_print_debug(buffer); debug_print_quoted(prefix); if_print_debug_character(' '); debug_print_quoted(name); } static void debug_print_npc(sc_gameref_t game, sc_int npc) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_char buffer[32]; const sc_char *prefix, *name; if_print_debug("NPC "); if (npc < 0 || npc >= gs_npc_count(game)) { sprintf(buffer, "%ld ", npc); if_print_debug(buffer); if_print_debug("[Out of range]"); return; } vt_key[0].string = "NPCs"; vt_key[1].integer = npc; vt_key[2].string = "Prefix"; prefix = prop_get_string(bundle, "S<-sis", vt_key); vt_key[2].string = "Name"; name = prop_get_string(bundle, "S<-sis", vt_key); sprintf(buffer, "%ld ", npc); if_print_debug(buffer); debug_print_quoted(prefix); if_print_debug_character(' '); debug_print_quoted(name); } static void debug_print_event(sc_gameref_t game, sc_int event) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[3]; sc_char buffer[32]; const sc_char *name; if_print_debug("Event "); if (event < 0 || event >= gs_event_count(game)) { sprintf(buffer, "%ld ", event); if_print_debug(buffer); if_print_debug("[Out of range]"); return; } vt_key[0].string = "Events"; vt_key[1].integer = event; vt_key[2].string = "Short"; name = prop_get_string(bundle, "S<-sis", vt_key); sprintf(buffer, "%ld ", event); if_print_debug(buffer); debug_print_quoted(name); } static void debug_print_task(sc_gameref_t game, sc_int task) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_vartype_t vt_key[4]; sc_char buffer[32]; const sc_char *command; if_print_debug("Task "); if (task < 0 || task >= gs_task_count(game)) { sprintf(buffer, "%ld ", task); if_print_debug(buffer); if_print_debug("[Out of range]"); return; } vt_key[0].string = "Tasks"; vt_key[1].integer = task; vt_key[2].string = "Command"; vt_key[3].integer = 0; command = prop_get_string(bundle, "S<-sisi", vt_key); sprintf(buffer, "%ld ", task); if_print_debug(buffer); debug_print_quoted(command); } static void debug_print_variable(sc_gameref_t game, sc_int variable) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[3], vt_rvalue; sc_char buffer[32]; sc_int var_type; const sc_char *name; if (variable < 0 || variable >= debug_variable_count(game)) { if_print_debug("Variable "); sprintf(buffer, "%ld ", variable); if_print_debug(buffer); if_print_debug("[Out of range]"); return; } vt_key[0].string = "Variables"; vt_key[1].integer = variable; vt_key[2].string = "Name"; name = prop_get_string(bundle, "S<-sis", vt_key); if (var_get(vars, name, &var_type, &vt_rvalue)) { switch (var_type) { case VAR_INTEGER: if_print_debug("Integer "); break; case VAR_STRING: if_print_debug("String "); break; default: if_print_debug("[Invalid type] "); break; } } else if_print_debug("[Invalid variable] "); sprintf(buffer, "%ld ", variable); if_print_debug(buffer); debug_print_quoted(name); } /* * debug_game() * * Display overall game details. */ static void debug_game(sc_gameref_t game, sc_command_type_t type) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_debuggerref_t debug = debug_get_debugger(game); sc_vartype_t vt_key[2]; const sc_char *version, *gamename, *compiledate, *gameauthor; sc_int perspective, waitturns; sc_bool has_sound, has_graphics, has_battle; sc_char buffer[32]; assert(debug_is_valid(debug)); if (type != COMMAND_QUERY) { if_print_debug("The Game command takes no arguments.\n"); return; } if_print_debug("Game "); vt_key[0].string = "Globals"; vt_key[1].string = "GameName"; gamename = prop_get_string(bundle, "S<-ss", vt_key); debug_print_quoted(gamename); if_print_debug_character('\n'); if_print_debug(" Compiled "); vt_key[0].string = "CompileDate"; compiledate = prop_get_string(bundle, "S<-s", vt_key); debug_print_quoted(compiledate); if_print_debug(", Author "); vt_key[0].string = "Globals"; vt_key[1].string = "GameAuthor"; gameauthor = prop_get_string(bundle, "S<-ss", vt_key); debug_print_quoted(gameauthor); if_print_debug_character('\n'); vt_key[0].string = "VersionString"; version = prop_get_string(bundle, "S<-s", vt_key); if_print_debug(" Version "); if_print_debug(version); vt_key[0].string = "Globals"; vt_key[1].string = "Perspective"; perspective = prop_get_integer(bundle, "I<-ss", vt_key); switch (perspective) { case 0: if_print_debug(", First person"); break; case 1: if_print_debug(", Second person"); break; case 2: if_print_debug(", Third person"); break; default: if_print_debug(", [Unknown perspective]"); break; } vt_key[0].string = "Globals"; vt_key[1].string = "WaitTurns"; waitturns = prop_get_integer(bundle, "I<-ss", vt_key); if_print_debug(", Waitturns "); sprintf(buffer, "%ld", waitturns); if_print_debug(buffer); vt_key[0].string = "Globals"; vt_key[1].string = "Sound"; has_sound = prop_get_boolean(bundle, "B<-ss", vt_key); vt_key[1].string = "Graphics"; has_graphics = prop_get_boolean(bundle, "B<-ss", vt_key); if (has_sound) if_print_debug(", Sound"); if (has_graphics) if_print_debug(", Graphics"); if_print_debug_character('\n'); vt_key[0].string = "Globals"; vt_key[1].string = "BattleSystem"; has_battle = prop_get_boolean(bundle, "B<-ss", vt_key); if (has_battle) if_print_debug(" Battle system\n"); if_print_debug(" Room count "); sprintf(buffer, "%ld", gs_room_count(game)); if_print_debug(buffer); if_print_debug(", Object count "); sprintf(buffer, "%ld", gs_object_count(game)); if_print_debug(buffer); if_print_debug(", NPC count "); sprintf(buffer, "%ld", gs_npc_count(game)); if_print_debug(buffer); if_print_debug_character('\n'); if_print_debug(" Event count "); sprintf(buffer, "%ld", gs_event_count(game)); if_print_debug(buffer); if_print_debug(", Task count "); sprintf(buffer, "%ld", gs_task_count(game)); if_print_debug(buffer); if_print_debug(", Variable count "); sprintf(buffer, "%ld", debug_variable_count(game)); if_print_debug(buffer); if_print_debug_character('\n'); if (game->is_running) if_print_debug(" Running"); else if_print_debug(" Not running"); if (game->has_completed) if_print_debug(", Completed"); else if_print_debug(", Not completed"); if (game->verbose) if_print_debug(", Verbose"); else if_print_debug(", Not verbose"); if (game->bold_room_names) if_print_debug(", Bold"); else if_print_debug(", Not bold"); if (game->undo_available) if_print_debug(", Undo"); else if_print_debug(", No undo"); if_print_debug_character('\n'); if_print_debug(" Score "); sprintf(buffer, "%ld", game->score); if_print_debug(buffer); if_print_debug(", Turns "); sprintf(buffer, "%ld", game->turns); if_print_debug(buffer); if_print_debug(", Seconds "); sprintf(buffer, "%lu", debug->elapsed_seconds); if_print_debug(buffer); if_print_debug_character('\n'); } /* * debug_player() * * Print a few brief details about the player status. */ static void debug_player(sc_gameref_t game, sc_command_t command, sc_command_type_t type) { if (type != COMMAND_QUERY) { if_print_debug("The Player command takes no arguments.\n"); return; } if (command == DEBUG_OLDPLAYER) { if (!game->undo_available) { if_print_debug("There is no previous game state to examine.\n"); return; } game = game->undo; assert(gs_is_game_valid(game)); } debug_print_player(game); if_print_debug_character('\n'); if (gs_playerroom(game) == -1) if_print_debug(" Hidden!\n"); else { if_print_debug(" In "); debug_print_room(game, gs_playerroom(game)); if_print_debug_character('\n'); } switch (gs_playerposition(game)) { case 0: if_print_debug(" Standing\n"); break; case 1: if_print_debug(" Sitting\n"); break; case 2: if_print_debug(" Lying\n"); break; default: if_print_debug(" [Invalid position]\n"); break; } if (gs_playerparent(game) != -1) { if_print_debug(" Parent is "); debug_print_object(game, gs_playerparent(game)); if_print_debug_character('\n'); } } /* * debug_normalize_arguments() * * Normalize a set of arguments parsed from a debugger command line, for * debug commands that take ranges. */ static sc_bool debug_normalize_arguments(sc_command_type_t type, sc_int *arg1, sc_int *arg2, sc_int limit) { sc_int low = 0, high = 0; /* Set range low and high depending on the command type. */ switch (type) { case COMMAND_QUERY: case COMMAND_ALL: low = 0; high = limit - 1; break; case COMMAND_ONE: low = *arg1; high = *arg1; break; case COMMAND_RANGE: low = *arg1; high = *arg2; break; default: sc_fatal("debug_normalize_arguments: bad command type\n"); } /* If range is valid, copy out and return TRUE. */ if (low >= 0 && low < limit && high >= 0 && high < limit && high >= low) { *arg1 = low; *arg2 = high; return TRUE; } /* Input range is invalid. */ return FALSE; } /* * debug_filter_room() * debug_dump_room() * * Print details of rooms and their direct contents. */ static sc_bool debug_filter_room(sc_gameref_t game, sc_int room) { return room == gs_playerroom(game); } static void debug_dump_room(sc_gameref_t game, sc_int room) { sc_int object, npc; debug_print_room(game, room); if_print_debug_character('\n'); if (gs_room_seen(game, room)) if_print_debug(" Visited\n"); else if_print_debug(" Not visited\n"); if (gs_playerroom(game) == room) { if_print_debug(" "); debug_print_player(game); if_print_debug_character('\n'); } for (object = 0; object < gs_object_count(game); object++) { if (obj_indirectly_in_room(game, object, room)) { if_print_debug(" "); debug_print_object(game, object); if_print_debug_character('\n'); } } for (npc = 0; npc < gs_npc_count(game); npc++) { if (npc_in_room(game, npc, room)) { if_print_debug(" "); debug_print_npc(game, npc); if_print_debug_character('\n'); } } } /* * debug_filter_object() * debug_dump_object() * * Print the changeable details of game objects. */ static sc_bool debug_filter_object(sc_gameref_t game, sc_int object) { return obj_indirectly_in_room(game, object, gs_playerroom(game)); } static void debug_dump_object(sc_gameref_t game, sc_int object) { const sc_prop_setref_t bundle = gs_get_bundle(game); sc_int openness; sc_vartype_t vt_key[3]; sc_bool bstatic, is_statussed; sc_int position, parent; debug_print_object(game, object); if_print_debug_character('\n'); vt_key[0].string = "Objects"; vt_key[1].integer = object; vt_key[2].string = "Static"; bstatic = prop_get_boolean(bundle, "B<-sis", vt_key); if (gs_object_seen(game, object)) if_print_debug(" Seen"); else if_print_debug(" Not seen"); if (bstatic) { if (gs_object_static_unmoved(game, object)) if_print_debug(", Not relocated"); else if_print_debug(", Relocated"); } else { vt_key[2].string = "OnlyWhenNotMoved"; if (prop_get_integer(bundle, "I<-sis", vt_key) == 1) { if (gs_object_unmoved(game, object)) if_print_debug(", Not moved"); else if_print_debug(", Moved"); } } openness = gs_object_openness(game, object); switch (openness) { case OBJ_OPEN: if_print_debug(", Open"); break; case OBJ_CLOSED: if_print_debug(", Closed"); break; case OBJ_LOCKED: if_print_debug(", Locked"); break; default: if_print_debug(", Unknown openness"); break; } if_print_debug_character('\n'); position = gs_object_position(game, object); parent = gs_object_parent(game, object); switch (position) { case OBJ_HIDDEN: if (bstatic) if_print_debug(" Static default\n"); else if_print_debug(" Hidden\n"); break; case OBJ_HELD_PLAYER: if_print_debug(" Held by "); debug_print_player(game); if_print_debug_character('\n'); break; case OBJ_HELD_NPC: if_print_debug(" Held by "); debug_print_npc(game, parent); if_print_debug_character('\n'); break; case OBJ_WORN_PLAYER: if_print_debug(" Worn by "); debug_print_player(game); if_print_debug_character('\n'); break; case OBJ_WORN_NPC: if_print_debug(" Worn by "); debug_print_npc(game, parent); if_print_debug_character('\n'); break; case OBJ_PART_NPC: if_print_debug(" Part of "); if (parent == -1) debug_print_player(game); else debug_print_npc(game, parent); if_print_debug_character('\n'); break; case OBJ_ON_OBJECT: if_print_debug(" On "); debug_print_object(game, parent); if_print_debug_character('\n'); break; case OBJ_IN_OBJECT: if_print_debug(" Inside "); debug_print_object(game, parent); if_print_debug_character('\n'); break; default: if_print_debug(" In "); debug_print_room(game, position - 1); if_print_debug_character('\n'); break; } vt_key[0].string = "Objects"; vt_key[1].integer = object; vt_key[2].string = "CurrentState"; is_statussed = prop_get_integer(bundle, "I<-sis", vt_key) != 0; if (is_statussed) { sc_char buffer[32]; const sc_char *states; if_print_debug(" State "); sprintf(buffer, "%ld", gs_object_state(game, object)); if_print_debug(buffer); vt_key[2].string = "States"; states = prop_get_string(bundle, "S<-sis", vt_key); if_print_debug(" of "); debug_print_quoted(states); if_print_debug_character('\n'); } } /* * debug_filter_npc() * debug_dump_npc() * * Print stuff about NPCs. */ static sc_bool debug_filter_npc(sc_gameref_t game, sc_int npc) { return npc_in_room(game, npc, gs_playerroom(game)); } static void debug_dump_npc(sc_gameref_t game, sc_int npc) { debug_print_npc(game, npc); if_print_debug_character('\n'); if (gs_npc_seen(game, npc)) if_print_debug(" Seen\n"); else if_print_debug(" Not seen\n"); if (gs_npc_location(game, npc) - 1 == -1) if_print_debug(" Hidden\n"); else { if_print_debug(" In "); debug_print_room(game, gs_npc_location(game, npc) - 1); if_print_debug_character('\n'); } switch (gs_npc_position(game, npc)) { case 0: if_print_debug(" Standing\n"); break; case 1: if_print_debug(" Sitting\n"); break; case 2: if_print_debug(" Lying\n"); break; default: if_print_debug(" [Invalid position]\n"); break; } if (gs_npc_parent(game, npc) != -1) { if_print_debug(" Parent is "); debug_print_object(game, gs_npc_parent(game, npc)); if_print_debug_character('\n'); } if (gs_npc_walkstep_count(game, npc) > 0) { sc_char buffer[32]; sc_int walk; if_print_debug(" Walkstep count "); sprintf(buffer, "%ld", gs_npc_walkstep_count(game, npc)); if_print_debug(buffer); if_print_debug(", Walks { "); for (walk = 0; walk < gs_npc_walkstep_count(game, npc); walk++) { sprintf(buffer, "%ld", gs_npc_walkstep(game, npc, walk)); if_print_debug(buffer); if_print_debug_character(' '); } if_print_debug("}.\n"); } } /* * debug_filter_event() * debug_dump_event() * * Print stuff about events. */ static sc_bool debug_filter_event(sc_gameref_t game, sc_int event) { return gs_event_state(game, event) == ES_RUNNING; } static void debug_dump_event(sc_gameref_t game, sc_int event) { sc_char buffer[32]; debug_print_event(game, event); if_print_debug_character('\n'); switch (gs_event_state(game, event)) { case ES_WAITING: if_print_debug(" Waiting\n"); break; case ES_RUNNING: if_print_debug(" Running\n"); break; case ES_AWAITING: if_print_debug(" Awaiting\n"); break; case ES_FINISHED: if_print_debug(" Finished\n"); break; case ES_PAUSED: if_print_debug(" Paused\n"); break; default: if_print_debug(" [Invalid state]\n"); break; } if_print_debug(" Time "); sprintf(buffer, "%ld\n", gs_event_time(game, event)); if_print_debug(buffer); } /* * debug_filter_task() * debug_dump_task() * * Print stuff about tasks. */ static sc_bool debug_filter_task(sc_gameref_t game, sc_int task) { return task_can_run_task(game, task); } static void debug_dump_task(sc_gameref_t game, sc_int task) { debug_print_task(game, task); if_print_debug_character('\n'); if (task_can_run_task(game, task)) if_print_debug(" Runnable"); else if_print_debug(" Not runnable"); if (gs_task_done(game, task)) if_print_debug(", Done"); else if_print_debug(", Not done"); if (gs_task_scored(game, task)) if_print_debug(", Scored\n"); else if_print_debug(", Not scored\n"); } /* * debug_dump_variable() * * Print stuff about variables. */ static void debug_dump_variable(sc_gameref_t game, sc_int variable) { const sc_prop_setref_t bundle = gs_get_bundle(game); const sc_var_setref_t vars = gs_get_vars(game); sc_vartype_t vt_key[3], vt_rvalue; const sc_char *name; sc_int var_type; debug_print_variable(game, variable); if_print_debug_character('\n'); vt_key[0].string = "Variables"; vt_key[1].integer = variable; vt_key[2].string = "Name"; name = prop_get_string(bundle, "S<-sis", vt_key); if_print_debug(" Value = "); if (var_get(vars, name, &var_type, &vt_rvalue)) { switch (var_type) { case VAR_INTEGER: { sc_char buffer[32]; sprintf(buffer, "%ld", vt_rvalue.integer); if_print_debug(buffer); break; } case VAR_STRING: debug_print_quoted(vt_rvalue.string); break; default: if_print_debug("[Unknown]"); break; } } else if_print_debug("[Unknown]"); if_print_debug_character('\n'); } /* * debug_dump_common() * * Common handler for iterating dumps of classes. */ static void debug_dump_common(sc_gameref_t game, sc_command_t command, sc_command_type_t type, sc_int arg1, sc_int arg2) { sc_int low = arg1, high = arg2; sc_int limit, index_; const sc_char *class_; sc_bool(*filter_function)(sc_gameref_t, sc_int); void (*dumper_function)(sc_gameref_t, sc_int); sc_bool printed = FALSE; /* Initialize variables to avoid gcc warnings. */ limit = 0; class_ = NULL; filter_function = NULL; dumper_function = NULL; /* Switch to undo game on relevant commands. */ switch (command) { case DEBUG_OLDROOMS: case DEBUG_OLDOBJECTS: case DEBUG_OLDNPCS: case DEBUG_OLDEVENTS: case DEBUG_OLDTASKS: case DEBUG_OLDVARIABLES: if (!game->undo_available) { if_print_debug("There is no previous game state to examine.\n"); return; } game = game->undo; assert(gs_is_game_valid(game)); break; default: break; } /* Demultiplex dump command. */ switch (command) { case DEBUG_ROOMS: case DEBUG_OLDROOMS: class_ = "Room"; filter_function = debug_filter_room; dumper_function = debug_dump_room; limit = gs_room_count(game); break; case DEBUG_OBJECTS: case DEBUG_OLDOBJECTS: class_ = "Object"; filter_function = debug_filter_object; dumper_function = debug_dump_object; limit = gs_object_count(game); break; case DEBUG_NPCS: case DEBUG_OLDNPCS: class_ = "NPC"; filter_function = debug_filter_npc; dumper_function = debug_dump_npc; limit = gs_npc_count(game); break; case DEBUG_EVENTS: case DEBUG_OLDEVENTS: class_ = "Event"; filter_function = debug_filter_event; dumper_function = debug_dump_event; limit = gs_event_count(game); break; case DEBUG_TASKS: case DEBUG_OLDTASKS: class_ = "Task"; filter_function = debug_filter_task; dumper_function = debug_dump_task; limit = gs_task_count(game); break; case DEBUG_VARIABLES: case DEBUG_OLDVARIABLES: class_ = "Variable"; filter_function = NULL; dumper_function = debug_dump_variable; limit = debug_variable_count(game); break; default: sc_fatal("debug_dump_common: invalid command\n"); } /* Normalize to this limit. */ if (!debug_normalize_arguments(type, &low, &high, limit)) { if (limit == 0) { if_print_debug("There is nothing of type "); debug_print_quoted(class_); if_print_debug(" to print.\n"); } else { if_print_debug("Invalid item or range for "); debug_print_quoted(class_); if (limit == 1) if_print_debug("; only 0 is valid.\n"); else { sc_char buffer[32]; if_print_debug("; valid values are 0 to "); sprintf(buffer, "%ld", limit - 1); if_print_debug(buffer); if_print_debug(".\n"); } } return; } /* Print each item of the class, filtering on query commands. */ for (index_ = low; index_ <= high; index_++) { if (type == COMMAND_QUERY && filter_function && !filter_function(game, index_)) continue; if (printed) if_print_debug_character('\n'); dumper_function(game, index_); printed = TRUE; } if (!printed) { if_print_debug("Nothing of type "); debug_print_quoted(class_); if_print_debug(" is relevant.\nTry \""); if_print_debug(class_); if_print_debug(" *\" to show all items of this type.\n"); } } /* * debug_buffer() * * Print the current raw printfilter contents. */ static void debug_buffer(sc_gameref_t game, sc_command_type_t type) { const sc_filterref_t filter = gs_get_filter(game); const sc_char *buffer; if (type != COMMAND_QUERY) { if_print_debug("The Buffer command takes no arguments.\n"); return; } buffer = pf_get_buffer(filter); if (buffer) if_print_debug(buffer); else if_print_debug("There is no game text buffered.\n"); } /* * debug_print_resource() * * Helper for debug_resources(). */ static void debug_print_resource(const sc_resource_t *resource) { sc_char buffer[32]; debug_print_quoted(resource->name); if_print_debug(", offset "); sprintf(buffer, "%ld", resource->offset); if_print_debug(buffer); if_print_debug(", length "); sprintf(buffer, "%ld", resource->length); if_print_debug(buffer); } /* * debug_resources() * * Print any active and requested resources. */ static void debug_resources(sc_gameref_t game, sc_command_type_t type) { sc_bool printed = FALSE; if (type != COMMAND_QUERY) { if_print_debug("The Resources command takes no arguments.\n"); return; } if (game->stop_sound) { if_print_debug("Sound stop"); if (strlen(game->requested_sound.name) > 0) if_print_debug(" before new sound"); if_print_debug(" requested"); if (game->sound_active) if_print_debug(", sound active"); if_print_debug(".\n"); printed = TRUE; } if (!res_compare_resource(&game->requested_sound, &game->playing_sound)) { if_print_debug("Requested Sound "); debug_print_resource(&game->requested_sound); if_print_debug(".\n"); printed = TRUE; } if (!res_compare_resource(&game->requested_graphic, &game->displayed_graphic)) { if_print_debug("Requested Graphic "); debug_print_resource(&game->requested_graphic); if_print_debug(".\n"); printed = TRUE; } if (strlen(game->playing_sound.name) > 0) { if_print_debug("Playing Sound "); debug_print_resource(&game->playing_sound); if_print_debug(".\n"); printed = TRUE; } if (strlen(game->displayed_graphic.name) > 0) { if_print_debug("Displaying Graphic "); debug_print_resource(&game->displayed_graphic); if_print_debug(".\n"); printed = TRUE; } if (!printed) if_print_debug("There is no game resource activity.\n"); } /* * debug_random() * * Report the PRNG in use, and seed the random number generator to the * given value. */ static void debug_random(sc_command_type_t type, sc_int new_seed) { const sc_char *random_type; sc_char buffer[32]; if (type != COMMAND_ONE && type != COMMAND_QUERY) { if_print_debug("The Random command takes either one argument or" " no arguments.\n"); return; } random_type = sc_is_congruential_random() ? "congruential" : "platform"; if (type == COMMAND_QUERY) { if_print_debug("The "); if_print_debug(random_type); if_print_debug(" random number generator is selected.\n"); return; } if (new_seed == 0) { if_print_debug("The seed value may not be zero.\n"); return; } sc_seed_random(new_seed); if_print_debug("Set seed "); sprintf(buffer, "%ld", new_seed); if_print_debug(buffer); if_print_debug(" for the "); if_print_debug(random_type); if_print_debug(" random number generator.\n"); } /* * debug_watchpoint_common() * * Common handler for setting and clearing watchpoints. */ static void debug_watchpoint_common(sc_gameref_t game, sc_command_t command, sc_command_type_t type, sc_int arg1, sc_int arg2) { const sc_debuggerref_t debug = debug_get_debugger(game); sc_int low = arg1, high = arg2; sc_int limit, index_; const sc_char *class_; sc_bool *watchpoints, action; sc_char buffer[32]; assert(debug_is_valid(debug)); /* Initialize variables to avoid gcc warnings. */ limit = 0; class_ = NULL; watchpoints = NULL; action = FALSE; /* Set action to TRUE or FALSE, for setting/clearing watchpoints. */ switch (command) { case DEBUG_WATCHPLAYER: case DEBUG_WATCHOBJECTS: case DEBUG_WATCHNPCS: case DEBUG_WATCHEVENTS: case DEBUG_WATCHTASKS: case DEBUG_WATCHVARIABLES: action = TRUE; break; case DEBUG_CLEARPLAYER: case DEBUG_CLEAROBJECTS: case DEBUG_CLEARNPCS: case DEBUG_CLEAREVENTS: case DEBUG_CLEARTASKS: case DEBUG_CLEARVARIABLES: action = FALSE; break; default: sc_fatal("debug_watchpoint_common: invalid command\n"); } /* Handle player watchpoint setting. */ if (command == DEBUG_WATCHPLAYER || command == DEBUG_CLEARPLAYER) { if (command == DEBUG_CLEARPLAYER) { debug->watch_player = action; if_print_debug("Cleared Player watchpoint.\n"); } else if (type == COMMAND_ONE && arg1 == 0) { debug->watch_player = action; if_print_debug("Set Player watchpoint.\n"); } else { if (debug->watch_player) if_print_debug("Player watchpoint is set.\n"); else if_print_debug("No Player watchpoint is set; to set one, use" " \"Watchplayer 0\".\n"); } return; } /* Demultiplex watchpoint command. */ switch (command) { case DEBUG_WATCHOBJECTS: case DEBUG_CLEAROBJECTS: class_ = "Object"; watchpoints = debug->watch_objects; limit = gs_object_count(game); break; case DEBUG_WATCHNPCS: case DEBUG_CLEARNPCS: class_ = "NPC"; watchpoints = debug->watch_npcs; limit = gs_npc_count(game); break; case DEBUG_WATCHEVENTS: case DEBUG_CLEAREVENTS: class_ = "Event"; watchpoints = debug->watch_events; limit = gs_event_count(game); break; case DEBUG_WATCHTASKS: case DEBUG_CLEARTASKS: class_ = "Task"; watchpoints = debug->watch_tasks; limit = gs_task_count(game); break; case DEBUG_WATCHVARIABLES: case DEBUG_CLEARVARIABLES: class_ = "Variable"; watchpoints = debug->watch_variables; limit = debug_variable_count(game); break; default: sc_fatal("debug_watchpoint_common: invalid command\n"); } /* Normalize to this limit. */ if (!debug_normalize_arguments(type, &low, &high, limit)) { if (limit == 0) { if_print_debug("There is nothing of type "); debug_print_quoted(class_); if_print_debug(" to watch.\n"); } else { if_print_debug("Invalid item or range for "); debug_print_quoted(class_); if (limit == 1) if_print_debug("; only 0 is valid.\n"); else { if_print_debug("; valid values are 0 to "); sprintf(buffer, "%ld", limit - 1); if_print_debug(buffer); if_print_debug(".\n"); } } return; } /* On query, search the array for set flags, and print out. */ if (type == COMMAND_QUERY) { sc_bool printed = FALSE; /* Scan for set watchpoints, and list each found. */ for (index_ = low; index_ <= high; index_++) { if (watchpoints[index_]) { if (!printed) { if_print_debug("Watchpoints are set for "); if_print_debug(class_); if_print_debug(" { "); } sprintf(buffer, "%ld", index_); if_print_debug(buffer); if_print_debug_character(' '); printed = TRUE; } } if (printed) if_print_debug("}.\n"); else { if_print_debug("No "); if_print_debug(class_); if_print_debug(" watchpoints are set.\n"); } return; } /* * For non-queries, set watchpoint flags as defined in action for * the range determined, and print confirmation. */ for (index_ = low; index_ <= high; index_++) watchpoints[index_] = action; if (action) if_print_debug("Set "); else if_print_debug("Cleared "); sprintf(buffer, "%ld ", high - low + 1); if_print_debug(buffer); if_print_debug(class_); if (high == low) if_print_debug(" watchpoint.\n"); else if_print_debug(" watchpoints.\n"); } /* * debug_watchall_common() * * Common handler to list out and clear all set watchpoints at a stroke. */ static void debug_watchall_common(sc_gameref_t game, sc_command_t command, sc_command_type_t type) { const sc_debuggerref_t debug = debug_get_debugger(game); assert(debug_is_valid(debug)); if (type != COMMAND_QUERY) { if (command == DEBUG_WATCHALL) if_print_debug("The Watchall command takes no arguments.\n"); else if_print_debug("The Clearall command takes no arguments.\n"); return; } /* Query all set watchpoints using common watchpoint handler... */ if (command == DEBUG_WATCHALL) { debug_watchpoint_common(game, DEBUG_WATCHPLAYER, COMMAND_QUERY, 0, 0); debug_watchpoint_common(game, DEBUG_WATCHOBJECTS, COMMAND_QUERY, 0, 0); debug_watchpoint_common(game, DEBUG_WATCHNPCS, COMMAND_QUERY, 0, 0); debug_watchpoint_common(game, DEBUG_WATCHEVENTS, COMMAND_QUERY, 0, 0); debug_watchpoint_common(game, DEBUG_WATCHTASKS, COMMAND_QUERY, 0, 0); debug_watchpoint_common(game, DEBUG_WATCHVARIABLES, COMMAND_QUERY, 0, 0); return; } /* ...but reset all the fast way, with memset(). */ assert(command == DEBUG_CLEARALL); debug->watch_player = FALSE; memset(debug->watch_objects, FALSE, gs_object_count(game) * sizeof(*debug->watch_objects)); memset(debug->watch_npcs, FALSE, gs_npc_count(game) * sizeof(*debug->watch_npcs)); memset(debug->watch_events, FALSE, gs_event_count(game) * sizeof(*debug->watch_events)); memset(debug->watch_tasks, FALSE, gs_task_count(game) * sizeof(*debug->watch_tasks)); memset(debug->watch_variables, FALSE, debug_variable_count(game) * sizeof(*debug->watch_variables)); if_print_debug("Cleared all watchpoints.\n"); } /* * debug_compare_object() * * Compare two objects, and return TRUE if the same. */ static sc_bool debug_compare_object(sc_gameref_t from, sc_gameref_t with, sc_int object) { const sc_objectstate_t *from_object = from->objects + object; const sc_objectstate_t *with_object = with->objects + object; return from_object->unmoved == with_object->unmoved && from_object->static_unmoved == with_object->static_unmoved && from_object->position == with_object->position && from_object->parent == with_object->parent && from_object->openness == with_object->openness && from_object->state == with_object->state && from_object->seen == with_object->seen; } /* * debug_compare_npc() * * Compare two NPCs, and return TRUE if the same. */ static sc_bool debug_compare_npc(sc_gameref_t from, sc_gameref_t with, sc_int npc) { const sc_npcstate_t *from_npc = from->npcs + npc; const sc_npcstate_t *with_npc = with->npcs + npc; if (from_npc->walkstep_count != with_npc->walkstep_count) sc_fatal("debug_compare_npc: walkstep count error\n"); return from_npc->location == with_npc->location && from_npc->position == with_npc->position && from_npc->parent == with_npc->parent && from_npc->seen == with_npc->seen && memcmp(from_npc->walksteps, with_npc->walksteps, from_npc->walkstep_count * sizeof(*from_npc->walksteps)) == 0; } /* * debug_compare_event() * * Compare two events, and return TRUE if the same. */ static sc_bool debug_compare_event(sc_gameref_t from, sc_gameref_t with, sc_int event) { const sc_eventstate_t *from_event = from->events + event; const sc_eventstate_t *with_event = with->events + event; return from_event->state == with_event->state && from_event->time == with_event->time; } /* * debug_compare_task() * * Compare two tasks, and return TRUE if the same. */ static sc_bool debug_compare_task(sc_gameref_t from, sc_gameref_t with, sc_int task) { const sc_taskstate_t *from_task = from->tasks + task; const sc_taskstate_t *with_task = with->tasks + task; return from_task->done == with_task->done && from_task->scored == with_task->scored; } /* * debug_compare_variable() * * Compare two variables, and return TRUE if the same. */ static sc_bool debug_compare_variable(sc_gameref_t from, sc_gameref_t with, sc_int variable) { const sc_prop_setref_t bundle = from->bundle; const sc_var_setref_t from_var = from->vars; const sc_var_setref_t with_var = with->vars; sc_vartype_t vt_key[3], vt_rvalue, vt_rvalue2; const sc_char *name; sc_int var_type, var_type2; sc_bool equal = FALSE; vt_rvalue.voidp = vt_rvalue2.voidp = nullptr; if (from->bundle != with->bundle) sc_fatal("debug_compare_variable: property sharing malfunction\n"); vt_key[0].string = "Variables"; vt_key[1].integer = variable; vt_key[2].string = "Name"; name = prop_get_string(bundle, "S<-sis", vt_key); if (!var_get(from_var, name, &var_type, &vt_rvalue) || !var_get(with_var, name, &var_type2, &vt_rvalue2)) sc_fatal("debug_compare_variable: can't find variable %s\n", name); else if (var_type != var_type2) sc_fatal("debug_compare_variable: variable type mismatch %s\n", name); switch (var_type) { case VAR_INTEGER: equal = (vt_rvalue.integer == vt_rvalue2.integer); break; case VAR_STRING: equal = !strcmp(vt_rvalue.string, vt_rvalue2.string); break; default: sc_fatal("debug_compare_variable:" " invalid variable type, %ld\n", var_type); } return equal; } /* * debug_check_class() * * Central handler for checking watchpoints. Compares a number of items * of a class using the comparison function given, where indicated by a * watchpoints flags array. Prints entries that differ, and returns TRUE * if any differed. */ static sc_bool debug_check_class(sc_gameref_t from, sc_gameref_t with, const sc_char *class_, sc_int class_count, const sc_bool *watchpoints, sc_bool(*const compare_function) (sc_gameref_t, sc_gameref_t, sc_int)) { sc_int index_; sc_bool triggered = FALSE; /* * Scan the watchpoints array for set watchpoints, comparing classes * where the watchpoint flag is set. */ for (index_ = 0; index_ < class_count; index_++) { if (!watchpoints[index_]) continue; if (!compare_function(from, with, index_)) { sc_char buffer[32]; if (!triggered) { if_print_debug("--- "); if_print_debug(class_); if_print_debug(" watchpoint triggered { "); } sprintf(buffer, "%ld ", index_); if_print_debug(buffer); triggered = TRUE; } } if (triggered) if_print_debug("}.\n"); /* Return TRUE if anything differed. */ return triggered; } /* * debug_check_watchpoints() * * Checks the game against the undo game for all set watchpoints. Returns * TRUE if any triggered, FALSE if none (or if the undo game isn't available, * in which case no check is possible). */ static sc_bool debug_check_watchpoints(sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); const sc_gameref_t undo = game->undo; sc_bool triggered; assert(debug_is_valid(debug) && gs_is_game_valid(undo)); /* If no undo is present, no check is possible. */ if (!game->undo_available) return FALSE; /* Check first for player watchpoint. */ triggered = FALSE; if (debug->watch_player) { if (gs_playerroom(game) != gs_playerroom(undo) || gs_playerposition(game) != gs_playerposition(undo) || gs_playerparent(game) != gs_playerparent(undo)) { if_print_debug("--- Player watchpoint triggered.\n"); triggered |= TRUE; } } /* Now check other classes of watchpoint. */ triggered |= debug_check_class(game, undo, "Object", gs_object_count(game), debug->watch_objects, debug_compare_object); triggered |= debug_check_class(game, undo, "NPC", gs_npc_count(game), debug->watch_npcs, debug_compare_npc); triggered |= debug_check_class(game, undo, "Event", gs_event_count(game), debug->watch_events, debug_compare_event); triggered |= debug_check_class(game, undo, "Task", gs_task_count(game), debug->watch_tasks, debug_compare_task); triggered |= debug_check_class(game, undo, "Variable", debug_variable_count(game), debug->watch_variables, debug_compare_variable); return triggered; } /* * debug_parse_command() * * Given a debugging command string, try to parse it and return the * appropriate command and its arguments. Returns DEBUG_NONE if the parse * fails. */ static sc_command_t debug_parse_command(const sc_char *command_string, sc_command_type_t *type, sc_int *arg1, sc_int *arg2, sc_command_t *help_topic) { sc_command_t return_command; sc_command_type_t return_type; sc_int val1, val2, converted, matches; sc_char *help, *string, junk, wildcard; sc_bool is_help, is_parsed, is_wildcard; const sc_strings_t *entry; /* Allocate temporary strings long enough to take a copy of the input. */ string = (sc_char *)sc_malloc(strlen(command_string) + 1); help = (sc_char *)sc_malloc(strlen(command_string) + 1); /* * Parse the input line, in a very simplistic fashion. The argument count * is one less than sscanf converts. */ is_parsed = is_wildcard = is_help = FALSE; val1 = val2 = 0; converted = sscanf(command_string, " %s %s %c", help, string, &junk); if (converted == 2 && sc_strcasecmp(help, "help") == 0) { is_help = TRUE; is_parsed = TRUE; } sc_free(help); if (!is_parsed) { converted = sscanf(command_string, " %s %ld to %ld %c", string, &val1, &val2, &junk); if (converted != 3) converted = sscanf(command_string, " %s %ld - %ld %c", string, &val1, &val2, &junk); if (converted != 3) converted = sscanf(command_string, " %s %ld .. %ld %c", string, &val1, &val2, &junk); if (converted != 3) converted = sscanf(command_string, " %s %ld %ld %c", string, &val1, &val2, &junk); is_parsed |= converted == 3; } if (!is_parsed) { converted = sscanf(command_string, " %s %ld %c", string, &val1, &junk); is_parsed |= converted == 2; } if (!is_parsed) { converted = sscanf(command_string, " %s %c %c", string, &wildcard, &junk); if (converted == 2 && wildcard == '*') { is_wildcard = TRUE; is_parsed = TRUE; } else is_parsed |= converted == 1; } if (!is_parsed) { if_print_debug("Invalid debug command."); if_print_debug(" Type 'help' for a list of valid commands.\n"); sc_free(string); return DEBUG_NONE; } /* Decide on a command type based on the parse. */ if (is_wildcard) return_type = COMMAND_ALL; else if (converted == 3) return_type = COMMAND_RANGE; else if (converted == 2) return_type = COMMAND_ONE; else return_type = COMMAND_QUERY; /* * Find the first unambiguous command matching the string. If none, * return DEBUG_NONE. */ matches = 0; return_command = DEBUG_NONE; for (entry = DEBUG_COMMANDS; entry->command_string; entry++) { if (sc_strncasecmp(string, entry->command_string, strlen(string)) == 0) { matches++; return_command = entry->command; } } if (matches != 1) { if (matches > 1) if_print_debug("Ambiguous debug command."); else if_print_debug("Unrecognized debug command."); if_print_debug(" Type 'help' for a list of valid commands.\n"); sc_free(string); return DEBUG_NONE; } /* Done with temporary command parse area. */ sc_free(string); /* * Return the command type, arguments, and the debugging command. For help * , the command is help, with the command on which help requested * in *help_topic. All clear, then? */ *type = return_type; *arg1 = val1; *arg2 = val2; *help_topic = is_help ? return_command : DEBUG_NONE; return is_help ? DEBUG_HELP : return_command; } /* * debug_dispatch() * * Dispatch a debugging command to the appropriate handler. */ static void debug_dispatch(sc_gameref_t game, sc_command_t command, sc_command_type_t type, sc_int arg1, sc_int arg2, sc_command_t help_topic) { /* Demultiplex debugging command, and call handlers. */ switch (command) { case DEBUG_HELP: debug_help(help_topic); break; case DEBUG_BUFFER: debug_buffer(game, type); break; case DEBUG_RESOURCES: debug_resources(game, type); break; case DEBUG_RANDOM: debug_random(type, arg1); break; case DEBUG_GAME: debug_game(game, type); break; case DEBUG_PLAYER: case DEBUG_OLDPLAYER: debug_player(game, command, type); break; case DEBUG_ROOMS: case DEBUG_OBJECTS: case DEBUG_NPCS: case DEBUG_EVENTS: case DEBUG_TASKS: case DEBUG_VARIABLES: case DEBUG_OLDROOMS: case DEBUG_OLDOBJECTS: case DEBUG_OLDNPCS: case DEBUG_OLDEVENTS: case DEBUG_OLDTASKS: case DEBUG_OLDVARIABLES: debug_dump_common(game, command, type, arg1, arg2); break; case DEBUG_WATCHPLAYER: case DEBUG_WATCHOBJECTS: case DEBUG_WATCHNPCS: case DEBUG_WATCHEVENTS: case DEBUG_WATCHTASKS: case DEBUG_WATCHVARIABLES: case DEBUG_CLEARPLAYER: case DEBUG_CLEAROBJECTS: case DEBUG_CLEARNPCS: case DEBUG_CLEAREVENTS: case DEBUG_CLEARTASKS: case DEBUG_CLEARVARIABLES: debug_watchpoint_common(game, command, type, arg1, arg2); break; case DEBUG_WATCHALL: case DEBUG_CLEARALL: debug_watchall_common(game, command, type); break; case DEBUG_NONE: break; default: sc_fatal("debug_dispatch: invalid debug command\n"); } } /* * debug_dialog() * * Create a small debugging dialog with the user. */ static void debug_dialog(CONTEXT, sc_gameref_t game) { const sc_filterref_t filter = gs_get_filter(game); const sc_debuggerref_t debug = debug_get_debugger(game); const sc_var_setref_t vars = gs_get_vars(game); assert(debug_is_valid(debug)); /* * Note elapsed seconds, so time stands still while debugging, and clear * any pending game quit left over from prior dialogs (just in case). */ debug->elapsed_seconds = var_get_elapsed_seconds(vars); debug->quit_pending = FALSE; /* Handle debug commands until debugger quit or game quit. */ while (TRUE) { sc_char buffer[DEBUG_BUFFER_SIZE]; sc_command_t command, help_topic; sc_command_type_t type; sc_int arg1, arg2; /* Get a debugging command string from the user. */ do { if_read_debug(buffer, sizeof(buffer)); if (g_vm->shouldQuit()) return; } while (sc_strempty(buffer)); /* Parse the command read, and handle dialog exit commands. */ command = debug_parse_command(buffer, &type, &arg1, &arg2, &help_topic); if (command == DEBUG_CONTINUE || command == DEBUG_STEP) { if (!game->is_running) { if_print_debug("The game is no longer running.\n"); continue; } debug->single_step = (command == DEBUG_STEP); break; } else if (command == DEBUG_QUIT) { /* * If the game is not running, we can't halt it, and we don't need * to confirm the quit (either the player "quit" or the game * completed), so leave the dialog loop. */ if (!game->is_running) break; /* * The game is still running, so confirm quit by requiring a repeat, * or if this is the confirmation, force the game to a halt. */ if (!debug->quit_pending) { if_print_debug("Use 'quit' again to confirm, or another" " debugger command to cancel.\n"); debug->quit_pending = TRUE; continue; } /* Drop printfilter contents and quit the game. */ pf_empty(filter); CALL1(run_quit, game); /* Just in case... */ if_print_debug("Unable to quit from the game. Sorry.\n"); continue; } /* Dispatch the remaining debugging commands, and clear quit flag. */ debug_dispatch(game, command, type, arg1, arg2, help_topic); debug->quit_pending = FALSE; } /* Restart time, and clear any pending game quit. */ var_set_elapsed_seconds(vars, debug->elapsed_seconds); debug->quit_pending = FALSE; } /* * debug_run_command() * * Handle a single debugging command line from the outside world. Returns * TRUE if valid, FALSE if invalid (parse failed, not understood). */ sc_bool debug_run_command(sc_gameref_t game, const sc_char *debug_command) { const sc_debuggerref_t debug = debug_get_debugger(game); sc_command_t command, help_topic; sc_command_type_t type; sc_int arg1, arg2; /* If debugging disallowed (not initialized), refuse the call. */ if (debug) { /* * Parse the command string passed in, and return FALSE if the parse * fails, or if it returns DEBUG_CONTINUE, DEBUG_STEP, or DEBUG_QUIT, * none of which make any sense in this context. */ command = debug_parse_command(debug_command, &type, &arg1, &arg2, &help_topic); if (command == DEBUG_NONE || command == DEBUG_CONTINUE || command == DEBUG_STEP || command == DEBUG_QUIT) return FALSE; /* Dispatch the remaining debugging commands, return successfully. */ debug_dispatch(game, command, type, arg1, arg2, help_topic); return TRUE; } return FALSE; } /* * debug_cmd_debugger() * * Called by the run main loop on user "debug" command request. Prints * a polite refusal if debugging is not enabled, otherwise runs a debugging * dialog. Uses if_print_string() as this isn't debug output. */ sc_bool debug_cmd_debugger(sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); Context context; /* If debugging disallowed (not initialized), ignore the call. */ if (debug) { debug_dialog(context, game); } else { if_print_string("SCARE's game debugger is not enabled. Sorry.\n"); } /* * Set as administrative command, so as not to consume a game turn, and * return successfully. */ game->is_admin = TRUE; return TRUE; } /* * debug_game_started() * debug_game_ended() * * The first is called on entry to the game main loop, and gives us a chance * to look at things before any turns are run, and to set watchpoints to * catch things in games that use catch-all command tasks on startup (The PK * Girl, for example). * * The second is called on exit from the game, and may make a final sweep for * watchpoints and offer the debug dialog one last time. */ void debug_game_started(CONTEXT, sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); /* If debugging disallowed (not initialized), ignore the call. */ if (debug) { /* Starting a new game, or a restore or undo of an old one? */ if (!gs_room_seen(game, gs_playerroom(game))) { /* * It's a new game starting or restarting. Print a banner, and * run the debugger dialog. */ if_print_debug("\n--- SCARE " SCARE_VERSION SCARE_PATCH_LEVEL " Game Debugger\n" "--- Type 'help' for a list of commands.\n"); CALL1(debug_dialog, game); } else { /* * It's a restore or undo through memos, so run the dialog only if * single-stepping; no need to check watchpoints for this case as * none can be set -- no undo. */ if (debug->single_step) { CALL1(debug_dialog, game); } } } } void debug_game_ended(CONTEXT, sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); /* If debugging disallowed (not initialized), ignore the call. */ if (debug) { /* * Using our carnal knowledge of the run main loop, we know here that * if the loop exited with do_restart or do_restore, we'll get a call to * debug_game_start() when the loop restarts. So in this case, ignore * the call (even if single stepping). */ if (game->do_restart || game->do_restore) return; /* * Check for any final watchpoints, and print a message describing why * we're here. Suppress the check for watchpoints if the user exited * the game, as it'll only be a repeat of any found last turn update. */ if (!game->is_running) { if (game->has_completed) { debug_check_watchpoints(game); if_print_debug("\n--- The game has completed.\n"); } else if_print_debug("\n--- The game has exited.\n"); } else { debug_check_watchpoints(game); if_print_debug("\n--- The game is still running!\n"); } /* Run a final dialog. */ CALL1(debug_dialog, game); } } /* * debug_turn_update() * * Called after each turn by the main game loop. Checks for any set * watchpoints, and triggers a debug dialog when any fire. */ void debug_turn_update(CONTEXT, sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); /* If debugging disallowed (not initialized), ignore the call. */ if (debug) { /* * Again using carnal knowledge of the run main loop, if we're in * mid-wait, ignore the call. Also, ignore the call if the game is * no longer running, as we'll see a debug_game_ended() call come * along to handle that. */ if (game->waitcounter > 0 || !game->is_running) return; /* * Run debugger dialog if any watchpoints triggered, or if single * stepping (even if none triggered). */ if (debug_check_watchpoints(game) || debug->single_step) { CALL1(debug_dialog, game); } } } /* * debug_set_enabled() * debug_get_enabled() * * Enable/disable debugging, and return debugging status. Debugging is * enabled when there is a debugger reference in the game, and disabled * when it's NULL -- that's the flag. To avoid lugging about all the * watchpoint memory with a game, debugger data is allocated on enabling, * and free'd on disabling; as a result, any set watchpoints are lost on * disabling. */ void debug_set_enabled(sc_gameref_t game, sc_bool enable) { const sc_debuggerref_t debug = debug_get_debugger(game); /* * If enabling and not already enabled, or disabling and not already * disabled, either initialize or finalize.. */ if ((enable && !debug) || (!enable && debug)) { /* Initialize or finalize debugging, as appropriate. */ if (enable) debug_initialize(game); else debug_finalize(game); } } sc_bool debug_get_enabled(sc_gameref_t game) { const sc_debuggerref_t debug = debug_get_debugger(game); return debug != NULL; } } // End of namespace Adrift } // End of namespace Glk