dll/debug.c

Go to the documentation of this file.

/* {{{
 * CalcRogue, a roguelike game for PCs, calculators and PDAs
 * Copyright (C) 2003 Jim Babcock
 * 
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 * }}} */
// debug.c

#include "crogue.h"
#include "dll.h"

#define NUM_DEBUGOPTS 12

#ifdef ALLOWDEBUG
#ifdef DEBUG_HEAVILY
static void do_diagnostic(void);
#endif

//{{{
const char* debugmenuopts[NUM_DEBUGOPTS] = {
    gettext("Gain level"),
    gettext("Gain attributes"),
    gettext("Heal"),
    gettext("Invulnerability"),
    gettext("Drain satiation"),
    gettext("Show free mem"),
    gettext("Reveal map"),
    gettext("Run diagnostic"),
    gettext("Show facing"),
    gettext("Throw exception"),
    gettext("Give item"),
    gettext("Spell times")
};
//}}}
//{{{
void debugmenu_pick(int N, char *buf)
{
    strcpy(buf, debugmenuopts[N]);
}
//}}}
//{{{
void debugmenu_item(int N, char *buf)
{
    item itm = {N+1, 0, 1, 0, 0, 0, 0};
    strcpy(buf, itemname(&itm));
}
//}}}

//{{{
//
// Debug menu: opens a list of debug (cheat) commands and handles the
// selection
//
void debug(void)
{
    int ii, jj;
    int choice;
    item itm = {0, 0, 1, 0, 0, 0, 0};
    
    if(!w->debug_mode)
    {
        if(!prompt(gettext("Warning: If you use debug features, you will not receive a score. Continue?")))
            return;
    }
    choice = UI_Menu_Pick(debug_rect, NUM_DEBUGOPTS, &debugmenu_pick, 0);
    
    if(choice>=0)
        w->debug_mode = 1;
    
    // Indeces correspond to debugmenuopts strings
    switch( choice )
    {
        case 0: // Gain level
            w->plr.level ++;
            w->plr.xp = 0;
            update_player();
            break;
        case 1: // Gain attributes
            for(ii=0; ii<5; ii++)
                w->plr.intrinsic[ii] += 10;
            
            update_player();
            break;
        case 2: // Heal
            w->plr.hps = w->plr.hps_max;
            break;
        case 3: // Pseudo-invulnerability
            w->plr.hps_max_mod = 2000;
            update_player();
            w->plr.hps = w->plr.hps_max;
            break;
        case 4: // Remove satiation
            w->plr.satiation -= 200;
            break;
        case 5: // Show free memory
#ifdef IS_CALCULATOR
            message(gettext("Free memory: %li"), HeapAvail());
#else
            message(gettext("Free memory: Lots."));
#endif
            break;
        case 6:
            for(jj=0; jj<MAPSIZE_Y; jj++)
            for(ii=0; ii<MAPSIZE_X; ii++) {
                w->t[jj][ii].flags |= TFLAG_EXPLORED;
                draw_tile(ii, jj);
            }
            break;
        
        case 7:
#ifdef DEBUG_HEAVILY
            do_diagnostic();
#endif
            break;
        case 8:
            message(gettext("Facing: %i, forced: %i"), w->plr.facing, w->plr.facing_forced);
            break;
        
        case 9:
#ifdef IS_CALCULATOR
            if(prompt(gettext("This will end your game. Are you sure?")))
                ER_throw(ER_MEMORY);
#else
            message(gettext("Exceptions are only used on TI calculators."));
#endif
            break;
        case 10:
            // Identify all types
            for(ii=0; ii<w->desc.itementries; ii++) {
                identify_type(ii);
            }
            itm.type = UI_Menu_Pick(debug_item_rect, w->desc.itementries - 1, debugmenu_item, 0) + 1;
            itm.stacksize = ITEMDESC(itm).stacksize;
            give_item(&itm, 1);
            break;
        case 11:
            message(gettext("Current time is %li."), (long)w->time);
            for(ii=0; ii<w->desc.numspells; ii++)
                message("%li,", (long)w->plr.spellknowledge[ii]);
    }
    
    full_redraw();
}
//}}}

#ifdef DEBUG_HEAVILY
static draw_string_info output_state = {0, 0};

//{{{
void diagnostic_print(const char *text)
{
    draw_string(text, &output_state, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 1);
}
//}}}
//{{{
void do_diagnostic(void)
{
    int xi, yi, ii, pos, total_items=0;
    int pass, failed=0;
    int monstcount = 0;
    output_state.curX = output_state.curRow = 0;
    
    clrscr();
    
#ifndef REALCOMPUTER
    diagnostic_print(gettext("Checking memory... "));
    if(HeapAvail() < 4096) {
        diagnostic_print(retprintf(gettext("Only %li bytes of RAM left! "), HeapAvail()));
        failed++;
    }
#endif
    
    diagnostic_print(gettext("\nChecking world/monster consistency... "));
    for(yi=0; yi<MAPSIZE_Y; yi++)
    for(xi=0; xi<MAPSIZE_X; xi++)
    {
        if(w->t[yi][xi].flags & TFLAG_OCCUPIED)
        {
            pass = 0;
            for(ii=0; ii<MONSTERS_MAX; ii++)
            {
                if(isNull(w->m[ii].type))
                    continue;
                if(w->m[ii].x == xi && w->m[ii].y == yi)
                {
                    monstcount++;
                    pass++;
                }
            }
            if(w->plr.x==xi && w->plr.y==yi)
                pass++;
            if(pass==0)
            {
                diagnostic_print(retprintf(gettext("Found mis-marked monster at (%i, %i)! "), xi, yi));
                failed++;
            }
            else if(pass>1)
            {
                diagnostic_print(retprintf(gettext("Found overlapping %i monsters at (%i, %i): "), pass, xi, yi));
                failed++;
                for(ii=0; ii<MONSTERS_MAX; ii++)
                {
                    if(isNull(w->m[ii].type))
                        continue;
                    if(w->m[ii].x == xi && w->m[ii].y == yi)
                        diagnostic_print(retprintf("%i, ", ii));
                }
            }
        }
    }
    
    for(ii=0; ii<MONSTERS_MAX; ii++)
    {
        if(isNull(w->m[ii].type))
            continue;
        if(w->m[ii].x<0 || w->m[ii].y<0 || w->m[ii].x>=MAPSIZE_X || w->m[ii].y>=MAPSIZE_Y)
        {
            diagnostic_print(retprintf(gettext("Found out of bounds monster at (%i, %i)! ", w->m[ii].x, w->m[ii].y));
            failed++;
            continue;
        }
        if(!(w->t[w->m[ii].y][w->m[ii].x].flags & TFLAG_OCCUPIED))
        {
            diagnostic_print(retprintf(gettext("Found monster on unmarked tile at (%i, %i)! "), w->m[ii].x, w->m[ii].y));
            failed++;
            continue;
        }
    }
    
    diagnostic_print(gettext("\nChecking item chains... "));
    for(yi=0; yi<MAPSIZE_Y; yi++)
    for(xi=0; xi<MAPSIZE_X; xi++)
    {
        if(w->t[yi][xi].flags & TFLAG_ITEM)
        {
            pos = top_item(xi, yi);
            
            if(w->items.items[pos].type > w->desc.itementries)
            {
                diagnostic_print(retprintf(gettext("Invalid item at (%i, %i) has type %i! "), xi, yi, w->items.items[pos].type) );
                failed++;
            }
            
            while(pos != 0) {
                pos = w->items.items[pos].next;
                total_items++;
            }
        }
    }
    
    if(total_items != w->items.num)
    {
        diagnostic_print(retprintf(gettext("Total number of items found does not match: expected %i, found %i. "), w->items.num, total_items));
        failed++;
    }
    diagnostic_print(retprintf(gettext("\n%i items stored, %i allocated. "), w->items.num, w->items.alloced));
    diagnostic_print(retprintf(gettext("\n%i monsters."), monstcount));
    
    diagnostic_print(retprintf(gettext("\n\nSummary: %i tests failed"),failed));
    read_char();
}
//}}}
#endif

#else

// Stub for debug() (since it's part of the exported interface, it can't be
// left out entirely)
void debug() {}

#endif

---