root/trunk/src/cmd3.c

/*
 * File: cmd3.c
 * Purpose: Miscellaneous queries
 *
 * 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"


/*
 * Display inventory
 */
void do_cmd_inven(void)
{
        /* Hack -- Start in "inventory" mode */
        p_ptr->command_wrk = (USE_INVEN);

        /* Save screen */
        screen_save();

        /* Hack -- show empty slots */
        item_tester_full = TRUE;

        /* Display the inventory */
        show_inven();

        /* Hack -- hide empty slots */
        item_tester_full = FALSE;

        /* Prompt for a command */
        prt(format("(Inventory) Burden %d.%dlb (%d%% capacity). Command: ",
            p_ptr->total_weight / 10, p_ptr->total_weight % 10,
            (10 * p_ptr->total_weight) / (6 * adj_str_wgt[p_ptr->stat_ind[A_STR]])), 0, 0);

        /* Hack -- Get a new command */
        p_ptr->command_new = inkey();

        /* Load screen */
        screen_load();


        /* Hack -- Process "Escape" */
        if (p_ptr->command_new == ESCAPE)
        {
                /* Reset stuff */
                p_ptr->command_new = 0;
        }
}


/*
 * Display equipment
 */
void do_cmd_equip(void)
{
        /* Hack -- Start in "equipment" mode */
        p_ptr->command_wrk = (USE_EQUIP);

        /* Save screen */
        screen_save();

        /* Hack -- show empty slots */
        item_tester_full = TRUE;

        /* Display the equipment */
        show_equip();

        /* Hack -- undo the hack above */
        item_tester_full = FALSE;

        /* Prompt for a command */
        prt("(Equipment) Command: ", 0, 0);

        /* Hack -- Get a new command */
        p_ptr->command_new = inkey();

        /* Load screen */
        screen_load();


        /* Hack -- Process "Escape" */
        if (p_ptr->command_new == ESCAPE)
        {
                /* Reset stuff */
                p_ptr->command_new = 0;
        }
}


/*
 * Wield or wear a single item from the pack or floor
 */
void wield_item(object_type *o_ptr, int item)
{
        object_type object_type_body;
        object_type *i_ptr = &object_type_body;

        cptr act;
        char o_name[80];

        int slot = wield_slot(o_ptr);

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

        /* Obtain local object */
        object_copy(i_ptr, o_ptr);

        /* Modify quantity */
        i_ptr->number = 1;

        /* Decrease the item (from the pack) */
        if (item >= 0)
        {
                inven_item_increase(item, -1);
                inven_item_optimize(item);
        }

        /* Decrease the item (from the floor) */
        else
        {
                floor_item_increase(0 - item, -1);
                floor_item_optimize(0 - item);
        }

        /* Get the wield slot */
        o_ptr = &inventory[slot];

        /* Take off existing item */
        if (o_ptr->k_idx)
        {
                /* Take off existing item */
                (void)inven_takeoff(slot, 255);
        }

        /* Wear the new stuff */
        object_copy(o_ptr, i_ptr);

        /* Increase the weight */
        p_ptr->total_weight += i_ptr->weight;

        /* Increment the equip counter by hand */
        p_ptr->equip_cnt++;

        /* Where is the item now */
        if (slot == INVEN_WIELD)
                act = "You are wielding";
        else if (slot == INVEN_BOW)
                act = "You are shooting with";
        else if (slot == INVEN_LITE)
                act = "Your light source is";
        else
                act = "You are wearing";

        /* Describe the result */
        object_desc(o_name, sizeof(o_name), o_ptr, TRUE, ODESC_FULL);

        /* Message */
        sound(MSG_WIELD);
        msg_format("%s %s (%c).", act, o_name, index_to_label(slot));

        /* Cursed! */
        if (cursed_p(o_ptr))
        {
                /* Warn the player */
                sound(MSG_CURSED);
                msg_print("Oops! It feels deathly cold!");

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

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

                /* Set squelched status */
                p_ptr->notice |= PN_SQUELCH;
        }

        /* Recalculate bonuses, torch, mana */
        p_ptr->update |= (PU_BONUS | PU_TORCH | PU_MANA);
        p_ptr->redraw |= (PR_INVEN | PR_EQUIP);
}



/*
 * Destroy an item
 */
void do_cmd_destroy(void)
{
        int item, amt;

        object_type *o_ptr;

        object_type *i_ptr;
        object_type object_type_body;

        char o_name[120];
        char out_val[160];

        cptr q, s;

        /* Get an item */
        q = "Destroy which item? ";
        s = "You have nothing to destroy.";
        if (!get_item(&item, q, s, (USE_INVEN | USE_EQUIP | USE_FLOOR | CAN_SQUELCH))) return;

        /* Deal with squelched items */
        if (item == ALL_SQUELCHED)
        {
                squelch_items();
                return;
        }

        /* Get the item (in the pack) */
        if (item >= 0)
        {
                o_ptr = &inventory[item];
        }

        /* Get the item (on the floor) */
        else
        {
                o_ptr = &o_list[0 - item];
        }

        /* Get a quantity */
        amt = get_quantity(NULL, o_ptr->number);

        /* Allow user abort */
        if (amt <= 0) return;

        /* Get local object */
        i_ptr = &object_type_body;

        /* Obtain a local object */
        object_copy(i_ptr, o_ptr);

        if ((o_ptr->tval == TV_WAND) ||
            (o_ptr->tval == TV_STAFF) ||
            (o_ptr->tval == TV_ROD))
        {
                /* Calculate the amount of destroyed charges */
                i_ptr->pval = o_ptr->pval * amt / o_ptr->number;
        }

        /* Set quantity */
        i_ptr->number = amt;

        /* Describe the destroyed object */
        object_desc(o_name, sizeof(o_name), i_ptr, TRUE, ODESC_FULL);

        /* Verify destruction */
        strnfmt(out_val, sizeof(out_val), "Really destroy %s? ", o_name);
        if (!get_check(out_val)) return;

        /* Artifacts cannot be destroyed */
        if (artifact_p(o_ptr))
        {
                /* Message */
                msg_format("You cannot destroy %s.", o_name);

                /* Don't mark id'ed objects */
                if (object_known_p(o_ptr)) return;

                /* It has already been sensed */
                if (o_ptr->ident & (IDENT_SENSE))
                {
                        /* Already sensed objects always get improved feelings */
                        if (cursed_p(o_ptr))
                                o_ptr->pseudo = INSCRIP_TERRIBLE;
                        else
                                o_ptr->pseudo = INSCRIP_SPECIAL;
                }
                else
                {
                        /* Mark the object as indestructible */
                        o_ptr->pseudo = INSCRIP_INDESTRUCTIBLE;
                }

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

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

                /* Done */
                return;
        }

        /* Message */
        message_format(MSG_DESTROY, 0, "You destroy %s.", o_name);

        /* Reduce the charges of rods/wands/staves */
        reduce_charges(o_ptr, amt);

        /* Eliminate the item (from the pack) */
        if (item >= 0)
        {
                inven_item_increase(item, -amt);
                inven_item_describe(item);
                inven_item_optimize(item);
        }

        /* Eliminate the item (from the floor) */
        else
        {
                floor_item_increase(0 - item, -amt);
                floor_item_describe(0 - item);
                floor_item_optimize(0 - item);
        }

#if 0
        /*
         * We can only re-enable this when it can be made to interact well with
         * the repeat code.
         */

        /* We have destroyed a floor item, and the floor is not empty */
        if ((item < 0) && (cave_o_idx[p_ptr->py][p_ptr->px]))
        {
                /* Automatically repeat this command (unless disturbed) */
                p_ptr->command_cmd = 'k';
                p_ptr->command_rep = 2;
        }
#endif
}




void refill_lamp(object_type *j_ptr, object_type *o_ptr, int item)
{
        /* Refuel */
        j_ptr->timeout += o_ptr->timeout ? o_ptr->timeout : o_ptr->pval;

        /* Message */
        msg_print("You fuel your lamp.");

        /* Comment */
        if (j_ptr->timeout >= FUEL_LAMP)
        {
                j_ptr->timeout = FUEL_LAMP;
                msg_print("Your lamp is full.");
        }

        /* Refilled from a lantern */
        if (o_ptr->sval == SV_LITE_LANTERN)
        {
                /* Unstack if necessary */
                if (o_ptr->number > 1)
                {
                        object_type *i_ptr;
                        object_type object_type_body;

                        /* Get local object */
                        i_ptr = &object_type_body;

                        /* Obtain a local object */
                        object_copy(i_ptr, o_ptr);

                        /* Modify quantity */
                        i_ptr->number = 1;

                        /* Remove fuel */
                        i_ptr->timeout = 0;

                        /* Unstack the used item */
                        o_ptr->number--;
                        p_ptr->total_weight -= i_ptr->weight;

                        /* Carry or drop */
                        if (item >= 0)
                                item = inven_carry(i_ptr);
                        else
                                drop_near(i_ptr, 0, p_ptr->py, p_ptr->px);
                }

                /* Empty a single lantern */
                else
                {
                        /* No more fuel */
                        o_ptr->timeout = 0;
                }

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

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

        /* Refilled from a flask */
        else
        {
                /* Decrease the item (from the pack) */
                if (item >= 0)
                {
                        inven_item_increase(item, -1);
                        inven_item_describe(item);
                        inven_item_optimize(item);
                }

                /* Decrease the item (from the floor) */
                else
                {
                        floor_item_increase(0 - item, -1);
                        floor_item_describe(0 - item);
                        floor_item_optimize(0 - item);
                }
        }

        /* Recalculate torch */
        p_ptr->update |= (PU_TORCH);

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


void refuel_torch(object_type *j_ptr, object_type *o_ptr, int item)
{
        /* Refuel */
        j_ptr->timeout += o_ptr->timeout + 5;

        /* Message */
        msg_print("You combine the torches.");

        /* Over-fuel message */
        if (j_ptr->timeout >= FUEL_TORCH)
        {
                j_ptr->timeout = FUEL_TORCH;
                msg_print("Your torch is fully fueled.");
        }

        /* Refuel message */
        else
        {
                msg_print("Your torch glows more brightly.");
        }

        /* Decrease the item (from the pack) */
        if (item >= 0)
        {
                inven_item_increase(item, -1);
                inven_item_describe(item);
                inven_item_optimize(item);
        }

        /* Decrease the item (from the floor) */
        else
        {
                floor_item_increase(0 - item, -1);
                floor_item_describe(0 - item);
                floor_item_optimize(0 - item);
        }

        /* Recalculate torch */
        p_ptr->update |= (PU_TORCH);

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






/*
 * Target command
 */
void do_cmd_target(void)
{
        /* Target set */
        if (target_set_interactive(TARGET_KILL, -1, -1))
        {
                msg_print("Target Selected.");
        }

        /* Target aborted */
        else
        {
                msg_print("Target Aborted.");
        }
}



/*
 * Look command
 */
void do_cmd_look(void)
{
        /* Look around */
        if (target_set_interactive(TARGET_LOOK, -1, -1))
        {
                msg_print("Target Selected.");
        }
}



/*
 * Allow the player to examine other sectors on the map
 */
void do_cmd_locate(void)
{
        int dir, y1, x1, y2, x2;

        char tmp_val[80];

        char out_val[160];


        /* Start at current panel */
        y1 = Term->offset_y;
        x1 = Term->offset_x;

        /* Show panels until done */
        while (1)
        {
                /* Get the current panel */
                y2 = Term->offset_y;
                x2 = Term->offset_x;
                
                /* Describe the location */
                if ((y2 == y1) && (x2 == x1))
                {
                        tmp_val[0] = '\0';
                }
                else
                {
                        strnfmt(tmp_val, sizeof(tmp_val), "%s%s of",
                                ((y2 < y1) ? " north" : (y2 > y1) ? " south" : ""),
                                ((x2 < x1) ? " west" : (x2 > x1) ? " east" : ""));
                }

                /* Prepare to ask which way to look */
                strnfmt(out_val, sizeof(out_val),
                        "Map sector [%d,%d], which is%s your sector.  Direction?",
                        (y2 / PANEL_HGT), (x2 / PANEL_WID), tmp_val);

                /* More detail */
                if (center_player)
                {
                        strnfmt(out_val, sizeof(out_val),
                                "Map sector [%d(%02d),%d(%02d)], which is%s your sector.  Direction?",
                                (y2 / PANEL_HGT), (y2 % PANEL_HGT),
                                (x2 / PANEL_WID), (x2 % PANEL_WID), tmp_val);
                }

                /* Assume no direction */
                dir = 0;

                /* Get a direction */
                while (!dir)
                {
                        char command;

                        /* Get a command (or Cancel) */
                        if (!get_com(out_val, &command)) break;

                        /* Extract direction */
                        dir = target_dir(command);

                        /* Error */
                        if (!dir) bell("Illegal direction for locate!");
                }

                /* No direction */
                if (!dir) break;

                /* Apply the motion */
                change_panel(dir);

                /* Handle stuff */
                handle_stuff();
        }

        /* Verify panel */
        verify_panel();
}






/*
 * The table of "symbol info" -- each entry is a string of the form
 * "X:desc" where "X" is the trigger, and "desc" is the "info".
 */
static cptr ident_info[] =
{
        " :A dark grid",
        "!:A potion (or oil)",
        "\":An amulet (or necklace)",
        "#:A wall (or secret door)",
        "$:Treasure (gold or gems)",
        "%:A vein (magma or quartz)",
        /* "&:unused", */
        "':An open door",
        "(:Soft armor",
        "):A shield",
        "*:A vein with treasure",
        "+:A closed door",
        ",:Food (or mushroom patch)",
        "-:A wand (or rod)",
        ".:Floor",
        "/:A polearm (Axe/Pike/etc)",
        /* "0:unused", */
        "1:Entrance to General Store",
        "2:Entrance to Armory",
        "3:Entrance to Weaponsmith",
        "4:Entrance to Temple",
        "5:Entrance to Alchemy shop",
        "6:Entrance to Magic store",
        "7:Entrance to Black Market",
        "8:Entrance to your home",
        /* "9:unused", */
        "::Rubble",
        ";:A glyph of warding",
        "<:An up staircase",
        "=:A ring",
        ">:A down staircase",
        "?:A scroll",
        "@:You",
        "A:Angel",
        "B:Bird",
        "C:Canine",
        "D:Ancient Dragon/Wyrm",
        "E:Elemental",
        "F:Dragon Fly",
        "G:Ghost",
        "H:Hybrid",
        "I:Insect",
        "J:Snake",
        "K:Killer Beetle",
        "L:Lich",
        "M:Multi-Headed Reptile",
        /* "N:unused", */
        "O:Ogre",
        "P:Giant Humanoid",
        "Q:Quylthulg (Pulsing Flesh Mound)",
        "R:Reptile/Amphibian",
        "S:Spider/Scorpion/Tick",
        "T:Troll",
        "U:Major Demon",
        "V:Vampire",
        "W:Wight/Wraith/etc",
        "X:Xorn/Xaren/etc",
        "Y:Yeti",
        "Z:Zephyr Hound",
        "[:Hard armor",
        "\\:A hafted weapon (mace/whip/etc)",
        "]:Misc. armor",
        "^:A trap",
        "_:A staff",
        /* "`:unused", */
        "a:Ant",
        "b:Bat",
        "c:Centipede",
        "d:Dragon",
        "e:Floating Eye",
        "f:Feline",
        "g:Golem",
        "h:Hobbit/Elf/Dwarf",
        "i:Icky Thing",
        "j:Jelly",
        "k:Kobold",
        "l:Louse",
        "m:Mold",
        "n:Naga",
        "o:Orc",
        "p:Person/Human",
        "q:Quadruped",
        "r:Rodent",
        "s:Skeleton",
        "t:Townsperson",
        "u:Minor Demon",
        "v:Vortex",
        "w:Worm/Worm-Mass",
        /* "x:unused", */
        "y:Yeek",
        "z:Zombie/Mummy",
        "{:A missile (arrow/bolt/shot)",
        "|:An edged weapon (sword/dagger/etc)",
        "}:A launcher (bow/crossbow/sling)",
        "~:A tool (or miscellaneous item)",
        NULL
};



/*
 * Sorting hook -- Comp function -- see below
 *
 * We use "u" to point to array of monster indexes,
 * and "v" to select the type of sorting to perform on "u".
 */
bool ang_sort_comp_hook(const void *u, const void *v, int a, int b)
{
        const u16b *who = (const u16b *)(u);
        const u16b *why = (const u16b *)(v);

        int w1 = who[a];
        int w2 = who[b];

        int z1, z2;


        /* Sort by player kills */
        if (*why >= 4)
        {
                /* Extract player kills */
                z1 = l_list[w1].pkills;
                z2 = l_list[w2].pkills;

                /* Compare player kills */
                if (z1 < z2) return (TRUE);
                if (z1 > z2) return (FALSE);
        }


        /* Sort by total kills */
        if (*why >= 3)
        {
                /* Extract total kills */
                z1 = l_list[w1].tkills;
                z2 = l_list[w2].tkills;

                /* Compare total kills */
                if (z1 < z2) return (TRUE);
                if (z1 > z2) return (FALSE);
        }


        /* Sort by monster level */
        if (*why >= 2)
        {
                /* Extract levels */
                z1 = r_info[w1].level;
                z2 = r_info[w2].level;

                /* Compare levels */
                if (z1 < z2) return (TRUE);
                if (z1 > z2) return (FALSE);
        }


        /* Sort by monster experience */
        if (*why >= 1)
        {
                /* Extract experience */
                z1 = r_info[w1].mexp;
                z2 = r_info[w2].mexp;

                /* Compare experience */
                if (z1 < z2) return (TRUE);
                if (z1 > z2) return (FALSE);
        }


        /* Compare indexes */
        return (w1 <= w2);
}


/*
 * Sorting hook -- Swap function -- see below
 *
 * We use "u" to point to array of monster indexes,
 * and "v" to select the type of sorting to perform.
 */
void ang_sort_swap_hook(void *u, void *v, int a, int b)
{
        u16b *who = (u16b*)(u);

        u16b holder;

        /* Unused parameter */
        (void)v;

        /* Swap */
        holder = who[a];
        who[a] = who[b];
        who[b] = holder;
}


/*
 * Identify a character, allow recall of monsters
 *
 * Several "special" responses recall "multiple" monsters:
 *   ^A (all monsters)
 *   ^U (all unique monsters)
 *   ^N (all non-unique monsters)
 *
 * The responses may be sorted in several ways, see below.
 *
 * Note that the player ghosts are ignored, since they do not exist.
 */
void do_cmd_query_symbol(void)
{
        int i, n, r_idx;
        char sym;
        char buf[128];

        ui_event_data query;

        bool all = FALSE;
        bool uniq = FALSE;
        bool norm = FALSE;

        bool recall = FALSE;

        u16b why = 0;
        u16b *who;


        /* Get a character, or abort */
        if (!get_com("Enter character to be identified: ", &sym)) return;

        /* Find that character info, and describe it */
        for (i = 0; ident_info[i]; ++i)
        {
                if (sym == ident_info[i][0]) break;
        }

        /* Describe */
        if (sym == KTRL('A'))
        {
                all = TRUE;
                my_strcpy(buf, "Full monster list.", sizeof(buf));
        }
        else if (sym == KTRL('U'))
        {
                all = uniq = TRUE;
                my_strcpy(buf, "Unique monster list.", sizeof(buf));
        }
        else if (sym == KTRL('N'))
        {
                all = norm = TRUE;
                my_strcpy(buf, "Non-unique monster list.", sizeof(buf));
        }
        else if (ident_info[i])
        {
                strnfmt(buf, sizeof(buf), "%c - %s.", sym, ident_info[i] + 2);
        }
        else
        {
                strnfmt(buf, sizeof(buf), "%c - %s.", sym, "Unknown Symbol");
        }

        /* Display the result */
        prt(buf, 0, 0);


        /* Allocate the "who" array */
        who = C_ZNEW(z_info->r_max, u16b);

        /* Collect matching monsters */
        for (n = 0, i = 1; i < z_info->r_max - 1; i++)
        {
                monster_race *r_ptr = &r_info[i];
                monster_lore *l_ptr = &l_list[i];

                /* Nothing to recall */
                if (!cheat_know && !l_ptr->sights) continue;

                /* Require non-unique monsters if needed */
                if (norm && (r_ptr->flags[0] & (RF0_UNIQUE))) continue;

                /* Require unique monsters if needed */
                if (uniq && !(r_ptr->flags[0] & (RF0_UNIQUE))) continue;

                /* Collect "appropriate" monsters */
                if (all || (r_ptr->d_char == sym)) who[n++] = i;
        }

        /* Nothing to recall */
        if (!n)
        {
                /* XXX XXX Free the "who" array */
                FREE(who);

                return;
        }

        /* Buttons */
        button_add("[y]", 'y');
        button_add("[k]", 'k');
        /* Don't collide with the repeat button */
        button_add("[n]", 'q'); 
        redraw_stuff();

        /* Prompt */
        put_str("Recall details? (y/k/n): ", 0, 40);

        /* Query */
        query = inkey_ex();

        /* Restore */
        prt(buf, 0, 0);

        /* Buttons */
        button_kill('y');
        button_kill('k');
        button_kill('q');
        redraw_stuff();

        /* Interpret the response */
        if (query.key == 'k')
        {
                /* Sort by kills (and level) */
                why = 4;
        }
        else if (query.key == 'y' || query.key == 'p')
        {
                /* Sort by level; accept 'p' as legacy */
                why = 2;
        }
        else
        {
                /* Any unsupported response is "nope, no history please" */
        
                /* XXX XXX Free the "who" array */
                FREE(who);

                return;
        }


        /* Select the sort method */
        ang_sort_comp = ang_sort_comp_hook;
        ang_sort_swap = ang_sort_swap_hook;

        /* Sort the array */
        ang_sort(who, &why, n);

        /* Start at the end */
        i = n - 1;

        /* Button */
        button_add("[r]", 'r');
        button_add("[-]", '-');