/////////////////////////////////////////////////////////////////////
struct level_pos;
class ShoppingList
{
public:
    ShoppingList();
    bool add_thing(const item_def &item, int cost, level_pos* pos = NULL);
    bool add_thing(std::string desc, std::string buy_verb, int cost,
                   level_pos* pos = NULL);
    bool is_on_list(const item_def &item, level_pos* pos = NULL) const;
    bool is_on_list(std::string desc, level_pos* pos = NULL) const;
    bool del_thing(const item_def &item, level_pos* pos = NULL);
    bool del_thing(std::string desc, level_pos* pos = NULL);
    int size() const;
    void move_things(const coord_def &src, const coord_def &dst);
    void gold_changed(int old_amount, int new_amount);
    void display_list();
    void refresh();
private:
    CrawlVector* list;
    int min_unbuyable_cost;
    int min_unbuyable_idx;
    int max_buyable_cost;
    int max_buyable_idx;
private:
    int find_thing(const item_def &item, const level_pos &pos) const;
    int find_thing(const std::string &desc, const level_pos &pos) const;
    static       bool        thing_is_item(const CrawlHashTable& thing);
    static const item_def&   get_thing_item(const CrawlHashTable& thing);
    static       std::string get_thing_desc(const CrawlHashTable& thing);
    static long      thing_cost(const CrawlHashTable& thing);
    static level_pos thing_pos(const CrawlHashTable& thing);
    static std::string name_thing(const CrawlHashTable& thing);
    static std::string describe_thing(const CrawlHashTable& thing);
};
extern ShoppingList shopping_list;

#include "files.h"

ShoppingList shopping_list;

                            int total_stock)

                            int total_stock, int num_selected,
                            int num_in_list)

    std::string shop_list = "";
    if (!viewing)
    {
        shop_list = "[<w>@</w>] ";
        if (num_selected > 0)
            shop_list += "Selected -> shopping list";
        else if (num_in_list > 0)
            shop_list += "Shopping list -> selected";
        else
            shop_list = "";
    }

            "] exit            [<w>!</w>] %s   %s",

            "] exit            [<w>!</w>] %s   %s%s",

            pkeys.c_str());

            pkeys.c_str(),
            shop_list.c_str());

static int _shop_get_item_value(const item_def& item, int greed, bool id)

static int _shop_get_item_value(const item_def& item, int greed, bool id,
                                bool ignore_bargain = false)

    if (you.duration[DUR_BARGAIN]) // 20% discount

    if (you.duration[DUR_BARGAIN] && !ignore_bargain) // 20% discount

                                      const std::vector<bool>& in_list,

        //  * lightcyan, if on the shopping list.

        if (total_cost > you.gold && selected[i])

        if (in_list[i])
            textcolor(LIGHTCYAN);
        else if (total_cost > you.gold && selected[i])

        if (selected[i])

        if (in_list[i])
            cprintf("%c @ ", c);
        else if (selected[i])

    const bool id_stock = shoptype_identifies_stock(shop.type);

    std::vector<int> stock = _shop_get_stock(shopidx);
    // Autoinscribe randarts in the shop.
    for (unsigned int i = 0; i < stock.size(); i++)
    {
        item_def& item = mitm[stock[i]];
        if (Options.autoinscribe_artefacts && is_artefact(item))
            item.inscription = artefact_auto_inscription(item);
    }
 

    bool bought_something = false;
    bool viewing = false;

    std::vector<bool> in_list;
    const bool id_stock = shoptype_identifies_stock(shop.type);
          bool bought_something = false;
          bool viewing = false;

        StashTrack.get_shop(shop.pos).reset();

        ASSERT(total_cost >= 0);

        std::vector<int> stock = _shop_get_stock(shopidx);

        StashTrack.get_shop(shop.pos).reset();

        // Autoinscribe randarts in the shop.
        for (unsigned int i = 0; i < stock.size(); i++)
        {
            item_def& item = mitm[stock[i]];
            if (Options.autoinscribe_artefacts && is_artefact(item))
                item.inscription = artefact_auto_inscription(item);
        }

        stock = _shop_get_stock(shopidx);

        // Deselect all.

        // Deselect all, recompute what's in the shopping list.

            in_list.resize(stock.size());
            for (unsigned int i = 0; i < stock.size(); i++)
            {
                const item_def& item = mitm[stock[i]];
                in_list[i] = shopping_list.is_on_list(item);
            }

        int num_in_list  = 0;
        int num_selected = 0;
        for (unsigned int i = 0; i < stock.size(); i++)
        {
            if (in_list[i])
                num_in_list++;
            if (selected[i])
                num_selected++;
        }

        const std::string purchasable = _shop_print_stock(stock, selected, shop,

        const std::string purchasable = _shop_print_stock(stock, selected,
                                                          in_list, shop,

        _list_shop_keys(purchasable, viewing, stock.size());

        _list_shop_keys(purchasable, viewing, stock.size(), num_selected,
                        num_in_list);

                            // Remove from shopping list.
                            if (in_list[i])
                                shopping_list.del_thing(item);

        else if (key == '@')
        {
            if (viewing || (num_selected == 0 && num_in_list == 0))
            {
                _shop_print("Huh?", 1);
                _shop_more();
                continue;
            }
            if (num_selected > 0)
            {
                // Move selected to shopping list.
                for (unsigned int i = 0; i < stock.size(); i++)
                {
                    if (selected[i])
                    {
                        in_list[i]  = true;
                        selected[i] = false;
                    }
                }
                total_cost = 0;
            }
            else
            {
                // Move shopping list to selected.
                for (unsigned int i = 0; i < stock.size(); i++)
                {
                    if (in_list[i])
                    {
                        in_list[i]  = false;
                        selected[i] = true;
                        const item_def& item = mitm[stock[i]];
                        total_cost += _shop_get_item_value(item, shop.greed,
                                                           id_stock);
                    }
                }
            }
        }

                if (in_list[key])
                {
                    if (gp_value > you.gold)
                    {
                        _shop_print("Remove from shopping list? (y/N)",
                                    1);
                        if ( yesno(NULL, true, 'n', false, false, true) )
                        {
                            in_list[key]  = false;
                            selected[key] = false;
                        }
                        continue;
                    }
                    else
                    {
                        _shop_print("Remove item from shopping list and buy "
                                    "it? (Y/n)", 1);
                        if ( yesno(NULL, true, 'y', false, false, true) )
                        {
                            in_list[key] = false;
                            // Will be toggled to true later
                            selected[key] = false;
                        }
                        else
                            continue;
                    }
                }
 

                ASSERT(total_cost > 0);
            }
        }
    }
    // Actually change shopping list.
    for (unsigned int i = 0; i < stock.size(); i++)
    {
        const item_def& item = mitm[stock[i]];
        bool on_list = shopping_list.is_on_list(item);
        if (on_list != in_list[i])
        {
            if (in_list[i])
            {
                // Ignore Bargaining.
                const int cost = _shop_get_item_value(item, shop.greed,
                                                      id_stock, false);
                shopping_list.add_thing(item, cost);

            else
                shopping_list.del_thing(item);

    you.gold -= cost;

    you.del_gold(cost);

////////////////////////////////////////////////////////////////////////
// Setup shopping list after restoring savefile.
static void _callback(bool saving)
{
    if (!saving)
        shopping_list.refresh();
}
static SavefileCallback _register_callback(_callback);
// TODO:
//   * Let shopping list be modified from with the stash lister.
//   * Warn if buying something not on the shopping list would put
//     something on shopping list out of your reach.
#define SHOPPING_LIST_KEY       "shopping_list_key"
#define SHOPPING_THING_COST_KEY "cost_key"
#define SHOPPING_THING_ITEM_KEY "item_key"
#define SHOPPING_THING_POS_KEY  "pos_key"
ShoppingList::ShoppingList()
{
}
#define SETUP_POS()                 \
    if (list == NULL) \
    { \
        mpr("SavefileCallback global constructor weirdness!", MSGCH_ERROR); \
        return (false); \
    } \
    level_pos pos;                  \
    if (_pos != NULL)               \
        pos = *_pos;                \
    else                            \
        pos = level_pos::current(); \
    ASSERT(pos.is_valid());
#define SETUP_THING()                             \
    CrawlHashTable *thing = new CrawlHashTable();  \
    (*thing)[SHOPPING_THING_COST_KEY] = (long) cost; \
    (*thing)[SHOPPING_THING_POS_KEY]  = pos;
bool ShoppingList::add_thing(const item_def &item, int cost,
                             level_pos* _pos)
{
    ASSERT(is_valid_item(item));
    ASSERT(cost > 0);
    SETUP_POS();
    if (find_thing(item, pos) != -1)
    {
        mprf(MSGCH_ERROR, "%s is already on the shopping list.",
             item.name(DESC_CAP_THE).c_str());
        return (false);
    }
    SETUP_THING();
    (*thing)[SHOPPING_THING_ITEM_KEY] = item;
    list->push_back(*thing);
    refresh();
    return (true);
}
bool ShoppingList::add_thing(std::string desc, std::string buy_verb, int cost,
                             level_pos* _pos)
{
    ASSERT(false); // Not implemented yet
    SETUP_POS();
    return (false);
}
#undef SETUP_THING
bool ShoppingList::is_on_list(const item_def &item, level_pos* _pos) const
{
    SETUP_POS();
    return (find_thing(item, pos) != -1);
}
bool ShoppingList::is_on_list(std::string desc, level_pos* _pos) const
{
    ASSERT(false); // Not implemented yet
    SETUP_POS();
    return (false);
}
bool ShoppingList::del_thing(const item_def &item, level_pos* _pos)
{
    SETUP_POS();
    int idx = find_thing(item, pos);
    if (idx == -1)
    {
        mprf(MSGCH_ERROR, "%s isn't on shopping list, can't delete it.",
             item.name(DESC_CAP_THE).c_str());
        return (false);
    }
    list->erase(idx);
    refresh();
    return (true);
}
bool ShoppingList::del_thing(std::string desc, level_pos* _pos)
{
    ASSERT(false); // Not implemented yet
    SETUP_POS();
    return (false);
}
#undef SETUP_POS
int ShoppingList::size() const
{
    if (list == NULL)
    {
        mpr("SavefileCallback global constructor weirdness!", MSGCH_ERROR);
        return (0);
    }
    return ( list->size() );
}
void ShoppingList::move_things(const coord_def &src, const coord_def &dst)
{
    ASSERT(false); // Not implemented yet
}
void ShoppingList::gold_changed(int old_amount, int new_amount)
{
    if (list == NULL)
    {
        mpr("SavefileCallback global constructor weirdness!", MSGCH_ERROR);
        return;
    }
    if (new_amount > old_amount && new_amount >= min_unbuyable_cost)
    {
        ASSERT(min_unbuyable_idx < list->size());
        std::vector<std::string> descs;
        for (unsigned int i = min_unbuyable_idx; i < list->size(); i++)
        {
            const CrawlHashTable &thing = (*list)[i];
            const long           cost   = thing_cost(thing);
            if (cost > new_amount)
            {
                ASSERT(i > (unsigned int) min_unbuyable_idx);
                break;
            }
            std::string desc;
            if (thing_is_item(thing))
                desc = "buy ";
            desc += describe_thing(thing);
            descs.push_back(desc);
        }
        ASSERT(!descs.empty());
        mpr_comma_separated_list("You now have enough gold to ", descs,
                                 ", or ");
        // Reset max_buyable and min_unbuyable info
        refresh();
    }
    else if (new_amount < old_amount && new_amount < max_buyable_cost)
    {
        // Reset max_buyable and min_unbuyable info
        refresh();
    }
}
void ShoppingList::display_list()
{
    ASSERT(false); // Not implemented yet
}
bool _compare_shopping_things(const CrawlStoreValue& a,
                              const CrawlStoreValue& b)
{
    const CrawlHashTable& hash_a = a.get_table();
    const CrawlHashTable& hash_b = b.get_table();
    const long a_cost = hash_a[SHOPPING_THING_COST_KEY];
    const long b_cost = hash_b[SHOPPING_THING_COST_KEY];
    return (a_cost < b_cost);
}
void ShoppingList::refresh()
{
    if (!you.props.exists(SHOPPING_LIST_KEY))
        you.props[SHOPPING_LIST_KEY].new_vector(SV_HASH, SFLAG_CONST_TYPE);
    list = &you.props[SHOPPING_LIST_KEY].get_vector();
    std::sort(list->begin(), list->end(), _compare_shopping_things);
    min_unbuyable_cost = INT_MAX;
    min_unbuyable_idx  = -1;
    max_buyable_cost   = -1;
    max_buyable_idx    = -1;
    for (unsigned int i = 0; i < list->size(); i++)
    {
        const CrawlHashTable &thing = (*list)[i];
        const long cost = thing_cost(thing);
        if (cost <= you.gold)
        {
            max_buyable_cost = cost;
            max_buyable_idx  = i;
        }
        else
        {
            min_unbuyable_cost = cost;
            min_unbuyable_idx  = i;
            break;
        }
    }
}
int ShoppingList::find_thing(const item_def &item,
                             const level_pos &pos) const
{
    for (unsigned int i = 0; i < list->size(); i++)
    {
        const CrawlHashTable &thing = (*list)[i];
        const level_pos      _pos    = thing_pos(thing);
        if (pos != _pos)
            continue;
        if (item.name(DESC_NOCAP_A) == name_thing(thing))
            return (i);
    }
    return (-1);
}
int ShoppingList::find_thing(const std::string &desc,
                             const level_pos &pos) const
{
    ASSERT(false); // Not implemented yet
    return (-1);
}
bool ShoppingList::thing_is_item(const CrawlHashTable& thing)
{
    return thing.exists(SHOPPING_THING_ITEM_KEY);
}
const item_def& ShoppingList::get_thing_item(const CrawlHashTable& thing)
{
    ASSERT(thing.exists(SHOPPING_THING_ITEM_KEY));
    const item_def &item = thing[SHOPPING_THING_ITEM_KEY].get_item();
    ASSERT(is_valid_item(item));
    return (item);
}
std::string ShoppingList::get_thing_desc(const CrawlHashTable& thing)
{
    ASSERT(false); // Not implemented yet
    return("");
}
long ShoppingList::thing_cost(const CrawlHashTable& thing)
{
    ASSERT(thing.exists(SHOPPING_THING_COST_KEY));
    return (thing[SHOPPING_THING_COST_KEY].get_long());
}
level_pos ShoppingList::thing_pos(const CrawlHashTable& thing)
{
    ASSERT(thing.exists(SHOPPING_THING_POS_KEY));
    return (thing[SHOPPING_THING_POS_KEY].get_level_pos());
}
std::string ShoppingList::name_thing(const CrawlHashTable& thing)
{
    if (thing_is_item(thing))
    {
        const item_def &item = get_thing_item(thing);
        return item.name(DESC_NOCAP_A);
    }
    else
        ASSERT(false);
    return ("");
}
std::string ShoppingList::describe_thing(const CrawlHashTable& thing)
{
    const level_pos pos = thing_pos(thing);
    std::string desc = name_thing(thing) + " on ";
    if (pos.id == level_id::current())
        desc += "this level";
    else
        desc += pos.id.describe();
    return (desc);
}

        you.gold -= donation_cost;

        you.del_gold(donation_cost);

    bool do_shaft();
    ////////////////////////////////////////////////////////////////

    bool do_shaft();

    void add_gold(int delta);
    void del_gold(int delta);
    void set_gold(int amount);

#include "shopping.h"

}
void player::add_gold(int delta)
{
    set_gold(gold + delta);
}
void player::del_gold(int delta)
{
    add_gold(gold - delta);

void player::set_gold(int amount)
{
    ASSERT(amount >= 0);
    if (amount != gold)
    {
        shopping_list.gold_changed(gold, amount);
        gold = amount;
    }
}

        you.gold = std::max(new_gold, 0);

        you.set_gold( std::max(new_gold, 0) );

        you.gold += quant_got;

        you.add_gold(quant_got);

        you.gold                       -= stolen_amount;

        you.del_gold(stolen_amount);

        you.gold += 1000;

        you.add_gold(1000);