root/trunk/src/squelch.c

/*
 * File: squelch.c
 * Purpose: Item destruction
 *
 * Copyright (c) 2007 David T. Blackston, Iain McFall, DarkGod, Jeff Greene,
 * David Vestal, Pete Mack, Andrew Sidwell.
 *
 * 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"

/*
 * The squelch code has a long history.  Originally it started out as a simple
 * sval-dependent item destroyer, but then ego-item and quality squelch was
 * added too, and then squelched items on the dungeon floor were marked by
 * purple dots, and by this time the code was quite unmaintainable and pretty
 * much impossible to work with.
 *
 * Luckily, though, it's been cleaned up.  Here's a quick overview of the
 * options available now:
 *
 * Squelched items are not automatically destroyed -- they're instead marked
 * "{squelch}", and destroyed with a special command on the "item destruction"
 * screen.  This is much cleaner.
 *
 * There is now only sval-dependent squelch and quality-based squelch, and the
 * two don't interact -- quality-based is for items that get pseudo-id'd and
 * sval-dependent is for potions and the like.
 *
 * The squelch code figures most things out itself.  If you want to make the
 * code see if it should add the squelch flag to an object, simply call
 * squelch_set(o_ptr), and it will do the rest.
 *
 * The quality-dependent squelch is much reduced in scope from how it used to
 * be.  If less "general" settings are desired, they can be added easily enough
 * by changing entries in type_tvals[][], adding more TYPE_* constants, and
 * updating type_names.  Savefile compatibility is automatically ensured.
 *
 *
 * The UI code is much cleaner than it was before, but the interface itself
 * still needs some design.  XXX
 */


/*
 * List of kinds of item, for pseudo-id squelch.
 */
enum
{
        TYPE_WEAPON,
        TYPE_SHOOTER,
        TYPE_MISSILE,
        TYPE_ARMOR,
        TYPE_JEWELRY,
        TYPE_DIGGER,

        TYPE_MAX
};

/*
 * Names of categories.
 */
static const char *type_names[TYPE_MAX] =
{
        "Melee weapons",
        "Missile weapons",
        "Ammunition",
        "Armor",
        "Jewelry",
        "Diggers",
};

/* Mapping of tval -> type */
static int type_tvals[][2] =
{
        { TYPE_WEAPON,  TV_SWORD },
        { TYPE_WEAPON,  TV_POLEARM },
        { TYPE_WEAPON,  TV_HAFTED },
        { TYPE_SHOOTER, TV_BOW },
        { TYPE_MISSILE, TV_ARROW },
        { TYPE_MISSILE, TV_BOLT },
        { TYPE_MISSILE, TV_SHOT },
        { TYPE_ARMOR,   TV_SHIELD },
        { TYPE_ARMOR,   TV_HELM },
        { TYPE_ARMOR,   TV_GLOVES },
        { TYPE_ARMOR,   TV_BOOTS },
        { TYPE_ARMOR,   TV_DRAG_ARMOR },
        { TYPE_ARMOR,   TV_HARD_ARMOR },
        { TYPE_ARMOR,   TV_SOFT_ARMOR },
        { TYPE_ARMOR,   TV_CLOAK },
        { TYPE_ARMOR,   TV_CROWN },
        { TYPE_JEWELRY, TV_RING },
        { TYPE_JEWELRY, TV_AMULET },
        { TYPE_DIGGER,  TV_DIGGING },
};

byte squelch_level[TYPE_MAX];
size_t squelch_size = TYPE_MAX;


/*
 * The different kinds of quality squelch
 */
enum
{
        SQUELCH_NONE,
        SQUELCH_CURSED,
        SQUELCH_AVERAGE,
        SQUELCH_GOOD_STRONG,
        SQUELCH_GOOD_WEAK,
        SQUELCH_ALL,

        SQUELCH_MAX
};

/*
 * The names for the various kinds of quality
 */
static const char *quality_names[SQUELCH_MAX] =
{
        "none",                                                 /* SQUELCH_NONE */
        "cursed",                                               /* SQUELCH_CURSED */
        "average",                                              /* SQUELCH_AVERAGE */
        "good (strong pseudo-ID)",              /* SQUELCH_GOOD_STRONG */
        "good (weak pseudo-ID)",                /* SQUELCH_GOOD_WEAK */
        "everything except artifacts",  /* SQUELCH_ALL */
};


/* Structure to describe tval/description pairings. */
typedef struct
{
        int tval;
        const char *desc;
} tval_desc;

/* Categories for sval-dependent squelch. */
static tval_desc sval_dependent[] =
{
        { TV_STAFF,             "Staffs" },
        { TV_WAND,              "Wands" },
        { TV_ROD,               "Rods" },
        { TV_SCROLL,    "Scrolls" },
        { TV_POTION,    "Potions" },
        { TV_RING,              "Rings" },
        { TV_AMULET,    "Amulets" },
        { TV_FOOD,              "Food" }
};


/*** Autoinscription stuff ***/

/*
 * This code needs documenting.
 */
int get_autoinscription_index(s16b k_idx)
{
        int i;

        for (i = 0; i < inscriptions_count; i++)
        {
                if (k_idx == inscriptions[i].kind_idx)
                        return i;
        }

        return -1;
}

/*
 * DOCUMENT ME!
 */
static cptr get_autoinscription(s16b kind_idx)
{
        int i;

        for (i = 0; i < inscriptions_count; i++)
        {
                if (kind_idx == inscriptions[i].kind_idx)
                        return quark_str(inscriptions[i].inscription_idx);
        }

        return 0;
}

/* Put the autoinscription on an object */
int apply_autoinscription(object_type *o_ptr)
{
        char o_name[80];
        cptr note = get_autoinscription(o_ptr->k_idx);
        cptr existing_inscription = quark_str(o_ptr->note);

        /* Don't inscribe unaware objects */
        if (!note || !object_aware_p(o_ptr))
                return 0;

        /* Don't re-inscribe if it's already correctly inscribed */
        if (existing_inscription && streq(note, existing_inscription))
                return 0;

        /* Get an object description */
        object_desc(o_name, sizeof(o_name), o_ptr, TRUE, 3);

        if (note[0] != 0)
                o_ptr->note = quark_add(note);
        else
                o_ptr->note = 0;

        msg_format("You autoinscribe %s.", o_name);

        return 1;
}


int remove_autoinscription(s16b kind)
{
        int i = get_autoinscription_index(kind);

        /* It's not here. */
        if (i == -1) return 0;

        while (i < inscriptions_count - 1)
        {
                inscriptions[i] = inscriptions[i+1];
                i++;
        }

        inscriptions_count--;

        return 1;
}


int add_autoinscription(s16b kind, cptr inscription)
{
        int index;

        /* Paranoia */
        if (kind == 0) return 0;

        /* If there's no inscription, remove it */
        if (!inscription || (inscription[0] == 0))
                return remove_autoinscription(kind);

        index = get_autoinscription_index(kind);

        if (index == -1)
                index = inscriptions_count;

        if (index >= AUTOINSCRIPTIONS_MAX)
        {
                msg_format("This inscription (%s) cannot be added because the inscription array is full!", inscription);
                return 0;
        }

        inscriptions[index].kind_idx = kind;
        inscriptions[index].inscription_idx = quark_add(inscription);

        /* Only increment count if inscription added to end of array */
        if (index == inscriptions_count)
                inscriptions_count++;

        return 1;
}


void autoinscribe_ground(void)
{
        int py = p_ptr->py;
        int px = p_ptr->px;
        s16b this_o_idx, next_o_idx = 0;

        /* Scan the pile of objects */
        for (this_o_idx = cave_o_idx[py][px]; this_o_idx; this_o_idx = next_o_idx)
        {
                /* Get the next object */
                next_o_idx = o_list[this_o_idx].next_o_idx;

                /* Apply an autoinscription */
                apply_autoinscription(&o_list[this_o_idx]);
        }
}

void autoinscribe_pack(void)
{
        int i;

        /* Cycle through the inventory */
        for (i = INVEN_PACK; i > 0; i--)
        {
                /* Skip empty items */
                if (!inventory[i].k_idx) continue;

                /* Apply the inscription */
                apply_autoinscription(&inventory[i]);
        }

        return;
}




/*** Squelch code ***/

/*
 * Determines if an object is eligable for squelching.
 */
static bool squelch_item_ok(object_type *o_ptr)
{
        size_t i;
        int num = -1;

        bool fullid = object_aware_p(o_ptr);
        bool sensed = (o_ptr->ident & IDENT_SENSE) || fullid;
        byte feel   = fullid ? value_check_aux1(o_ptr) : o_ptr->pseudo;


        /* Don't squelch artifacts */
        if (artifact_p(o_ptr)) return FALSE;

        /* Don't check things that aren't known at all */
        if (!sensed) return FALSE;


        /* Auto-squelch junk items */
        if (object_value(o_ptr) == 0) return TRUE;

        /* Auto-squelch dead chests */
        if (o_ptr->tval == TV_CHEST && o_ptr->pval == 0)
                return TRUE;


        /* Find the appropriate squelch group */
        for (i = 0; i < N_ELEMENTS(type_tvals); i++)
        {
                if (type_tvals[i][1] == o_ptr->tval)
                        num = type_tvals[i][0];
        }

        /* Never squelched */
        if (num == -1)
                return FALSE;


        /* Get result based on the feeling and the squelch_level */
        switch (squelch_level[num])
        {
                case SQUELCH_CURSED:
                {
                        if ((feel == INSCRIP_BROKEN) || (feel == INSCRIP_TERRIBLE) ||
                            (feel == INSCRIP_WORTHLESS) || (feel == INSCRIP_CURSED))
                        {
                                return TRUE;
                        }

                break;
                }

                case SQUELCH_AVERAGE:
                {
                        if ((feel == INSCRIP_BROKEN) || (feel == INSCRIP_TERRIBLE) ||
                            (feel == INSCRIP_WORTHLESS) || (feel == INSCRIP_CURSED) ||
                            (feel == INSCRIP_AVERAGE))
                        {
                                return TRUE;
                        }

                break;
                }

                case SQUELCH_GOOD_WEAK:
                {
                        if ((feel == INSCRIP_BROKEN) || (feel == INSCRIP_TERRIBLE) ||
                            (feel == INSCRIP_WORTHLESS) || (feel == INSCRIP_CURSED) ||
                            (feel == INSCRIP_AVERAGE) || (feel == INSCRIP_GOOD))
                        {
                                return TRUE;
                        }

                        break;
                }

                case SQUELCH_GOOD_STRONG:
                {
                        if ((feel == INSCRIP_BROKEN) || (feel == INSCRIP_TERRIBLE) ||
                            (feel == INSCRIP_WORTHLESS) || (feel == INSCRIP_CURSED) ||
                            (feel == INSCRIP_AVERAGE) ||
                            ((feel == INSCRIP_GOOD) &&
                             ((fullid) || (cp_ptr->flags & CF_PSEUDO_ID_HEAVY))))
                        {
                                return TRUE;
                        }

                        break;
                }

                case SQUELCH_ALL:
                {
                        return TRUE;
                break;
                }
        }

        /* Failure */
        return FALSE;
}


/*
 * Set squelch inscription on an object.
 */
void squelch_set(object_type *o_ptr)
{
        bool can_squelch;

        /* Check if we can squelch */
        can_squelch = squelch_item_ok(o_ptr);

        /* Set squelch inscription unless there's already one */
        if (!o_ptr->note && can_squelch)
                o_ptr->note = quark_add("squelch");


        /* Done */
        return;
}


/*
 * An item_tester_hook for squelched items.
 */
static bool item_tester_squelched(const object_type *o_ptr)
{
        const char *inscrip = (o_ptr->note ? quark_str(o_ptr->note) : NULL);

        /* Check for inscription */
        if (!o_ptr->note) return FALSE;

        /* Find "squelch" */
        if (inscrip && streq(inscrip, "squelch")) return TRUE;

        /* Nope */
        return FALSE;
}


/*
 * Destroy all {squelch}able items.
 *
 * Imported, with thanks, from Ey... much cleaner than the original.
 */
void squelch_items(void)
{
        int floor_list[MAX_FLOOR_STACK];
        int floor_num, n;
        int count = 0;

        object_type *o_ptr;

        /* Set the hook and scan the floor */
        item_tester_hook = item_tester_squelched;
        (void)scan_floor(floor_list, &floor_num, p_ptr->py, p_ptr->px, 0x01);

        if (floor_num)
        {
                for (n = 0; n < floor_num; n++)
                {
                        o_ptr = &o_list[floor_list[n]];

                        /* Avoid artifacts */
                        if (artifact_p(o_ptr)) continue;

                        if (item_tester_okay(o_ptr))
                        {
                                /* Destroy item */
                                floor_item_increase(floor_list[n], -o_ptr->number);
                                floor_item_optimize(floor_list[n]);
                                count++;
                        }
                }
        }

        /* Scan through the slots backwards */
        for (n = INVEN_PACK - 1; n >= 0; n--)
        {
                o_ptr = &inventory[n];

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

                if (item_tester_okay(o_ptr))
                {
                        /* Destroy item */
                        inven_item_increase(n, -o_ptr->number);
                        inven_item_optimize(n);
                        count++;
                }
        }

        item_tester_hook = NULL;

        /* Mention casualties */
        if (count > 0)
        {
                message_format(MSG_DESTROY, 0, "%d item%s squelched.",
                               count, ((count > 1) ? "s" : ""));

                /* Combine/reorder the pack */
                p_ptr->notice |= (PN_COMBINE | PN_REORDER);
        }
        else
        {
                message(MSG_GENERIC, 0, "No squelched items to destroy.");
        }

        /* Happy now I've sold my soul */
        return;
}





/*** UI stuff ***/

/*
 * This is much simpler than it used to be.
 */


/*** Quality-squelch menu ***/

/*
 * Display an entry in the menu.
 */
static void quality_display(menu_type *menu, int oid, bool cursor, int row, int col, int width)
{
        const char *name = type_names[oid];

        byte level = squelch_level[oid];
        const char *level_name = quality_names[level];

        byte attr = (cursor ? TERM_L_BLUE : TERM_WHITE);


        c_put_str(attr, format("%-20s : %s", name, level_name), row, col);
}


/*
 * Display the quality squelch subtypes.
 */
static void quality_subdisplay(menu_type *menu, int oid, bool cursor, int row, int col, int width)
{
        const char *name = quality_names[oid];
        byte attr = (cursor ? TERM_L_BLUE : TERM_WHITE);

        c_put_str(attr, name, row, col);
}

/*
 * Handle "Enter".  :(
 */
static bool quality_subaction(char cmd, void *db, int oid)
{
        return TRUE;
}


/*
 * Handle keypresses.
 */
static bool quality_action(char cmd, void *db, int oid)
{
        menu_type menu;
        menu_iter menu_f = { 0, 0, 0, quality_subdisplay, quality_subaction };
        region area = { 24, 5, 26, SQUELCH_MAX };
        event_type evt;
        int cursor;

        /* Display at the right point */
        area.row += oid;
        cursor = squelch_level[oid];

        /* Save */
        screen_save();

        /* Run menu */
        WIPE(&menu, menu);
        menu.cmd_keys = "\n\r";
        menu.count = SQUELCH_MAX;
        if (oid == TYPE_JEWELRY)
                menu.count = area.page_rows = SQUELCH_CURSED + 1;

        menu_init2(&menu, find_menu_skin(MN_SCROLL), &menu_f, &area);
        window_make(area.col - 2, area.row - 1, area.col + area.width + 2, area.row + area.page_rows);

        evt = menu_select(&menu, &cursor, 0);

        /* Set the new value appropriately */
        if (evt.key != ESCAPE && evt.type != EVT_BACK)
                squelch_level[oid] = cursor;

        /* Load and finish */
        screen_load();
        return TRUE;
}

/*
 * Display quality squelch menu.
 */
static void quality_menu(void)
{
        menu_type menu;
        menu_iter menu_f = { 0, 0, 0, quality_display, quality_action };
        region area = { 1, 5, -1, -1 };
        event_type evt;
        int cursor = 0;

        /* Save screen */
        screen_save();
        clear_from(0);

        /* Help text */
        prt("Quality squelch menu", 0, 0);

        Term_gotoxy(1, 1);
        text_out_to_screen(TERM_L_RED, "Use the movement keys to navigate, and Enter to change settings.");

        /* Set up the menu */
        WIPE(&menu, menu);
        menu.cmd_keys = " \n\r";
        menu.count = TYPE_MAX;
        menu_init2(&menu, find_menu_skin(MN_SCROLL), &menu_f, &area);

        /* Select an entry */
        while (evt.key != ESCAPE && evt.type != EVT_BACK)
                evt = menu_select(&menu, &cursor, 0);

        /* Load screen */
        screen_load();
        return;
}



/*** Sval-dependent menu ***/

/*
 * Display an entry on the sval menu
 */
static void sval_display(menu_type *menu, int oid, bool cursor, int row, int col, int width)
{
        char buf[80];
        const char *inscrip;
        const u16b *choice = menu->menu_data;
        int idx = choice[oid];

        byte attr = (cursor ? TERM_L_BLUE : TERM_WHITE);


        /* Acquire the "name" of object "i" */
        strip_name(buf, idx, TRUE);

        /* Print it */
        c_put_str(attr, format("[ ] %s", buf), row, col);
        if (k_info[idx].squelch)
                c_put_str(TERM_L_RED, "*", row, col + 1);

        inscrip = get_autoinscription(choice[oid]);
        if (!inscrip) inscrip = "(none)";

        c_put_str(attr, format("%-40s", inscrip), row, col + 40);
}

/*
 * Deal with events on the sval menu
 */
static bool sval_action(char cmd, void *db, int oid)
{
        char buf[80] = "";
        u16b *choice = db;

        /* Toggle */
        if (cmd == ' ')
        {
                int idx = choice[oid];
                k_info[idx].squelch = !k_info[idx].squelch;

                return TRUE;
        }

        /* Set inscription */
        else if (cmd == '\n' || cmd == '\r')
        {
                s16b k_idx = choice[oid];
                const char *inscrip;

                /* Obtain the current inscription */
                inscrip = get_autoinscription(k_idx);   

                /* Copy of the current inscription, or clear the buffer */
                if (inscrip)
                        my_strcpy(buf, inscrip, sizeof(buf));

                /* Get a new inscription (possibly empty) */
                if (get_string("Autoinscription: ", buf, sizeof(buf)))
                {
                        /* Save the inscription */
                        add_autoinscription(k_idx, buf);

                        /* Notice stuff (later) */
                        p_ptr->notice |= (PN_AUTOINSCRIBE);
                        p_ptr->window |= (PW_INVEN | PW_EQUIP);
                }

                return TRUE;
        }

        return FALSE;
}

/*
 * Display list of svals to be squelched.
 */
static bool sval_menu(int tval, const char *desc)
{
        menu_type menu;
        menu_iter menu_f = { 0, 0, 0, sval_display, sval_action };
        region area = { 1, 5, -1, -1 };
        event_type evt = { EVT_NONE, 0, 0, 0, 0 };
        int cursor = 0;

        int num = 0;
        size_t i;

        u16b *choice;


        /* Create the array */
        C_MAKE(choice, z_info->k_max, u16b);

        /* Iterate over all possible object kinds, finding ones which can be squelched */
        for (i = 1; i < z_info->k_max; i++)
        {
                object_kind *k_ptr = &k_info[i];

                /* Skip empty objects, unseen objects, and incorrect tvals */
                if (!k_ptr->name) continue;
                if (!k_ptr->everseen) continue;
                if (k_ptr->tval != tval) continue;

                /* Add this item to our possibles list */
                choice[num++] = i;
        }

        /* Return here if there are no objects */
        if (!num)
        {
                FREE(choice);
                return FALSE;
        }


        /* Save the screen and clear it */
        screen_save();
        clear_from(0);

        /* Help text */

        /* Output to the screen */
        text_out_hook = text_out_to_screen;

        /* Indent output */
        text_out_indent = 1;
        text_out_wrap = 79;
        Term_gotoxy(1, 0);

        /* Display some helpful information */
        text_out("Use the ");
        text_out_c(TERM_L_GREEN, "movement keys");
        text_out(" to scroll the list or ");
        text_out_c(TERM_L_GREEN, "ESC");
        text_out(" to return to the previous menu.  ");
        text_out_c(TERM_L_BLUE, "Space");
        text_out(" toggles the current setting, and ");
        text_out_c(TERM_L_GREEN, "Enter");
        text_out(" will prompt you for a new autoinscription.");

        /* Set up the menu */
        WIPE(&menu, menu);
        menu.cmd_keys = " \n\r";
        menu.count = num;
        menu.menu_data = choice;
        menu_init2(&menu, find_menu_skin(MN_SCROLL), &menu_f, &area);

        /* Select an entry */
        while (evt.key != ESCAPE && evt.type != EVT_BACK)
                evt = menu_select(&menu, &cursor, 0);

        /* Free memory */
        FREE(choice);

        /* Load screen */
        screen_load();
        return TRUE;
}



/*
 * Display and handle the main squelching menu.
 */
void do_cmd_options_item(void)
{
        bool done = FALSE;
        bool no_known = FALSE;
        size_t i;

        /* Save and clear screen */
        screen_save();
        clear_from(0);


        /* Header */
        prt("Item handling menu", 0, 0);

        /* Print all typevals and their descriptions */
        for (i = 0; i < N_ELEMENTS(sval_dependent); i++)
                prt(format("%c) %s", I2A(i), sval_dependent[i].desc), i + 3, 1);

        prt("Q) Quality squelching options", i + 4, 1);
        prt("ESC) Back to options menu.", i + 6, 1);

        while (!done)
        {
                char ch;

                if (no_known)
                {
                        prt("You've not seen any object of that type yet.", 1, 0);
                        no_known = FALSE;
                }
                else
                {
                        prt("", 1, 0);
                }

                /* Prompt */
                ch = inkey();

                /* Choose! */
                if (ch == 'Q') quality_menu();         /* Switch to secondary squelching menu */
                else if (ch == ESCAPE) done = TRUE;         /* Finished */

                else
                {
                        /* Analyze choice */
                        int choice = A2I(ch);

                        /* Ignore illegal choice */
                        if (choice < 0 || choice >= (int)N_ELEMENTS(sval_dependent)) continue;

                        if (!sval_menu(sval_dependent[choice].tval, sval_dependent[choice].desc))
                                no_known = TRUE;
                }
        }

        /* Load screen and finish */
        screen_load();
        return;
}