src/crogue.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.
 */
// crogue.c



#include "crogue.h"
#include "substdio.h"
#include "export.h"

#ifdef REGISTERVAR
world *w_non_reg; // A place to back up 'w', because it won't survive in a
                  // register variable if an exception is thrown
#else
world *w;
#endif

static void cb_main_menu_choice(int n, char *buf);
static void main_menu(void);

//{{{
void initialize(void)
{
    int loadedfromfile = 0;
    
    sys_init();
    
    // Claim memory for main data struct
#ifdef REGISTERVAR
    w_non_reg = NULL; // In case call fails, so cleanup will know
#endif
    w = (world*)debug_calloc(1, sizeof(world));
#ifdef REGISTERVAR
    w_non_reg = w;
#endif
    
    lsrand(get_entropy());
    
    // Load saved game if possible
    loadedfromfile = restore_game();
    
    
    // If not loaded from saved game, initialize things
    if(!loadedfromfile) {
        sys_init_data_file();
        init_options();
        load_options();
#       ifdef IS_CALCULATOR
        if(w->options[OPTION_GRAYSCALE] == OPTION_GRAY_ON)
            GrayOnThrow();
#       endif
        display_title_screen();
        
        init_shuffle_tab();
        
        w->messagevis=0;
        w->time=0;
#ifdef ALLOWDEBUG
        w->debug_mode = 0;
#endif
        
        init_spells();
        init_discoveries();
    }
    else
    {
        UI_TF_Init( COORD(MAPSIZE_X,MAPSIZE_Y) );
#ifdef IS_CALCULATOR
        if(w->options[OPTION_GRAYSCALE] == OPTION_GRAY_ON)
            GrayOnThrow();
#endif
    }
    
    init_layout();
    
    if(!loadedfromfile)
        main_menu();
    
    UI_MF_clear();
    enter_map();
}
//}}}
//{{{
void resize_map_store(int size_x, int size_y)
{
    tile *alloc_pos;
    int i;
    
    if(w->t && w->mapsize_x == size_x && w->mapsize_y == size_y)
        return;
    
    if(w->t) debug_free(w->t);
    w->mapsize_x = size_x;
    w->mapsize_y = size_y;
    w->t = debug_malloc( size_y*sizeof(tile*)
            + size_x*size_y*sizeof(tile) );
    alloc_pos = (tile*)((tile**)w->t + size_y);
    for(i=0; i<size_y; i++) {
        w->t[i] = alloc_pos;
        alloc_pos += size_x;
    }
    
    UI_TF_Init( COORD(size_x, size_y) );
}
//}}}

//{{{
static const char *main_menu_choices[] = {
    gettext("New game"),
    gettext("Help"),
    gettext("Tutorial"),
    gettext("High scores"),
    gettext("Options"),
    gettext("Quit")
    };
static const int num_main_menu_choices = 6;
//}}}
//{{{
static void cb_main_menu_choice(int n, char *buf)
{
    strcpy(buf, main_menu_choices[n]);
}
//}}}
//{{{
static void main_menu(void)
{
    int choice;
    
restart:
    // Generic title screen method (overlay a menu on a background image, as on calc)
    display_title_screen();
    
    do {
        choice = UI_Menu_Pick( main_menu_rect, num_main_menu_choices, &cb_main_menu_choice, 0);
    } while(choice == -1);
    
    switch(choice)
    {
        case 0: // New game
            init_player(0);
            w->current_map_link = w->desc.mainmap;
            w->current_map = (mapdesc*)deref_file_ptr(w->current_map_link);
            w->maxlevel = w->level = w->current_map->mapindex;
            gen_map(0, COORD(0,0));
            break;
        case 1: // Help
            help();
            goto restart;
        case 2: // Tutorial
            init_player(1);
            w->current_map_link = w->desc.tutorialmap;
            w->current_map = (mapdesc*)deref_file_ptr(w->current_map_link);
            w->maxlevel = w->level = w->current_map->mapindex;
            gen_map(0, COORD(0,0));
            break;
        case 3: // High scores
            display_scores(-1);
            goto restart;
        case 4: // Options
            options_menu();
            goto restart;
        case 5: // Quit
            quit();
    }
}
//}}}

//{{{
void eventloop(void)
{
    while(1)
    {
        plr_move();
        draw();
    }
}
//}}}

//{{{
void die(const char *cause_of_death)
{
    message(gettext("You die..."));
    draw();
    while(read_char() != KEY_ACKNOWLEDGE);
    
    end_game(cause_of_death);
}
//}}}
//{{{
void end_game(const char *cause_of_death)
{
    award_item_points();
    
#ifdef ALLOWDEBUG
    if(w->debug_mode)
    {
        message( gettext(
            "Since you used debug features, your game will not be scored."));
        read_char();
    } else
#endif
    {
        award_high_score(w->plr.score, cause_of_death);
        display_scores(w->plr.score);
    }
    
    cleanup_save();
    quit();
}
//}}}

//{{{
void quit(void)
{
#ifdef IS_CALCULATOR
    ER_success();
#endif
    cleanup();
    exit(0);
}
//}}}
//{{{
void cleanup(void)
{
    sys_cleanup();
    
    if(w) {
        if(w->t)                  debug_free(w->t);
        if(w->plr.spellknowledge) debug_free(w->plr.spellknowledge);
        if(w->shuffletranslation) debug_free(w->shuffletranslation);
        if(w->itemids)            debug_free(w->itemids);
        cleanup_items();
        debug_free(w);
    }
    UI_TF_Deinit();
    
    exit(0);
}
//}}}
//{{{
void timepass(ushort amt)
{
    uint partialhpsperhp;
    uint partialppsperpp;
    uint i;
    
    
    // Apply draining
    if(w->plr.extrinsic[STAT_FLAGS] & STAT_FLAG_DRAIN)
    {
        if(w->plr.pps > 0)
        {
            message(gettext("You feel the Amulet sucking your energy away."));
            w->plr.pps--;
        }
        else
        {
            message(gettext("You feel the Amulet sucking your life away."));
            plr_takedamage(1, gettext("Killed by the Amulet of Yendor"));
        }
    } else {
        // Regenerate hit points
        partialhpsperhp = 150+10*w->plr.level;
        w->plr.partialhps += (w->plr.hps_max+10) * amt;
        w->plr.hps += w->plr.partialhps / partialhpsperhp;
        w->plr.hps += w->plr.extrinsic[STAT_REGEN];
        w->plr.partialhps -= (w->plr.partialhps/partialhpsperhp)*partialhpsperhp;
        if( w->plr.hps > w->plr.hps_max )
            w->plr.hps = w->plr.hps_max;
        
        // Regenerate power points
        partialppsperpp = 155+10*w->plr.level;
        w->plr.partialpps += (w->plr.pps_max+w->plr.extrinsic[STAT_MANA]) * amt;
        w->plr.pps += w->plr.partialpps / partialppsperpp;
        w->plr.partialpps -= (w->plr.partialpps/partialppsperpp)*partialppsperpp;
        if( w->plr.pps > w->plr.pps_max )
            w->plr.pps = w->plr.pps_max;
    }
    
    // Drain torch fuel
    if(w->plr.extrinsic[STAT_FLAGS] & STAT_FLAG_TIMER)
    {
        for(i=0; i<PLRINVSIZE; i++)
        {
            if(ITEMDESC(INVENTORY(i)).flags)
            {
                if(get_item_property(&INVENTORY(i), PROPERTY_BURN))
                {
                    call_usefunc(get_item_property(&INVENTORY(i),
                        PROPERTY_BURN)->function, i );
                }
            }
/*          if(ITEMDESC(INVENTORY(i)).flags & ITEMFLAG_FUELED && INVENTORY(i).flags & ITEMFLAG_EQUIPPED)
            {
                INVENTORY(i).stacksize--;
                if(INVENTORY(i).stacksize == 0)
                {
                    message(gettext("Your %s burns out."), shortitemname(&INVENTORY(i)));
                    INVENTORY(i).type = 0;
                    update_player();
                }
            }*/
        }
    }
    
    if(remove_expired_timers())
        update_player();
    
    w->plr.satiation -= w->plr.extrinsic[STAT_DIGESTION] * amt;
    if(w->plr.satiation <= -600) {
        message(gettext("You are starving!"));
        plr_takedamage(w->plr.satiation/-600, gettext("Starved to death."));    // FIXME: PV shouldn't affect this
                                                // FIXME: should scale with number of turns spend
    }
    
    // Run monster AI
    for(i=0; i<MONSTERS_MAX; i++)
    {
        if(!isNull(w->m[i].type))
        {
            w->m[i].energy += MDESC(i)->speed * amt;
            
            while(w->m[i].energy >= w->plr.extrinsic[STAT_SPEED] && !isNull(w->m[i].type))
            {
                monstmove(i);
                w->m[i].energy -= w->plr.extrinsic[STAT_SPEED];
            }
        }
    }
    
    // Add monsters randomly with time
    // (1 in 70 chance per turn)
    for(i=0; i<amt; i++)
        if( !(MAPDESC_CURRENT.flags & MAPFLAG_NORANDMONST) && lrand()%70 == 0 )
        {
#ifdef DEBUG_BALANCE
            if(w->debug_mode)
                message(gettext("Added random monster."));
#endif
            addrandommonst();
        }
    
    // Clear player force-facing
    w->plr.facing_forced = -1;
    if(w->plr.velocity > 0) w->plr.velocity --;
    
    w->time++;
}
//}}}

---