root/trunk/src/dungeon.c

/*
 * File: dungeon.c
 * Purpose: The game core bits, shared across platforms.
 *
 * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
 *
 * This work is free software; you can redistribute it and/or modify it
 * under the terms of either:
 *
 * a) the GNU General Public License as published by the Free Software
 *    Foundation, version 2, or
 *
 * b) the "Angband licence":
 *    This software may be copied and distributed for educational, research,
 *    and not for profit purposes provided that this copyright and statement
 *    are included in all such copies.  Other copyrights may also apply.
 */
#include "angband.h"
#include "object/tvalsval.h"
#include "z-file.h"
#include "cmds.h"
#include "game-event.h"


/*
 * Sense the inventory
 */
static void sense_inventory(void)
{
        int i;

        int plev = p_ptr->lev;

        int feel;

        object_type *o_ptr;

        char o_name[80];

        unsigned int rate;


        /* No ID when resting or confused */
        if (p_ptr->resting) return;
        if (p_ptr->timed[TMD_CONFUSED]) return;


        /* Get improvement rate */
        if (cp_ptr->flags & CF_PSEUDO_ID_IMPROV)
                rate = cp_ptr->sense_base / (plev * plev + cp_ptr->sense_div);
        else
                rate = cp_ptr->sense_base / (plev + cp_ptr->sense_div);

        if (!one_in_(rate)) return;


        /* Check everything */
        for (i = 0; i < INVEN_TOTAL; i++)
        {
                bool okay = FALSE;
                bool heavy = ((cp_ptr->flags & CF_PSEUDO_ID_HEAVY) ? TRUE : FALSE);

                o_ptr = &inventory[i];

                /* Skip empty slots */
                if (!o_ptr->k_idx) continue;

                /* Valid "tval" codes */
                switch (o_ptr->tval)
                {
                        case TV_SHOT:
                        case TV_ARROW:
                        case TV_BOLT:
                        case TV_BOW:
                        case TV_DIGGING:
                        case TV_HAFTED:
                        case TV_POLEARM:
                        case TV_SWORD:
                        case TV_BOOTS:
                        case TV_GLOVES:
                        case TV_HELM:
                        case TV_CROWN:
                        case TV_SHIELD:
                        case TV_CLOAK:
                        case TV_SOFT_ARMOR:
                        case TV_HARD_ARMOR:
                        case TV_DRAG_ARMOR:
                        {
                                okay = TRUE;
                                break;
                        }
                }

                /* Skip non-sense machines */
                if (!okay) continue;

                /* It is known, no information needed */
                if (object_known_p(o_ptr)) continue;


                /* It has already been sensed, do not sense it again */
                if (o_ptr->ident & IDENT_SENSE)
                {
                        /* Small chance of wielded, sensed items getting complete ID */
                        if (!o_ptr->name1 && (i >= INVEN_WIELD) && one_in_(1000))
                                do_ident_item(i, o_ptr);

                        continue;
                }

                /* Occasional failure on inventory items */
                if ((i < INVEN_WIELD) && one_in_(5)) continue;



                /* It's already been pseudo-ID'd */
                if (o_ptr->pseudo &&
                    o_ptr->pseudo != INSCRIP_INDESTRUCTIBLE) continue;

                /* Indestructible objects are either excellent or terrible */
                if (o_ptr->pseudo == INSCRIP_INDESTRUCTIBLE)
                        heavy = TRUE;

                /* Check for a feeling */
                feel = (heavy ? object_pseudo_heavy(o_ptr) : object_pseudo_light(o_ptr));

                /* Skip non-feelings */
                if (!feel) continue;

                /* Stop everything */
                disturb(0, 0);

                /* Average pseudo-ID means full ID */
                if (feel == INSCRIP_AVERAGE)
                {
                        do_ident_item(i, o_ptr);
                }
                else
                {
                        object_desc(o_name, sizeof(o_name), o_ptr, FALSE, ODESC_BASE);

                        if (i >= INVEN_WIELD)
                        {
                                message_format(MSG_PSEUDOID, 0, "You feel the %s (%c) you are %s %s %s...",
                                           o_name, index_to_label(i), describe_use(i),
                                           ((o_ptr->number == 1) ? "is" : "are"),
                                           inscrip_text[feel - INSCRIP_NULL]);
                        }
                        else
                        {
                                message_format(MSG_PSEUDOID, 0, "You feel the %s (%c) in your pack %s %s...",
                                           o_name, index_to_label(i),
                                           ((o_ptr->number == 1) ? "is" : "are"),
                                           inscrip_text[feel - INSCRIP_NULL]);
                        }

                        /* Sense the object */
                        o_ptr->pseudo = feel;

                        /* The object has been "sensed" */
                        o_ptr->ident |= (IDENT_SENSE);
                }


                /* Set squelch flag as appropriate */
                if (i < INVEN_WIELD)
                        p_ptr->notice |= PN_SQUELCH;


                /* Combine / Reorder the pack (later) */
                p_ptr->notice |= (PN_COMBINE | PN_REORDER);

                /* Redraw stuff */
                p_ptr->redraw |= (PR_INVEN | PR_EQUIP);
        }
}



/*
 * Regenerate hit points
 */
static void regenhp(int percent)
{
        s32b new_chp, new_chp_frac;
        int old_chp;

        /* Save the old hitpoints */
        old_chp = p_ptr->chp;

        /* Extract the new hitpoints */
        new_chp = ((long)p_ptr->mhp) * percent + PY_REGEN_HPBASE;
        p_ptr->chp += (s16b)(new_chp >> 16);   /* div 65536 */

        /* check for overflow */
        if ((p_ptr->chp < 0) && (old_chp > 0)) p_ptr->chp = MAX_SHORT;
        new_chp_frac = (new_chp & 0xFFFF) + p_ptr->chp_frac;    /* mod 65536 */
        if (new_chp_frac >= 0x10000L)
        {
                p_ptr->chp_frac = (u16b)(new_chp_frac - 0x10000L);
                p_ptr->chp++;
        }
        else
        {
                p_ptr->chp_frac = (u16b)new_chp_frac;
        }

        /* Fully healed */
        if (p_ptr->chp >= p_ptr->mhp)
        {
                p_ptr->chp = p_ptr->mhp;
                p_ptr->chp_frac = 0;
        }

        /* Notice changes */
        if (old_chp != p_ptr->chp)
        {
                /* Redraw */
                p_ptr->redraw |= (PR_HP);
        }
}


/*
 * Regenerate mana points
 */
static void regenmana(int percent)
{
        s32b new_mana, new_mana_frac;
        int old_csp;

        old_csp = p_ptr->csp;
        new_mana = ((long)p_ptr->msp) * percent + PY_REGEN_MNBASE;
        p_ptr->csp += (s16b)(new_mana >> 16);   /* div 65536 */
        /* check for overflow */
        if ((p_ptr->csp < 0) && (old_csp > 0))
        {
                p_ptr->csp = MAX_SHORT;
        }
        new_mana_frac = (new_mana & 0xFFFF) + p_ptr->csp_frac;  /* mod 65536 */
        if (new_mana_frac >= 0x10000L)
        {
                p_ptr->csp_frac = (u16b)(new_mana_frac - 0x10000L);
                p_ptr->csp++;
        }
        else
        {
                p_ptr->csp_frac = (u16b)new_mana_frac;
        }

        /* Must set frac to zero even if equal */
        if (p_ptr->csp >= p_ptr->msp)
        {
                p_ptr->csp = p_ptr->msp;
                p_ptr->csp_frac = 0;
        }

        /* Redraw mana */
        if (old_csp != p_ptr->csp)
        {
                /* Redraw */
                p_ptr->redraw |= (PR_MANA);
        }
}






/*
 * Regenerate the monsters (once per 100 game turns)
 *
 * XXX XXX XXX Should probably be done during monster turns.
 */
static void regen_monsters(void)
{
        int i, frac;

        /* Regenerate everyone */
        for (i = 1; i < mon_max; i++)
        {
                /* Check the i'th monster */
                monster_type *m_ptr = &mon_list[i];
                monster_race *r_ptr = &r_info[m_ptr->r_idx];

                /* Skip dead monsters */
                if (!m_ptr->r_idx) continue;

                /* Allow regeneration (if needed) */
                if (m_ptr->hp < m_ptr->maxhp)
                {
                        /* Hack -- Base regeneration */
                        frac = m_ptr->maxhp / 100;

                        /* Hack -- Minimal regeneration rate */
                        if (!frac) frac = 1;

                        /* Hack -- Some monsters regenerate quickly */
                        if (r_ptr->flags[1] & (RF1_REGENERATE)) frac *= 2;

                        /* Hack -- Regenerate */
                        m_ptr->hp += frac;

                        /* Do not over-regenerate */
                        if (m_ptr->hp > m_ptr->maxhp) m_ptr->hp = m_ptr->maxhp;

                        /* Redraw (later) if needed */
                        if (p_ptr->health_who == i) p_ptr->redraw |= (PR_HEALTH);
                }
        }
}


/*
 * If player has inscribed the object with "!!", let him know when it's
 * recharged. -LM-
 * Also inform player when first item of a stack has recharged. -HK-
 */
static void recharged_notice(const object_type *o_ptr, bool all)
{
        char o_name[120];

        cptr s;

        /* No inscription */
        if (!o_ptr->note) return;

        /* Find a '!' */
        s = strchr(quark_str(o_ptr->note), '!');

        /* Process notification request */
        while (s)
        {
                /* Find another '!' */
                if (s[1] == '!')
                {
                        /* Describe (briefly) */
                        object_desc(o_name, sizeof(o_name), o_ptr, FALSE, ODESC_BASE);

                        /* Disturb the player */
                        disturb(0, 0);

                        /* Notify the player */
                        if (o_ptr->number > 1)
                        {
                                if (all) msg_format("Your %s have recharged.", o_name);
                                else msg_format("One of your %s has recharged.", o_name);
                        }

                        /* Artifacts */
                        else if (o_ptr->name1)
                        {
                                msg_format("The %s has recharged.", o_name);
                        }

                        /* Single, non-artifact items */
                        else msg_format("Your %s has recharged.", o_name);

                        /* Done */
                        return;
                }

                /* Keep looking for '!'s */
                s = strchr(s + 1, '!');
        }
}


/*
 * Recharge activatable objects in the player's equipment
 * and rods in the inventory and on the ground.
 */
static void recharge_objects(void)
{
        int i;

        int charged = 0;

        object_type *o_ptr;
        object_kind *k_ptr;


        /* Process equipment */
        for (i = INVEN_WIELD; i < INVEN_TOTAL; i++)
        {
                /* Get the object */
                o_ptr = &inventory[i];

                /* Skip non-objects */
                if (!o_ptr->k_idx) continue;

                /* Recharge activatable objects */
                if (o_ptr->timeout > 0 && !(o_ptr->tval == TV_LITE && !artifact_p(o_ptr)))
                {
                        /* Recharge */
                        o_ptr->timeout--;

                        /* Notice changes */
                        if (!o_ptr->timeout) charged++;

                        /* Message if item is recharged, if inscribed with "!!" */
                        if (!o_ptr->timeout) recharged_notice(o_ptr, TRUE);
                }
        }

        /* Notice changes */
        if (charged)
        {
                /* Window stuff */
                p_ptr->redraw |= (PR_EQUIP);
        }

        charged = 0;

        /* Recharge rods */
        for (i = 0; i < INVEN_PACK; i++)
        {
                o_ptr = &inventory[i];
                k_ptr = &k_info[o_ptr->k_idx];

                /* Skip non-objects */
                if (!o_ptr->k_idx) continue;

                /* Examine all charging rods */
                if ((o_ptr->tval == TV_ROD) && (o_ptr->timeout))
                {
                        /* Determine how many rods are charging */
                        int temp = (o_ptr->timeout + (k_ptr->time_base - 1)) / k_ptr->time_base;
                        if (temp > o_ptr->number) temp = o_ptr->number;

                        /* Decrease timeout by that number */
                        o_ptr->timeout -= temp;

                        /* Boundary control */
                        if (o_ptr->timeout < 0) o_ptr->timeout = 0;

                        /* Update if any rods are recharged */
                        if (temp > (o_ptr->timeout + (k_ptr->time_base - 1)) / k_ptr->time_base)
                        {
                                /* Update window */
                                charged++;

                                /* Message if whole stack is recharged, if inscribed with "!!" */
                                if (!o_ptr->timeout) recharged_notice(o_ptr, TRUE);
                                /* Message if first in a stack is recharged, if inscribed with "!!" -HK- */
                                else if (temp == o_ptr->number) recharged_notice(o_ptr, FALSE);
                        }
                }
        }

        /* Notice changes */
        if (charged)
        {
                /* Combine pack */
                p_ptr->notice |= (PN_COMBINE);

                /* Redraw stuff */
                p_ptr->redraw |= (PR_INVEN);
        }


        /*** Process Objects ***/

        /* Process objects */
        for (i = 1; i < o_max; i++)
        {
                /* Get the object */
                o_ptr = &o_list[i];

                /* Skip dead objects */
                if (!o_ptr->k_idx) continue;

                /* Recharge rods on the ground */
                if ((o_ptr->tval == TV_ROD) && o_ptr->timeout)
                {
                        /* Charge it */
                        o_ptr->timeout -= o_ptr->number;

                        /* Boundary control */
                        if (o_ptr->timeout < 0) o_ptr->timeout = 0;
                }
        }
}


static void play_ambient_sound(void)
{
        /* Town sound */
        if (p_ptr->depth == 0) 
        {
                /* Hack - is it daytime or nighttime? */
                if (turn % (10L * TOWN_DAWN) < TOWN_DAWN / 2)
                {
                        /* It's day. */
                        sound(MSG_AMBIENT_DAY);
                } 
                else 
                {
                        /* It's night. */
                        sound(MSG_AMBIENT_NITE);
                }
                
        }

        /* Dungeon level 1-20 */
        else if (p_ptr->depth <= 20) 
        {
                sound(MSG_AMBIENT_DNG1);
        }

        /* Dungeon level 21-40 */
        else if (p_ptr->depth <= 40) 
        {
                sound(MSG_AMBIENT_DNG2);
        }

        /* Dungeon level 41-60 */
        else if (p_ptr->depth <= 60) 
        {
                sound(MSG_AMBIENT_DNG3);
        }

        /* Dungeon level 61-80 */
        else if (p_ptr->depth <= 80) 
        {
                sound(MSG_AMBIENT_DNG4);
        }

        /* Dungeon level 80- */
        else  
        {
                sound(MSG_AMBIENT_DNG5);
        }
}

/*
 * Helper for process_world -- decrement p_ptr->timed[] fields.
 */
static void decrease_timeouts(void)
{
        int adjust = (adj_con_fix[p_ptr->state.stat_ind[A_CON]] + 1);
        int i;

        /* Decrement all effects that can be done simply */
        for (i = 0; i < TMD_MAX; i++)
        {
                int decr = 1;
                if (!p_ptr->timed[i])
                        continue;

                switch (i)
                {
                        case TMD_CUT:
                        {
                                /* Hack -- check for truly "mortal" wound */
                                decr = (p_ptr->timed[i] > 1000) ? 0 : adjust;
                                break;
                        }

                        case TMD_POISONED:
                        case TMD_STUN:
                        {
                                decr = adjust;
                                break;
                        }
                }
                /* Decrement the effect */
                dec_timed(i, decr, FALSE);
        }

        return;
}


/*
 * Handle certain things once every 10 game turns
 */
static void process_world(void)
{
        int i;

        int regen_amount;

        object_type *o_ptr;

        /* Every 10 game turns */
        if (turn % 10) return;


        /*** Check the Time and Load ***/

        /* Play an ambient sound at regular intervals. */
        if (!(turn % ((10L * TOWN_DAWN) / 4)))
        {
                play_ambient_sound();
        }

        /*** Handle the "town" (stores and sunshine) ***/

        /* While in town */
        if (!p_ptr->depth)
        {
                /* Hack -- Daybreak/Nighfall in town */
                if (!(turn % ((10L * TOWN_DAWN) / 2)))
                {
                        bool dawn;

                        /* Check for dawn */
                        dawn = (!(turn % (10L * TOWN_DAWN)));

                        /* Day breaks */
                        if (dawn)
                                msg_print("The sun has risen.");

                        /* Night falls */
                        else
                                msg_print("The sun has fallen.");

                        /* Illuminate */
                        town_illuminate(dawn);
                }
        }


        /* While in the dungeon */
        else
        {
                /*** Update the Stores ***/

                /* Update the stores once a day (while in dungeon) */
                if (!(turn % (10L * STORE_TURNS)))
                {
                        int n;

                        /* Message */
                        if (cheat_xtra) msg_print("Updating Shops...");

                        /* Maintain each shop (except home) */
                        for (n = 0; n < MAX_STORES; n++)
                        {
                                /* Skip the home */
                                if (n == STORE_HOME) continue;

                                /* Maintain */
                                store_maint(n);
                        }

                        /* Sometimes, shuffle the shop-keepers */
                        if (one_in_(STORE_SHUFFLE))
                        {
                                /* Message */
                                if (cheat_xtra) msg_print("Shuffling a Shopkeeper...");

                                /* Pick a random shop (except home) */
                                while (1)
                                {
                                        n = randint0(MAX_STORES);
                                        if (n != STORE_HOME) break;
                                }

                                /* Shuffle it */
                                store_shuffle(n);
                        }

                        /* Message */
                        if (cheat_xtra) msg_print("Done.");
                }
        }


        /*** Process the monsters ***/

        /* Check for creature generation */
        if (one_in_(MAX_M_ALLOC_CHANCE))
        {
                /* Make a new monster */
                (void)alloc_monster(MAX_SIGHT + 5, FALSE, p_ptr->depth);
        }

        /* Hack -- Check for creature regeneration */
        if (!(turn % 100)) regen_monsters();


        /*** Damage over Time ***/

        /* Take damage from poison */
        if (p_ptr->timed[TMD_POISONED])
        {
                /* Take damage */
                take_hit(1, "poison");
        }

        /* Take damage from cuts */
        if (p_ptr->timed[TMD_CUT])
        {
                /* Mortal wound or Deep Gash */
                if (p_ptr->timed[TMD_CUT] > 200)
                        i = 3;

                /* Severe cut */
                else if (p_ptr->timed[TMD_CUT] > 100)
                        i = 2;

                /* Other cuts */
                else
                        i = 1;

                /* Take damage */
                take_hit(i, "a fatal wound");
        }


        /*** Check the Food, and Regenerate ***/

        /* Digest normally */
        if (p_ptr->food < PY_FOOD_MAX)
        {
                /* Every 100 game turns */
                if (!(turn % 100))
                {
                        /* Basic digestion rate based on speed */
                        i = extract_energy[p_ptr->state.speed] * 2;

                        /* Regeneration takes more food */
                        if (p_ptr->state.regenerate) i += 30;

                        /* Slow digestion takes less food */
                        if (p_ptr->state.slow_digest) i -= 10;

                        /* Minimal digestion */
                        if (i < 1) i = 1;

                        /* Digest some food */
                        (void)set_food(p_ptr->food - i);
                }
        }

        /* Digest quickly when gorged */
        else
        {
                /* Digest a lot of food */
                (void)set_food(p_ptr->food - 100);
        }

        /* Getting Faint */
        if (p_ptr->food < PY_FOOD_FAINT)
        {
                /* Faint occasionally */
                if (!p_ptr->timed[TMD_PARALYZED] && one_in_(10))
                {
                        /* Message */
                        msg_print("You faint from the lack of food.");
                        disturb(1, 0);

                        /* Hack -- faint (bypass free action) */
                        (void)inc_timed(TMD_PARALYZED, 1 + randint0(5), TRUE);
                }
        }


        /* Starve to death (slowly) */
        if (p_ptr->food < PY_FOOD_STARVE)
        {
                /* Calculate damage */
                i = (PY_FOOD_STARVE - p_ptr->food) / 10;

                /* Take damage */
                take_hit(i, "starvation");
        }

        /** Regenerate HP **/

        /* Default regeneration */
        if (p_ptr->food >= PY_FOOD_WEAK)
                regen_amount = PY_REGEN_NORMAL;
        else if (p_ptr->food < PY_FOOD_STARVE)
                regen_amount = 0;
        else if (p_ptr->food < PY_FOOD_FAINT)
                regen_amount = PY_REGEN_FAINT;
        else /* if (p_ptr->food < PY_FOOD_WEAK) */
                regen_amount = PY_REGEN_WEAK;

        /* Various things speed up regeneration */
        if (p_ptr->state.regenerate)
                regen_amount *= 2;
        if (p_ptr->searching || p_ptr->resting)
                regen_amount *= 2;

        /* Some things slow it down */
        if (p_ptr->state.impair_hp)
                regen_amount /= 2;

        /* Various things interfere with physical healing */
        if (p_ptr->timed[TMD_PARALYZED]) regen_amount = 0;
        if (p_ptr->timed[TMD_POISONED]) regen_amount = 0;
        if (p_ptr->timed[TMD_STUN]) regen_amount = 0;
        if (p_ptr->timed[TMD_CUT]) regen_amount = 0;

        /* Regenerate Hit Points if needed */
        if (p_ptr->chp < p_ptr->mhp)
                regenhp(regen_amount);


        /** Regenerate SP **/

        /* Default regeneration */
        regen_amount = PY_REGEN_NORMAL;

        /* Various things speed up regeneration */
        if (p_ptr->state.regenerate)
                regen_amount *= 2;
        if (p_ptr->searching || p_ptr->resting)
                regen_amount *= 2;

        /* Some things slow it down */
        if (p_ptr->state.impair_mana)
                regen_amount /= 2;

        /* Regenerate mana */
        if (p_ptr->csp < p_ptr->msp)
                regenmana(regen_amount);



        /*** Timeout Various Things ***/

        decrease_timeouts();



        /*** Process Light ***/

        /* Check for light being wielded */
        o_ptr = &inventory[INVEN_LITE];

        /* Burn some fuel in the current lite */
        if (o_ptr->tval == TV_LITE)
        {
                u32b f1, f2, f3;
                bool burn_fuel = TRUE;

                /* Get the object flags */
                object_flags(o_ptr, &f1, &f2, &f3);

                /* Turn off the wanton burning of light during the day in the town */
                if (!p_ptr->depth && ((turn % (10L * TOWN_DAWN)) < ((10L * TOWN_DAWN) / 2)))
                        burn_fuel = FALSE;

                /* If the light has the NO_FUEL flag, well... */
                if (f3 & TR3_NO_FUEL)
                    burn_fuel = FALSE;

                /* Use some fuel (except on artifacts, or during the day) */
                if (burn_fuel && o_ptr->timeout > 0)
                {
                        /* Decrease life-span */
                        o_ptr->timeout--;

                        /* Hack -- notice interesting fuel steps */
                        if ((o_ptr->timeout < 100) || (!(o_ptr->timeout % 100)))
                        {
                                /* Redraw stuff */
                                p_ptr->redraw |= (PR_EQUIP);
                        }

                        /* Hack -- Special treatment when blind */
                        if (p_ptr->timed[TMD_BLIND])
                        {
                                /* Hack -- save some light for later */
                                if (o_ptr->timeout == 0) o_ptr->timeout++;
                        }

                        /* The light is now out */
                        else if (o_ptr->timeout == 0)
                        {
                                disturb(0, 0);
                                msg_print(