// NOTE: All operators will assert if the alue is of the wrong

    // NOTE: All operators will assert if the value is of the wrong

    // rather than replacing it (i.e., ++) the value will be set to a

    // rather than replacing it (e.g., ++) the value will be set to a

// created it's type (or lack of type) is immutable.

// created its type (or lack of type) is immutable.

    // NOTE: If the const versions of get_value() or [] are given a
    // key which doesn't exist, they will assert.
    const CrawlStoreValue& get_value(const std::string &key) const;
    const CrawlStoreValue& operator[] (const std::string &key) const;

    // NOTE: If the const versions of get_value() or [] are given a
    // key which doesn't exist, they will assert.
    const CrawlStoreValue& get_value(const std::string &key) const;
    const CrawlStoreValue& operator[] (const std::string &key) const;

    iterator  begin();
    iterator  end();

    iterator  begin();
    iterator  end();

    CrawlStoreValue& get_value(const vec_size &index);
    CrawlStoreValue& operator[] (const vec_size &index);

    CrawlStoreValue& get_value(const vec_size &index);
    CrawlStoreValue& operator[] (const vec_size &index);

    // than by reference so that coversion constructors will work.

    // than by reference so that conversion constructors will work.

    const_iterator begin() const;
    const_iterator end() const;

    const_iterator begin() const;
    const_iterator end() const;

    CrawlHashTable* get_table();
    T& operator[] (const std::string &key);

    CrawlHashTable* get_table();
    T& operator[] (const std::string &key);

// The mehtod is called to prevent the "no repeating zero turns
// commands" message that input() generates (in the abscence of

// The method is called to prevent the "no repeating zero turns
// commands" message that input() generates (in the absence of

#endif
static void give_nemelex_gift()
{
    if (random2(MAX_PIETY) <= you.piety
        && one_chance_in(3)
        && !you.attribute[ATTR_CARD_COUNTDOWN]
        && !grid_destroys_items(grd[you.x_pos][you.y_pos]))
    {
        misc_item_type gift_type;
        if ( random2(MAX_PIETY) <= you.piety )
        {
            // make a pure deck
            const misc_item_type pure_decks[] = {
                MISC_DECK_OF_ESCAPE,
                MISC_DECK_OF_DESTRUCTION,
                MISC_DECK_OF_DUNGEONS,
                MISC_DECK_OF_SUMMONING,
                MISC_DECK_OF_WONDERS
            };
            int weights[5];
            get_pure_deck_weights(weights);
            gift_type = pure_decks[choose_random_weighted(weights, weights+5)];
#if DEBUG_GIFTS || DEBUG_CARDS
            show_pure_deck_chances();

        }
        else
        {
            // make a mixed deck
            const misc_item_type mixed_decks[] = {
                MISC_DECK_OF_WAR,
                MISC_DECK_OF_CHANGES,
                MISC_DECK_OF_DEFENSE
            };
            gift_type = RANDOM_ELEMENT(mixed_decks);
        }
        int thing_created = items( 1, OBJ_MISCELLANY, gift_type, 
                                   true, 1, MAKE_ITEM_RANDOM_RACE );
        if (thing_created != NON_ITEM)
        {
            // Piety|Common  | Rare  |Legendary
            // --------------------------------
            //     0:  95.00%,  5.00%,  0.00%
            //    20:  86.00%, 10.50%,  3.50%
            //    40:  77.00%, 16.00%,  7.00%
            //    60:  68.00%, 21.50%, 10.50%
            //    80:  59.00%, 27.00%, 14.00%
            //   100:  50.00%, 32.50%, 17.50%
            //   120:  41.00%, 38.00%, 21.00%
            //   140:  32.00%, 43.50%, 24.50%
            //   160:  23.00%, 49.00%, 28.00%
            //   180:  14.00%, 54.50%, 31.50%
            //   200:   5.00%, 60.00%, 35.00%
            int common_weight = 95 - (90 * you.piety / MAX_PIETY);
            int rare_weight   = 5  + (55 * you.piety / MAX_PIETY);
            int legend_weight = 0  + (35 * you.piety / MAX_PIETY);
            deck_rarity_type rarity = static_cast<deck_rarity_type>(
                random_choose_weighted(common_weight,
                                       DECK_RARITY_COMMON,
                                       rare_weight,
                                       DECK_RARITY_RARE,
                                       legend_weight,
                                       DECK_RARITY_LEGENDARY,
                                       0));
            item_def &deck(mitm[thing_created]);
            deck.special = rarity;
            deck.colour  = deck_rarity_to_color(rarity);
            move_item_to_grid( &thing_created, you.x_pos, you.y_pos );
            origin_acquired(deck, you.religion);
                    
            simple_god_message(" grants you a gift!");
            more();
            canned_msg(MSG_SOMETHING_APPEARS);
            you.attribute[ATTR_CARD_COUNTDOWN] = 10;
            inc_gift_timeout(5 + random2avg(9, 2));
            you.num_gifts[you.religion]++;
            take_note(Note(NOTE_GOD_GIFT, you.religion));
        }
    }
}

            if (random2(MAX_PIETY) <= you.piety
                && one_chance_in(3)
                && !you.attribute[ATTR_CARD_COUNTDOWN]
                && !grid_destroys_items(grd[you.x_pos][you.y_pos]))
            {
                misc_item_type gift_type;
                if ( random2(MAX_PIETY) <= you.piety )
                {
                    // make a pure deck
                    const misc_item_type pure_decks[] = {
                        MISC_DECK_OF_ESCAPE,
                        MISC_DECK_OF_DESTRUCTION,
                        MISC_DECK_OF_DUNGEONS,
                        MISC_DECK_OF_SUMMONING,
                        MISC_DECK_OF_WONDERS
                    };
                    int weights[5];
                    get_pure_deck_weights(weights);
                    gift_type = pure_decks[choose_random_weighted(weights,
                                                                  weights+5)];
#if DEBUG_GIFTS || DEBUG_CARDS
                    show_pure_deck_chances();
#endif
                }
                else
                {
                    // make a mixed deck
                    const misc_item_type mixed_decks[] = {
                        MISC_DECK_OF_WAR,
                        MISC_DECK_OF_CHANGES,
                        MISC_DECK_OF_DEFENSE
                    };
                    gift_type = RANDOM_ELEMENT(mixed_decks);
                }
                int thing_created = items( 1, OBJ_MISCELLANY, gift_type, 
                                           true, 1, MAKE_ITEM_RANDOM_RACE );
                if (thing_created != NON_ITEM)
                {
                    // Piety|Common  | Rare  |Legendary
                    // --------------------------------
                    //     0:  95.00%,  5.00%,  0.00%
                    //    20:  86.00%, 10.50%,  3.50%
                    //    40:  77.00%, 16.00%,  7.00%
                    //    60:  68.00%, 21.50%, 10.50%
                    //    80:  59.00%, 27.00%, 14.00%
                    //   100:  50.00%, 32.50%, 17.50%
                    //   120:  41.00%, 38.00%, 21.00%
                    //   140:  32.00%, 43.50%, 24.50%
                    //   160:  23.00%, 49.00%, 28.00%
                    //   180:  14.00%, 54.50%, 31.50%
                    //   200:   5.00%, 60.00%, 35.00%
                    int common_weight = 95 - (90 * you.piety / MAX_PIETY);
                    int rare_weight   = 5  + (55 * you.piety / MAX_PIETY);
                    int legend_weight = 0  + (35 * you.piety / MAX_PIETY);
                    deck_rarity_type rarity = (deck_rarity_type)
                        random_choose_weighted(common_weight,
                                               DECK_RARITY_COMMON,
                                               rare_weight,
                                               DECK_RARITY_RARE,
                                               legend_weight,
                                               DECK_RARITY_LEGENDARY,
                                               0);
                    item_def &deck(mitm[thing_created]);
                    deck.special = rarity;
                    deck.colour  = deck_rarity_to_color(rarity);
                    move_item_to_grid( &thing_created, you.x_pos, you.y_pos );
                    origin_acquired(deck, you.religion);
                    
                    simple_god_message(" grants you a gift!");
                    more();
                    canned_msg(MSG_SOMETHING_APPEARS);
                    you.attribute[ATTR_CARD_COUNTDOWN] = 10;
                    inc_gift_timeout(5 + random2avg(9, 2));
                    you.num_gifts[you.religion]++;
                    take_note(Note(NOTE_GOD_GIFT, you.religion));
                }
            }

            give_nemelex_gift();

// for a maximum of 256 differetn kinds of cards and 8 bits of flags.

// for a maximum of 256 different kinds of cards and 8 bits of flags.

    return (unsigned long) props["cards"].get_vector().size();

    return static_cast<unsigned long>(props["cards"].get_vector().size());

    std::ostream& strm = msg::streams(MSGCH_DIAGNOSTICS);

        mpr("This isn't a deck at all!");

        strm << "This isn't a deck at all!" << std::endl;

            msg::stream << "Seems this deck never had any cards in the "
                "first place!";

            strm << "Seems this deck never had any cards in the first place!";

            msg::stream << "'cards' property isn't a vector.";

            strm << "'cards' property isn't a vector.";

                msg::stream << "'cards' vector doesn't contain bytes.  ";

                strm << "'cards' vector doesn't contain bytes.";

                msg::stream << "Strange, this deck is already empty.";

                strm << "Strange, this deck is already empty.";

                    msg::stream << "  But there should be been ";
                    msg::stream <<  cards_left;
                    msg::stream << " cards left.";

                    strm << " But there should be been " <<  cards_left
                         << " cards left.";

        msg::stream << std::endl;

        strm << std::endl
             << "A swarm of software bugs snatches the deck from you "
            "and whisks it away."
             << std::endl;

        mpr("A swarm of software bugs snatches the deck from you and "
            "whisk it away.");

        mprf("%d buggy cards found in the deck, discarding them.",
             num_buggy);

        strm << num_buggy << " buggy cards found in the deck, discarding them."
             << std::endl;

    if (num_cards <= 0)

    if (num_cards == 0)

        mpr("Oops, all of the cards seem to be gone.");
        mpr("A swarm of software bugs snatches the deck from you and "
            "whisk it away.");

        strm << "Oops, all of the cards seem to be gone." << std::endl
             << "A swarm of software bugs snatches the deck from you "
            "and whisks it away." << std::endl;

    if ((long) num_cards > deck.plus)

    if (static_cast<long>(num_cards) > deck.plus)

            mpr("Deck was created with zero cards???");

            strm << "Deck was created with zero cards???" << std::endl;

            mpr("Deck was created with *negative* cards?!");

            strm << "Deck was created with *negative* cards?!" << std::endl;

            mpr("Deck has more cards than it was created with?");

            strm << "Deck has more cards than it was created with?"
                 << std::endl;

        mprf("%d more cards than flags.", num_cards - num_flags);

        strm << (num_cards - num_flags) << " more cards than flags.";

        mpr("More cards than flags.");

        strm << "More cards than flags.";

        strm << std::endl;

            flags[i] = (char) 0;

            flags[i] = static_cast<char>(0);

        mprf("%d more flags than cards.", num_flags - num_cards);

        strm << (num_cards - num_flags) << " more cards than flags.";

        mpr("More flags than cards.");

        strm << "More cards than flags.";

        strm << std::endl;

    if (props["num_marked"].get_byte() > (char) num_cards)

    if (props["num_marked"].get_byte() > static_cast<char>(num_cards))

        mpr("More cards marked than in the deck?");
        props["num_marked"] = (char) num_marked;

        strm << "More cards marked than in the deck?" << std::endl;
        props["num_marked"] = static_cast<char>(num_marked);

    else if (props["num_marked"].get_byte() != (char) num_marked)

    else if (props["num_marked"].get_byte() != static_cast<char>(num_marked))

        mprf("Oops, counted %d marked cards, but num_marked is %d.",
             (int) num_marked, (int) props["num_marked"].get_byte());

        strm << "Oops, counted " << static_cast<int>(num_marked)
             << " marked cards, but num_marked is "
             << (static_cast<int>(props["num_marked"].get_byte()));        

        mpr("Oops, book-keeping on marked cards is wrong.");

        strm << "Oops, book-keeping on marked cards is wrong.";

        props["num_marked"] = (char) num_marked;

        strm << std::endl;
        props["num_marked"] = static_cast<char>(num_marked);

        if (deck.plus != (deck.plus2 + (long) num_cards))

        if (deck.plus != (deck.plus2 + static_cast<long>(num_cards)))

            mprf("Have you used %d cards, or %d?  Oops.",
                 deck.plus2, deck.plus - num_cards);

            strm << "Have you used " << deck.plus2 << " cards, or "
                 << (deck.plus - num_cards) << "? Oops.";

            mpr("Oops, book-keeping on used cards is wrong.");

            strm << "Oops, book-keeping on used cards is wrong.";

            strm << std::endl;

        if (-deck.plus2 != (long) num_cards)

        if (-deck.plus2 != static_cast<long>(num_cards))

            mprf("There are %d cards left, not %d.  Oops.",
                 num_cards, -deck.plus2);

            strm << "There are " << num_cards << " cards left, not "
                 << (-deck.plus2) << ".  Oops.";

            mpr("Oops, book-keeping on cards left is wrong.");

            strm << "Oops, book-keeping on cards left is wrong.";

            strm << std::endl;

        // "Shuffle" the two cards (even if they're teh same, since

        // "Shuffle" the two cards (even if they're the same, since

// know whate order they're in, and the if the top card is non-marked

// know what order they're in, and the if the top card is non-marked

    you.redraw_hit_points = 1;
    you.redraw_magic_points = 1;

    you.redraw_hit_points = true;
    you.redraw_magic_points = true;

                cause = "the 'helpfullness' of ";

                cause = "the 'helpfulness' of ";

    else
        mpr("You feel transcendent for a moment.");

    switch(rarity)

    switch (rarity)

        if (coinflip())
            return (MAGENTA);
        else
            return (BROWN);

        return (coinflip() ? MAGENTA : BROWN);