root/trunk/src/cmd2.c

/*
 * File: cmd2.c
 * Purpose: Chest and door opening/closing, disarming, running, resting, &c.
 *
 * 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 "tvalsval.h"

/*
 * Go up one level
 */
void do_cmd_go_up(void)
{
        /* Verify stairs */
        if (cave_feat[p_ptr->py][p_ptr->px] != FEAT_LESS)
        {
                msg_print("I see no up staircase here.");
                return;
        }

        /* Ironman */
        if (adult_ironman)
        {
                msg_print("Nothing happens!");
                return;
        }

        /* Hack -- take a turn */
        p_ptr->energy_use = 100;

        /* Success */
        message(MSG_STAIRS_UP, 0, "You enter a maze of up staircases.");

        /* Create a way back */
        p_ptr->create_up_stair = FALSE;
        p_ptr->create_down_stair = TRUE;

        /* New depth */
        p_ptr->depth--;

        /* Leaving */
        p_ptr->leaving = TRUE;
}


/*
 * Go down one level
 */
void do_cmd_go_down(void)
{
        /* Verify stairs */
        if (cave_feat[p_ptr->py][p_ptr->px] != FEAT_MORE)
        {
                msg_print("I see no down staircase here.");
                return;
        }

        /* Hack -- take a turn */
        p_ptr->energy_use = 100;

        /* Success */
        message(MSG_STAIRS_DOWN, 0, "You enter a maze of down staircases.");

        /* Create a way back */
        p_ptr->create_up_stair = TRUE;
        p_ptr->create_down_stair = FALSE;

        /* New level */
        p_ptr->depth++;

        /* Leaving */
        p_ptr->leaving = TRUE;
}



/*
 * Simple command to "search" for one turn
 */
void do_cmd_search(void)
{
        /* Allow repeated command */
        if (p_ptr->command_arg)
        {
                /* Set repeat count */
                p_ptr->command_rep = p_ptr->command_arg - 1;

                /* Redraw the state */
                p_ptr->redraw |= (PR_STATE);

                /* Cancel the arg */
                p_ptr->command_arg = 0;
        }

        /* Take a turn */
        p_ptr->energy_use = 100;

        /* Search */
        search();
}


/*
 * Hack -- toggle search mode
 */
void do_cmd_toggle_search(void)
{
        /* Stop searching */
        if (p_ptr->searching)
        {
                /* Clear the searching flag */
                p_ptr->searching = FALSE;

                /* Recalculate bonuses */
                p_ptr->update |= (PU_BONUS);

                /* Redraw the state */
                p_ptr->redraw |= (PR_STATE);
        }

        /* Start searching */
        else
        {
                /* Set the searching flag */
                p_ptr->searching = TRUE;

                /* Update stuff */
                p_ptr->update |= (PU_BONUS);

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



/*
 * Determine if a grid contains a chest
 */
static s16b chest_check(int y, int x)
{
        s16b this_o_idx, next_o_idx = 0;


        /* Scan all objects in the grid */
        for (this_o_idx = cave_o_idx[y][x]; this_o_idx; this_o_idx = next_o_idx)
        {
                object_type *o_ptr;

                /* Get the object */
                o_ptr = &o_list[this_o_idx];

                /* Get the next object */
                next_o_idx = o_ptr->next_o_idx;

                /* Skip unknown chests XXX XXX */
                /* if (!o_ptr->marked) continue; */

                /* Check for chest */
                if (o_ptr->tval == TV_CHEST) return (this_o_idx);
        }

        /* No chest */
        return (0);
}


/*
 * Allocate objects upon opening a chest
 *
 * Disperse treasures from the given chest, centered at (x,y).
 *
 * Small chests often contain "gold", while Large chests always contain
 * items.  Wooden chests contain 2 items, Iron chests contain 4 items,
 * and Steel chests contain 6 items.  The "value" of the items in a
 * chest is based on the "power" of the chest, which is in turn based
 * on the level on which the chest is generated.
 */
static void chest_death(int y, int x, s16b o_idx)
{
        int number, value;

        bool tiny;

        object_type *o_ptr;

        object_type *i_ptr;
        object_type object_type_body;


        /* Get the chest */
        o_ptr = &o_list[o_idx];

        /* Small chests often hold "gold" */
        tiny = (o_ptr->sval < SV_CHEST_MIN_LARGE);

        /* Determine how much to drop (see above) */
        number = (o_ptr->sval % SV_CHEST_MIN_LARGE) * 2;

        /* Zero pval means empty chest */
        if (!o_ptr->pval) number = 0;

        /* Opening a chest */
        opening_chest = TRUE;

        /* Determine the "value" of the items */
        value = ABS(o_ptr->pval) + 10;

        /* Drop some objects (non-chests) */
        for (; number > 0; --number)
        {
                /* Get local object */
                i_ptr = &object_type_body;

                /* Wipe the object */
                object_wipe(i_ptr);

                /* Small chests often drop gold */
                if (tiny && (randint0(100) < 75))
                        make_gold(i_ptr, value, SV_GOLD_ANY);

                /* Otherwise drop an item */
                else
                {
                        if (!make_object(i_ptr, value, FALSE, FALSE))
                                continue;
                }

                /* Drop it in the dungeon */
                drop_near(i_ptr, -1, y, x);
        }

        /* No longer opening a chest */
        opening_chest = FALSE;

        /* Empty */
        o_ptr->pval = 0;

        /* Known */
        object_known(o_ptr);
}


/*
 * Chests have traps too.
 *
 * Exploding chest destroys contents (and traps).
 * Note that the chest itself is never destroyed.
 */
static void chest_trap(int y, int x, s16b o_idx)
{
        int i, trap;

        object_type *o_ptr = &o_list[o_idx];


        /* Ignore disarmed chests */
        if (o_ptr->pval <= 0) return;

        /* Obtain the traps */
        trap = chest_traps[o_ptr->pval];

        /* Lose strength */
        if (trap & (CHEST_LOSE_STR))
        {
                msg_print("A small needle has pricked you!");
                take_hit(damroll(1, 4), "a poison needle");
                (void)do_dec_stat(A_STR, FALSE);
        }

        /* Lose constitution */
        if (trap & (CHEST_LOSE_CON))
        {
                msg_print("A small needle has pricked you!");
                take_hit(damroll(1, 4), "a poison needle");
                (void)do_dec_stat(A_CON, FALSE);
        }

        /* Poison */
        if (trap & (CHEST_POISON))
        {
                msg_print("A puff of green gas surrounds you!");
                if (!(p_ptr->resist_pois || p_ptr->timed[TMD_OPP_POIS]))
                {
                        (void)inc_timed(TMD_POISONED, 10 + randint1(20));
                }
        }

        /* Paralyze */
        if (trap & (CHEST_PARALYZE))
        {
                msg_print("A puff of yellow gas surrounds you!");
                if (!p_ptr->free_act)
                {
                        (void)inc_timed(TMD_PARALYZED, 10 + randint1(20));
                }
        }

        /* Summon monsters */
        if (trap & (CHEST_SUMMON))
        {
                int num = 2 + randint1(3);
                msg_print("You are enveloped in a cloud of smoke!");
                sound(MSG_SUM_MONSTER);
                for (i = 0; i < num; i++)
                {
                        (void)summon_specific(y, x, p_ptr->depth, 0);
                }
        }

        /* Explode */
        if (trap & (CHEST_EXPLODE))
        {
                msg_print("There is a sudden explosion!");
                msg_print("Everything inside the chest is destroyed!");
                o_ptr->pval = 0;
                take_hit(damroll(5, 8), "an exploding chest");
        }
}


/*
 * Attempt to open the given chest at the given location
 *
 * Assume there is no monster blocking the destination
 *
 * Returns TRUE if repeated commands may continue
 */
static bool do_cmd_open_chest(int y, int x, s16b o_idx)
{
        int i, j;

        bool flag = TRUE;

        bool more = FALSE;

        object_type *o_ptr = &o_list[o_idx];


        /* Attempt to unlock it */
        if (o_ptr->pval > 0)
        {
                /* Assume locked, and thus not open */
                flag = FALSE;

                /* Get the "disarm" factor */
                i = p_ptr->skills[SKILL_DISARM];

                /* Penalize some conditions */
                if (p_ptr->timed[TMD_BLIND] || no_lite()) i = i / 10;
                if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) i = i / 10;

                /* Extract the difficulty */
                j = i - o_ptr->pval;

                /* Always have a small chance of success */
                if (j < 2) j = 2;

                /* Success -- May still have traps */
                if (randint0(100) < j)
                {
                        message(MSG_LOCKPICK, 0, "You have picked the lock.");
                        gain_exp(1);
                        flag = TRUE;
                }

                /* Failure -- Keep trying */
                else
                {
                        /* We may continue repeating */
                        more = TRUE;
                        if (flush_failure) flush();
                        message(MSG_LOCKPICK_FAIL, 0, "You failed to pick the lock.");
                }
        }

        /* Allowed to open */
        if (flag)
        {
                /* Apply chest traps, if any */
                chest_trap(y, x, o_idx);

                /* Let the Chest drop items */
                chest_death(y, x, o_idx);

                /* Squelch chest if autosquelch calls for it */
                p_ptr->notice |= PN_SQUELCH;

                /* Redraw chest, to be on the safe side (it may have been squelched) */
                lite_spot(y, x);
        }

        /* Result */
        return (more);
}


/*
 * Attempt to disarm the chest at the given location
 *
 * Assume there is no monster blocking the destination
 *
 * Returns TRUE if repeated commands may continue
 */
static bool do_cmd_disarm_chest(int y, int x, s16b o_idx)
{
        int i, j;

        bool more = FALSE;

        object_type *o_ptr = &o_list[o_idx];


        /* Get the "disarm" factor */
        i = p_ptr->skills[SKILL_DISARM];

        /* Penalize some conditions */
        if (p_ptr->timed[TMD_BLIND] || no_lite()) i = i / 10;
        if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) i = i / 10;

        /* Extract the difficulty */
        j = i - o_ptr->pval;

        /* Always have a small chance of success */
        if (j < 2) j = 2;

        /* Must find the trap first. */
        if (!object_known_p(o_ptr))
        {
                msg_print("I don't see any traps.");
        }

        /* Already disarmed/unlocked */
        else if (o_ptr->pval <= 0)
        {
                msg_print("The chest is not trapped.");
        }

        /* No traps to find. */
        else if (!chest_traps[o_ptr->pval])
        {
                msg_print("The chest is not trapped.");
        }

        /* Success (get a lot of experience) */
        else if (randint0(100) < j)
        {
                message(MSG_DISARM, 0, "You have disarmed the chest.");
                gain_exp(o_ptr->pval);
                o_ptr->pval = (0 - o_ptr->pval);
        }

        /* Failure -- Keep trying */
        else if ((i > 5) && (randint1(i) > 5))
        {
                /* We may keep trying */
                more = TRUE;
                if (flush_failure) flush();
                msg_print("You failed to disarm the chest.");
        }

        /* Failure -- Set off the trap */
        else
        {
                msg_print("You set off a trap!");
                chest_trap(y, x, o_idx);
        }

        /* Result */
        return (more);
}


/*
 * Return TRUE if the given feature is an open door
 */
static bool is_open(int feat)
{
        return (feat == FEAT_OPEN);
}


/*
 * Return TRUE if the given feature is a closed door
 */
static bool is_closed(int feat)
{
        return ((feat >= FEAT_DOOR_HEAD) &&
                (feat <= FEAT_DOOR_TAIL));
}


/*
 * Return TRUE if the given feature is a trap
 */
static bool is_trap(int feat)
{
        return ((feat >= FEAT_TRAP_HEAD) &&
                (feat <= FEAT_TRAP_TAIL));
}


/*
 * Return the number of doors/traps around (or under) the character.
 */
static int count_feats(int *y, int *x, bool (*test)(int feat), bool under)
{
        int d;
        int xx, yy;
        int count = 0; /* Count how many matches */

        /* Check around (and under) the character */
        for (d = 0; d < 9; d++)
        {
                /* if not searching under player continue */
                if ((d == 8) && !under) continue;

                /* Extract adjacent (legal) location */
                yy = p_ptr->py + ddy_ddd[d];
                xx = p_ptr->px + ddx_ddd[d];

                /* Paranoia */
                if (!in_bounds_fully(yy, xx)) continue;

                /* Must have knowledge */
                if (!(cave_info[yy][xx] & (CAVE_MARK))) continue;

                /* Not looking for this feature */
                if (!((*test)(cave_feat[yy][xx]))) continue;

                /* Count it */
                ++count;

                /* Remember the location of the last door found */
                *y = yy;
                *x = xx;
        }

        /* All done */
        return count;
}


/*
 * Return the number of chests around (or under) the character.
 * If requested, count only trapped chests.
 */
static int count_chests(int *y, int *x, bool trapped)
{
        int d, count, o_idx;

        object_type *o_ptr;

        /* Count how many matches */
        count = 0;

        /* Check around (and under) the character */
        for (d = 0; d < 9; d++)
        {
                /* Extract adjacent (legal) location */
                int yy = p_ptr->py + ddy_ddd[d];
                int xx = p_ptr->px + ddx_ddd[d];

                /* No (visible) chest is there */
                if ((o_idx = chest_check(yy, xx)) == 0) continue;

                /* Grab the object */
                o_ptr = &o_list[o_idx];

                /* Already open */
                if (o_ptr->pval == 0) continue;

                /* No (known) traps here */
                if (trapped &&
                    (!object_known_p(o_ptr) ||
                     (o_ptr->pval < 0) ||
                     !chest_traps[o_ptr->pval]))
                {
                        continue;
                }

                /* Count it */
                ++count;

                /* Remember the location of the last chest found */
                *y = yy;
                *x = xx;
        }

        /* All done */
        return count;
}


/*
 * Extract a "direction" which will move one step from the player location
 * towards the given "target" location (or "5" if no motion necessary).
 */
static int coords_to_dir(int y, int x)
{
        return (motion_dir(p_ptr->py, p_ptr->px, y, x));
}


/*
 * Determine if a given grid may be "opened"
 */
static bool do_cmd_open_test(int y, int x)
{
        /* Must have knowledge */
        if (!(cave_info[y][x] & (CAVE_MARK)))
        {
                /* Message */
                msg_print("You see nothing there.");

                /* Nope */
                return (FALSE);
        }

        /* Must be a closed door */
        if (!((cave_feat[y][x] >= FEAT_DOOR_HEAD) &&
              (cave_feat[y][x] <= FEAT_DOOR_TAIL)))
        {
                /* Message */
                message(MSG_NOTHING_TO_OPEN, 0, "You see nothing there to open.");

                /* Nope */
                return (FALSE);
        }

        /* Okay */
        return (TRUE);
}


/*
 * Perform the basic "open" command on doors
 *
 * Assume there is no monster blocking the destination
 *
 * Returns TRUE if repeated commands may continue
 */
static bool do_cmd_open_aux(int y, int x)
{
        int i, j;

        bool more = FALSE;


        /* Verify legality */
        if (!do_cmd_open_test(y, x)) return (FALSE);


        /* Jammed door */
        if (cave_feat[y][x] >= FEAT_DOOR_HEAD + 0x08)
        {
                /* Stuck */
                msg_print("The door appears to be stuck.");
        }

        /* Locked door */
        else if (cave_feat[y][x] >= FEAT_DOOR_HEAD + 0x01)
        {
                /* Disarm factor */
                i = p_ptr->skills[SKILL_DISARM];

                /* Penalize some conditions */
                if (p_ptr->timed[TMD_BLIND] || no_lite()) i = i / 10;
                if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) i = i / 10;

                /* Extract the lock power */
                j = cave_feat[y][x] - FEAT_DOOR_HEAD;

                /* Extract the difficulty XXX XXX XXX */
                j = i - (j * 4);

                /* Always have a small chance of success */
                if (j < 2) j = 2;

                /* Success */
                if (randint0(100) < j)
                {
                        /* Message */
                        message(MSG_LOCKPICK, 0, "You have picked the lock.");

                        /* Open the door */
                        cave_set_feat(y, x, FEAT_OPEN);

                        /* Update the visuals */
                        p_ptr->update |= (PU_UPDATE_VIEW | PU_MONSTERS);

                        /* Experience */
                        gain_exp(1);
                }

                /* Failure */
                else
                {
                        /* Failure */
                        if (flush_failure) flush();

                        /* Message */
                        message(MSG_LOCKPICK_FAIL, 0, "You failed to pick the lock.");

                        /* We may keep trying */
                        more = TRUE;
                }
        }

        /* Closed door */
        else
        {
                /* Open the door */
                cave_set_feat(y, x, FEAT_OPEN);

                /* Update the visuals */
                p_ptr->update |= (PU_UPDATE_VIEW | PU_MONSTERS);

                /* Sound */
                sound(MSG_OPENDOOR);
        }

        /* Result */
        return (more);
}



/*
 * Open a closed/locked/jammed door or a closed/locked chest.
 *
 * Unlocking a locked door/chest is worth one experience point.
 */
void do_cmd_open(void)
{
        int y, x, dir;

        s16b o_idx;

        bool more = FALSE;


        /* Easy Open */
        if (easy_open)
        {
                int num_doors, num_chests;

                /* Count closed doors */
                num_doors = count_feats(&y, &x, is_closed, FALSE);

                /* Count chests (locked) */
                num_chests = count_chests(&y, &x, FALSE);

                /* See if only one target */
                if ((num_doors + num_chests) == 1)
                {
                        p_ptr->command_dir = coords_to_dir(y, x);
                }
        }

        /* Get a direction (or abort) */
        if (!get_rep_dir(&dir)) return;

        /* Get location */
        y = p_ptr->py + ddy[dir];
        x = p_ptr->px + ddx[dir];

        /* Check for chests */
        o_idx = chest_check(y, x);


        /* Verify legality */
        if (!o_idx && !do_cmd_open_test(y, x)) return;


        /* Take a turn */
        p_ptr->energy_use = 100;

        /* Apply confusion */
        if (confuse_dir(&dir))
        {
                /* Get location */
                y = p_ptr->py + ddy[dir];
                x = p_ptr->px + ddx[dir];

                /* Check for chest */
                o_idx = chest_check(y, x);
        }


        /* Allow repeated command */
        if (p_ptr->command_arg)
        {
                /* Set repeat count */
                p_ptr->command_rep = p_ptr->command_arg - 1;

                /* Redraw the state */
                p_ptr->redraw |= (PR_STATE);

                /* Cancel the arg */
                p_ptr->command_arg = 0;
        }

        /* Monster */
        if (cave_m_idx[y][x] > 0)
        {
                /* Message */
                msg_print("There is a monster in the way!");

                /* Attack */
                py_attack(y, x);
        }

        /* Chest */
        else if (o_idx)
        {
                /* Open the chest */
                more = do_cmd_open_chest(y, x, o_idx);
        }

        /* Door */
        else
        {
                /* Open the door */
                more = do_cmd_open_aux(y, x);
        }

        /* Cancel repeat unless we may continue */
        if (!more) disturb(0, 0);
}


/*
 * Determine if a given grid may be "closed"
 */
static bool do_cmd_close_test(int y, int x)
{
        /* Must have knowledge */
        if (!(cave_info[y][x] & (CAVE_MARK)))
        {
                /* Message */
                msg_print("You see nothing there.");

                /* Nope */
                return (FALSE);
        }

        /* Require open/broken door */
        if ((cave_feat[y][x] != FEAT_OPEN) &&
            (cave_feat[y][x] != FEAT_BROKEN))
        {
                /* Message */
                msg_print("You see nothing there to close.");

                /* Nope */
                return (FALSE);
        }

        /* Okay */
        return (TRUE);
}


/*
 * Perform the basic "close" command
 *
 * Assume there is no monster blocking the destination
 *
 * Returns TRUE if repeated commands may continue
 */
static bool do_cmd_close_aux(int y, int x)
{
        bool more = FALSE;


        /* Verify legality */
        if (!do_cmd_close_test(y, x)) return (FALSE);


        /* Broken door */
        if (cave_feat[y][x] == FEAT_BROKEN)
        {
                /* Message */
                msg_print("The door appears to be broken.");
        }

        /* Open door */
        else
        {
                /* Close the door */
                cave_set_feat(y, x, FEAT_DOOR_HEAD + 0x00);

                /* Update the visuals */
                p_ptr->update |= (PU_UPDATE_VIEW | PU_MONSTERS);

                /* Sound */
                sound(MSG_SHUTDOOR);
        }

        /* Result */
        return (more);
}


/*
 * Close an open door.
 */
void do_cmd_close(void)
{
        int y, x, dir;

        bool more = FALSE;


        /* Easy Close */
        if (easy_open)
        {
                /* Count open doors */
                if (count_feats(&y, &x, is_open, FALSE) == 1)
                {
                        p_ptr->command_dir = coords_to_dir(y, x);
                }
        }

        /* Get a direction (or abort) */
        if (!get_rep_dir(&dir)) return;

        /* Get location */
        y = p_ptr->py + ddy[dir];
        x = p_ptr->px + ddx[dir];


        /* Verify legality */
        if (!do_cmd_close_test(y, x)) return;


        /* Take a turn */
        p_ptr->energy_use = 100;

        /* Apply confusion */
        if (confuse_dir(&dir))
        {
                /* Get location */
                y = p_ptr->py + ddy[dir];
                x = p_ptr->px + ddx[dir];
        }


        /* Allow repeated command */
        if (p_ptr->command_arg)
        {
                /* Set repeat count */
                p_ptr->command_rep = p_ptr->command_arg - 1;

                /* Redraw the state */
                p_ptr->redraw |= (PR_STATE);

                /* Cancel the arg */
                p_ptr->command_arg = 0;
        }

        /* Monster */
        if (cave_m_idx[y][x] > 0)
        {
                /* Message */
                msg_print("There is a monster in the way!");

                /* Attack */
                py_attack(y, x);
        }

        /* Door */
        else
        {
                /* Close door */
                more = do_cmd_close_aux(y, x);
        }