Revert "Track who destroys an item; incur Nemelex penance for deck destruction."
[crawl.git] / crawl-ref / source / items.cc
1 /**
2  * @file
3  * @brief Misc (mostly) inventory related functions.
4 **/
5
6 #include "AppHdr.h"
7
8 #include "items.h"
9 #include "bitary.h"
10 #include "cio.h"
11 #include "clua.h"
12
13 #include <string.h>
14 #include <stdlib.h>
15 #include <stdio.h>
16 #include <ctype.h>
17
18 #include "externs.h"
19
20 #include "arena.h"
21 #include "art-enum.h"
22 #include "artefact.h"
23 #include "beam.h"
24 #include "coord.h"
25 #include "coordit.h"
26 #include "dactions.h"
27 #include "describe.h"
28 #include "dbg-util.h"
29 #include "decks.h"
30 #include "delay.h"
31 #include "dgnevent.h"
32 #include "directn.h"
33 #include "dungeon.h"
34 #include "effects.h"
35 #include "env.h"
36 #include "evoke.h"
37 #include "food.h"
38 #include "godpassive.h"
39 #include "godprayer.h"
40 #include "hints.h"
41 #include "hiscores.h"
42 #include "invent.h"
43 #include "item_use.h"
44 #include "itemname.h"
45 #include "itemprop.h"
46 #include "libutil.h"
47 #include "makeitem.h"
48 #include "message.h"
49 #include "misc.h"
50 #include "notes.h"
51 #include "options.h"
52 #include "orb.h"
53 #include "place.h"
54 #include "player.h"
55 #include "player-equip.h"
56 #include "quiver.h"
57 #include "religion.h"
58 #include "shopping.h"
59 #include "showsymb.h"
60 #include "spl-book.h"
61 #include "spl-util.h"
62 #include "state.h"
63 #include "stuff.h"
64 #include "areas.h"
65 #include "stash.h"
66 #include "state.h"
67 #include "terrain.h"
68 #include "travel.h"
69 #include "hints.h"
70 #include "unwind.h"
71 #include "viewchar.h"
72 #include "xom.h"
73
74 static bool _invisible_to_player(const item_def& item);
75 static void _autoinscribe_item(item_def& item);
76 static void _autoinscribe_floor_items();
77 static void _autoinscribe_inventory();
78 static void _multidrop(vector<SelItem> tmp_items);
79
80 static bool will_autopickup   = false;
81 static bool will_autoinscribe = false;
82
83 static inline string _autopickup_item_name(const item_def &item)
84 {
85     return userdef_annotate_item(STASH_LUA_SEARCH_ANNOTATE, &item, true)
86            + item_prefix(item, false) + " " + item.name(DESC_PLAIN);
87 }
88
89 // Used to be called "unlink_items", but all it really does is make
90 // sure item coordinates are correct to the stack they're in. -- bwr
91 void fix_item_coordinates()
92 {
93     // Nails all items to the ground (i.e. sets x,y).
94     for (int x = 0; x < GXM; x++)
95         for (int y = 0; y < GYM; y++)
96         {
97             int i = igrd[x][y];
98
99             while (i != NON_ITEM)
100             {
101                 mitm[i].pos.x = x;
102                 mitm[i].pos.y = y;
103                 i = mitm[i].link;
104             }
105         }
106 }
107
108 // This function uses the items coordinates to relink all the igrd lists.
109 void link_items(void)
110 {
111     // First, initialise igrd array.
112     igrd.init(NON_ITEM);
113
114     // Link all items on the grid, plus shop inventory,
115     // but DON'T link the huge pile of monster items at (-2,-2).
116
117     for (int i = 0; i < MAX_ITEMS; i++)
118     {
119         // Don't mess with monster held items, since the index of the holding
120         // monster is stored in the link field.
121         if (mitm[i].held_by_monster())
122             continue;
123
124         if (!mitm[i].defined())
125         {
126             // Item is not assigned.  Ignore.
127             mitm[i].link = NON_ITEM;
128             continue;
129         }
130
131         // link to top
132         mitm[i].link = igrd(mitm[i].pos);
133         igrd(mitm[i].pos) = i;
134     }
135 }
136
137 static bool _item_ok_to_clean(int item)
138 {
139     // Never clean food or Orbs.
140     if (mitm[item].base_type == OBJ_FOOD || item_is_orb(mitm[item]))
141         return false;
142
143     // Never clean runes.
144     if (mitm[item].base_type == OBJ_MISCELLANY
145         && mitm[item].sub_type == MISC_RUNE_OF_ZOT)
146     {
147         return false;
148     }
149
150     return true;
151 }
152
153 static bool _item_preferred_to_clean(int item)
154 {
155     // Preferably clean "normal" weapons and ammo
156     if (mitm[item].base_type == OBJ_WEAPONS
157         && mitm[item].plus <= 0 && mitm[item].plus2 <= 0
158         && !is_artefact(mitm[item]))
159         return true;
160
161     if (mitm[item].base_type == OBJ_MISSILES
162         && mitm[item].plus <= 0 && mitm[item].plus2 <= 0
163         && !is_artefact(mitm[item]))
164         return true;
165
166     return false;
167 }
168
169 // Returns index number of first available space, or NON_ITEM for
170 // unsuccessful cleanup (should be exceedingly rare!)
171 static int _cull_items(void)
172 {
173     crawl_state.cancel_cmd_repeat();
174
175     // XXX: Not the prettiest of messages, but the player
176     // deserves to know whenever this kicks in. -- bwr
177     mpr("Too many items on level, removing some.", MSGCH_WARN);
178
179     // Rules:
180     //  1. Don't cleanup anything nearby the player
181     //  2. Don't cleanup shops
182     //  3. Don't cleanup monster inventory
183     //  4. Clean 15% of items
184     //  5. never remove food, orbs, runes
185     //  7. uniques weapons are moved to the abyss
186     //  8. randarts are simply lost
187     //  9. unrandarts are 'destroyed', but may be generated again
188     // 10. Remove +0 weapons and ammo first, only removing others if this fails.
189
190     int first_cleaned = NON_ITEM;
191
192     // 2. Avoid shops by avoiding (0,5..9).
193     // 3. Avoid monster inventory by iterating over the dungeon grid.
194
195     // 10. Remove +0 weapons and ammo first, only removing others if this fails.
196     // Loop twice. First iteration, get rid of uninteresting stuff. Second
197     // iteration, get rid of anything non-essential
198     for (int remove_all=0; remove_all<2 && first_cleaned==NON_ITEM; remove_all++)
199     {
200         for (rectangle_iterator ri(1); ri; ++ri)
201         {
202             if (distance2(you.pos(), *ri) <= dist_range(9))
203                 continue;
204
205             for (stack_iterator si(*ri); si; ++si)
206             {
207                 if (_item_ok_to_clean(si->index())
208                     && (remove_all || _item_preferred_to_clean(si->index()))
209                     && x_chance_in_y(15, 100))
210                 {
211                     if (is_unrandom_artefact(*si))
212                     {
213                         // 7. Move uniques to abyss.
214                         set_unique_item_status(*si, UNIQ_LOST_IN_ABYSS);
215                     }
216
217                     if (first_cleaned == NON_ITEM)
218                         first_cleaned = si->index();
219
220                     // POOF!
221                     destroy_item(si->index());
222                 }
223             }
224         }
225     }
226
227     return first_cleaned;
228 }
229
230
231 /*---------------------------------------------------------------------*/
232 stack_iterator::stack_iterator(const coord_def& pos, bool accessible)
233 {
234     cur_link = accessible ? you.visible_igrd(pos) : igrd(pos);
235     if (cur_link != NON_ITEM)
236         next_link = mitm[cur_link].link;
237     else
238         next_link = NON_ITEM;
239 }
240
241 stack_iterator::stack_iterator(int start_link)
242 {
243     cur_link = start_link;
244     if (cur_link != NON_ITEM)
245         next_link = mitm[cur_link].link;
246     else
247         next_link = NON_ITEM;
248 }
249
250 stack_iterator::operator bool() const
251 {
252     return (cur_link != NON_ITEM);
253 }
254
255 item_def& stack_iterator::operator*() const
256 {
257     ASSERT(cur_link != NON_ITEM);
258     return mitm[cur_link];
259 }
260
261 item_def* stack_iterator::operator->() const
262 {
263     ASSERT(cur_link != NON_ITEM);
264     return &mitm[cur_link];
265 }
266
267 int stack_iterator::link() const
268 {
269     return cur_link;
270 }
271
272 const stack_iterator& stack_iterator::operator ++ ()
273 {
274     cur_link = next_link;
275     if (cur_link != NON_ITEM)
276         next_link = mitm[cur_link].link;
277     return *this;
278 }
279
280 stack_iterator stack_iterator::operator++(int dummy)
281 {
282     const stack_iterator copy = *this;
283     ++(*this);
284     return copy;
285 }
286 /*---------------------------------------------------------------------*/
287
288
289 // Reduce quantity of an inventory item, do cleanup if item goes away.
290 //
291 // Returns true if stack of items no longer exists.
292 bool dec_inv_item_quantity(int obj, int amount, bool suppress_burden)
293 {
294     bool ret = false;
295
296     if (you.equip[EQ_WEAPON] == obj)
297         you.wield_change = true;
298
299     you.m_quiver->on_inv_quantity_changed(obj, amount);
300
301     if (you.inv[obj].quantity <= amount)
302     {
303         for (int i = 0; i < NUM_EQUIP; i++)
304         {
305             if (you.equip[i] == obj)
306             {
307                 if (i == EQ_WEAPON)
308                 {
309                     unwield_item();
310                     canned_msg(MSG_EMPTY_HANDED_NOW);
311                 }
312                 you.equip[i] = -1;
313             }
314         }
315
316         item_skills(you.inv[obj], you.stop_train);
317
318         you.inv[obj].base_type = OBJ_UNASSIGNED;
319         you.inv[obj].quantity  = 0;
320         you.inv[obj].props.clear();
321
322         ret = true;
323
324         // If we're repeating a command, the repetitions used up the
325         // item stack being repeated on, so stop rather than move onto
326         // the next stack.
327         crawl_state.cancel_cmd_repeat();
328         crawl_state.cancel_cmd_again();
329     }
330     else
331         you.inv[obj].quantity -= amount;
332
333     if (!suppress_burden)
334         burden_change();
335
336     return ret;
337 }
338
339 // Reduce quantity of a monster/grid item, do cleanup if item goes away.
340 //
341 // Returns true if stack of items no longer exists.
342 bool dec_mitm_item_quantity(int obj, int amount)
343 {
344     if (mitm[obj].quantity <= amount)
345         amount = mitm[obj].quantity;
346
347     if (mitm[obj].quantity == amount)
348     {
349         destroy_item(obj);
350         // If we're repeating a command, the repetitions used up the
351         // item stack being repeated on, so stop rather than move onto
352         // the next stack.
353         crawl_state.cancel_cmd_repeat();
354         crawl_state.cancel_cmd_again();
355         return true;
356     }
357
358     mitm[obj].quantity -= amount;
359
360     return false;
361 }
362
363 void inc_inv_item_quantity(int obj, int amount, bool suppress_burden)
364 {
365     if (you.equip[EQ_WEAPON] == obj)
366         you.wield_change = true;
367
368     you.m_quiver->on_inv_quantity_changed(obj, amount);
369     you.inv[obj].quantity += amount;
370
371     if (!suppress_burden)
372         burden_change();
373 }
374
375 void inc_mitm_item_quantity(int obj, int amount)
376 {
377     mitm[obj].quantity += amount;
378 }
379
380 void init_item(int item)
381 {
382     if (item == NON_ITEM)
383         return;
384
385     mitm[item].clear();
386 }
387
388 // Returns an unused mitm slot, or NON_ITEM if none available.
389 // The reserve is the number of item slots to not check.
390 // Items may be culled if a reserve <= 10 is specified.
391 int get_mitm_slot(int reserve)
392 {
393     ASSERT(reserve >= 0);
394
395     if (crawl_state.game_is_arena())
396         reserve = 0;
397
398     int item = NON_ITEM;
399
400     for (item = 0; item < (MAX_ITEMS - reserve); item++)
401         if (!mitm[item].defined())
402             break;
403
404     if (item >= MAX_ITEMS - reserve)
405     {
406         if (crawl_state.game_is_arena())
407         {
408             item = arena_cull_items();
409             // If arena_cull_items() can't free up any space then
410             // _cull_items() won't be able to either, so give up.
411             if (item == NON_ITEM)
412                 return NON_ITEM;
413         }
414         else
415             item = (reserve <= 10) ? _cull_items() : NON_ITEM;
416
417         if (item == NON_ITEM)
418             return NON_ITEM;
419     }
420
421     ASSERT(item != NON_ITEM);
422
423     init_item(item);
424
425     return item;
426 }
427
428 void unlink_item(int dest)
429 {
430     // Don't destroy non-items, may be called after an item has been
431     // reduced to zero quantity however.
432     if (dest == NON_ITEM || !mitm[dest].defined())
433         return;
434
435     monster* mons = mitm[dest].holding_monster();
436
437     if (mons != NULL)
438     {
439         for (int i = 0; i < NUM_MONSTER_SLOTS; i++)
440         {
441             if (mons->inv[i] == dest)
442             {
443                 mons->inv[i] = NON_ITEM;
444
445                 mitm[dest].pos.reset();
446                 mitm[dest].link = NON_ITEM;
447                 return;
448             }
449         }
450         mprf(MSGCH_ERROR, "Item %s claims to be held by monster %s, but "
451                           "it isn't in the monster's inventory.",
452              mitm[dest].name(DESC_PLAIN, false, true).c_str(),
453              mons->name(DESC_PLAIN, true).c_str());
454         // Don't return so the debugging code can take a look at it.
455     }
456     // Unlinking a newly created item, or a a temporary one, or an item in
457     // the player's inventory.
458     else if (mitm[dest].pos.origin() || mitm[dest].pos.equals(-1, -1))
459     {
460         mitm[dest].pos.reset();
461         mitm[dest].link = NON_ITEM;
462         return;
463     }
464     else
465     {
466         if (!is_shop_item(mitm[dest]))
467             ASSERT_IN_BOUNDS(mitm[dest].pos);
468
469         // Linked item on map:
470         //
471         // Use the items (x,y) to access the list (igrd[x][y]) where
472         // the item should be linked.
473
474         // First check the top:
475         if (igrd(mitm[dest].pos) == dest)
476         {
477             // link igrd to the second item
478             igrd(mitm[dest].pos) = mitm[dest].link;
479
480             mitm[dest].pos.reset();
481             mitm[dest].link = NON_ITEM;
482             return;
483         }
484
485         // Okay, item is buried, find item that's on top of it.
486         for (stack_iterator si(mitm[dest].pos); si; ++si)
487         {
488             // Find item linking to dest item.
489             if (si->defined() && si->link == dest)
490             {
491                 // unlink dest
492                 si->link = mitm[dest].link;
493                 mitm[dest].pos.reset();
494                 mitm[dest].link = NON_ITEM;
495                 return;
496             }
497         }
498     }
499
500 #ifdef DEBUG
501     // Okay, the sane ways are gone... let's warn the player:
502     mprf(MSGCH_ERROR, "BUG WARNING: Problems unlinking item '%s', (%d, %d)!!!",
503          mitm[dest].name(DESC_PLAIN).c_str(),
504          mitm[dest].pos.x, mitm[dest].pos.y);
505
506     // Okay, first we scan all items to see if we have something
507     // linked to this item.  We're not going to return if we find
508     // such a case... instead, since things are already out of
509     // alignment, let's assume there might be multiple links as well.
510     bool linked = false;
511     int  old_link = mitm[dest].link; // used to try linking the first
512
513     // Clean the relevant parts of the object.
514     mitm[dest].base_type = OBJ_UNASSIGNED;
515     mitm[dest].quantity  = 0;
516     mitm[dest].link      = NON_ITEM;
517     mitm[dest].pos.reset();
518     mitm[dest].props.clear();
519
520     // Look through all items for links to this item.
521     for (int c = 0; c < MAX_ITEMS; c++)
522     {
523         if (mitm[c].defined() && mitm[c].link == dest)
524         {
525             // unlink item
526             mitm[c].link = old_link;
527
528             if (!linked)
529             {
530                 old_link = NON_ITEM;
531                 linked = true;
532             }
533         }
534     }
535
536     // Now check the grids to see if it's linked as a list top.
537     for (int c = 2; c < (GXM - 1); c++)
538         for (int cy = 2; cy < (GYM - 1); cy++)
539         {
540             if (igrd[c][cy] == dest)
541             {
542                 igrd[c][cy] = old_link;
543
544                 if (!linked)
545                 {
546                     old_link = NON_ITEM;  // cleaned after the first
547                     linked = true;
548                 }
549             }
550         }
551
552
553     // Okay, finally warn player if we didn't do anything.
554     if (!linked)
555     {
556         mpr("BUG WARNING: Item didn't seem to be linked at all.",
557             MSGCH_ERROR);
558     }
559 #endif
560 }
561
562 void destroy_item(item_def &item, bool never_created)
563 {
564     if (!item.defined())
565         return;
566
567     if (never_created)
568     {
569         if (is_unrandom_artefact(item))
570             set_unique_item_status(item, UNIQ_NOT_EXISTS);
571     }
572
573     item.clear();
574 }
575
576 void destroy_item(int dest, bool never_created)
577 {
578     // Don't destroy non-items, but this function may be called upon
579     // to remove items reduced to zero quantity, so we allow "invalid"
580     // objects in.
581     if (dest == NON_ITEM || !mitm[dest].defined())
582         return;
583
584     unlink_item(dest);
585     destroy_item(mitm[dest], never_created);
586 }
587
588 static void _handle_gone_item(const item_def &item)
589 {
590     if (player_in_branch(BRANCH_ABYSS)
591         && place_branch(item.orig_place) == BRANCH_ABYSS
592         && !(item.flags & ISFLAG_BEEN_IN_INV))
593     {
594         if (is_unrandom_artefact(item))
595             set_unique_item_status(item, UNIQ_LOST_IN_ABYSS);
596     }
597 }
598
599 void item_was_lost(const item_def &item)
600 {
601     _handle_gone_item(item);
602     xom_check_lost_item(item);
603 }
604
605 void item_was_destroyed(const item_def &item, int cause)
606 {
607     if (item.props.exists("destroy_xp"))
608         gain_exp(item.props["destroy_xp"].get_int());
609     _handle_gone_item(item);
610     xom_check_destroyed_item(item, cause);
611 }
612
613 void lose_item_stack(const coord_def& where)
614 {
615     for (stack_iterator si(where); si; ++si)
616     {
617         if (si ->defined()) // FIXME is this check necessary?
618         {
619             item_was_lost(*si);
620             si->clear();
621         }
622     }
623     igrd(where) = NON_ITEM;
624 }
625
626 static bool _invisible_to_player(const item_def& item)
627 {
628     return strstr(item.inscription.c_str(), "=k") != 0;
629 }
630
631 static int _count_nonsquelched_items(int obj)
632 {
633     int result = 0;
634
635     for (stack_iterator si(obj); si; ++si)
636         if (!_invisible_to_player(*si))
637             ++result;
638
639     return result;
640 }
641
642 // Fill items with the items on a square.
643 // Squelched items (marked with =k) are ignored, unless
644 // the square contains *only* squelched items, in which case they
645 // are included. If force_squelch is true, squelched items are
646 // never displayed.
647 void item_list_on_square(vector<const item_def*>& items, int obj,
648                          bool force_squelch)
649 {
650     const bool have_nonsquelched = (force_squelch
651                                     || _count_nonsquelched_items(obj));
652
653     // Loop through the items.
654     for (stack_iterator si(obj); si; ++si)
655     {
656         // Add them to the items list if they qualify.
657         if (!have_nonsquelched || !_invisible_to_player(*si))
658             items.push_back(& (*si));
659     }
660 }
661
662 bool need_to_autopickup()
663 {
664     return will_autopickup;
665 }
666
667 void request_autopickup(bool do_pickup)
668 {
669     will_autopickup = do_pickup;
670 }
671
672 bool item_is_branded(const item_def& item)
673 {
674     switch (item.base_type)
675     {
676     case OBJ_WEAPONS:
677         return (get_weapon_brand(item) != SPWPN_NORMAL);
678     case OBJ_ARMOUR:
679         return (get_armour_ego_type(item) != SPARM_NORMAL);
680     case OBJ_MISSILES:
681         return (get_ammo_brand(item) != SPMSL_NORMAL);
682     default:
683         return false;
684     }
685 }
686
687 // 2 - artefact, 1 - glowing/runed, 0 - mundane
688 static int _item_name_specialness(const item_def& item)
689 {
690     if (item.base_type != OBJ_WEAPONS && item.base_type != OBJ_ARMOUR
691         && item.base_type != OBJ_MISSILES && item.base_type != OBJ_JEWELLERY)
692     {
693         return 0;
694     }
695
696     // You can tell something is an artefact, because it'll have a
697     // description which rules out anything else.
698     if (is_artefact(item))
699         return 2;
700
701     // All unknown jewellery is worth looking at.
702     if (item.base_type == OBJ_JEWELLERY)
703     {
704         if (is_useless_item(item))
705             return 0;
706
707         return 1;
708     }
709
710     if (item_type_known(item))
711     {
712         if (item_is_branded(item))
713             return 1;
714         return 0;
715     }
716
717     if (item.flags & ISFLAG_COSMETIC_MASK)
718         return 1;
719
720     return 0;
721 }
722
723 static void _maybe_give_corpse_hint(const item_def item)
724 {
725     if (!crawl_state.game_is_hints_tutorial())
726         return;
727
728     if (item.base_type == OBJ_CORPSES && item.sub_type == CORPSE_BODY
729         && you.has_spell(SPELL_ANIMATE_SKELETON))
730     {
731         learned_something_new(HINT_ANIMATE_CORPSE_SKELETON);
732     }
733 }
734
735 void item_check(bool verbose)
736 {
737     describe_floor();
738     origin_set(you.pos());
739
740     ostream& strm = msg::streams(MSGCH_FLOOR_ITEMS);
741
742     vector<const item_def*> items;
743
744     item_list_on_square(items, you.visible_igrd(you.pos()), true);
745
746     if (items.empty())
747     {
748         if (verbose)
749             strm << "There are no items here." << endl;
750         return;
751     }
752
753     if (items.size() == 1)
754     {
755         item_def it(*items[0]);
756         string name = get_menu_colour_prefix_tags(it, DESC_A);
757         strm << "You see here " << name << '.' << endl;
758         _maybe_give_corpse_hint(it);
759         return;
760     }
761
762     bool done_init_line = false;
763
764     if (static_cast<int>(items.size()) >= Options.item_stack_summary_minimum)
765     {
766         vector<unsigned int> item_chars;
767         for (unsigned int i = 0; i < items.size() && i < 50; ++i)
768         {
769             cglyph_t g = get_item_glyph(items[i]);
770             get_item_glyph(items[i]);
771             item_chars.push_back(g.ch * 0x100 +
772                                  (10 - _item_name_specialness(*(items[i]))));
773         }
774         sort(item_chars.begin(), item_chars.end());
775
776         string out_string = "Items here: ";
777         int cur_state = -1;
778         for (unsigned int i = 0; i < item_chars.size(); ++i)
779         {
780             const int specialness = 10 - (item_chars[i] % 0x100);
781             if (specialness != cur_state)
782             {
783                 switch (specialness)
784                 {
785                 case 2: out_string += "<yellow>";   break; // artefact
786                 case 1: out_string += "<white>";    break; // glowing/runed
787                 case 0: out_string += "<darkgrey>"; break; // mundane
788                 }
789                 cur_state = specialness;
790             }
791
792             out_string += stringize_glyph(item_chars[i] / 0x100);
793             if (i + 1 < item_chars.size()
794                 && (item_chars[i] / 0x100) != (item_chars[i+1] / 0x100))
795             {
796                 out_string += ' ';
797             }
798         }
799         mprnojoin(out_string, MSGCH_FLOOR_ITEMS);
800         done_init_line = true;
801     }
802
803     if (verbose || items.size() <= msgwin_lines() - 1)
804     {
805         if (!done_init_line)
806             mprnojoin("Things that are here:", MSGCH_FLOOR_ITEMS);
807         for (unsigned int i = 0; i < items.size(); ++i)
808         {
809             item_def it(*items[i]);
810             string name = get_menu_colour_prefix_tags(it, DESC_A);
811             mpr_nocap(name);
812             _maybe_give_corpse_hint(it);
813         }
814     }
815     else if (!done_init_line)
816         strm << "There are many items here." << endl;
817
818     if (items.size() > 2 && crawl_state.game_is_hints_tutorial())
819     {
820         // If there are 2 or more non-corpse items here, we might need
821         // a hint.
822         int count = 0;
823         for (unsigned int i = 0; i < items.size(); ++i)
824         {
825             item_def it(*items[i]);
826             if (it.base_type == OBJ_CORPSES)
827                 continue;
828
829             if (++count > 1)
830             {
831                 learned_something_new(HINT_MULTI_PICKUP);
832                 break;
833             }
834         }
835     }
836 }
837
838 static int _menu_selection_weight(const Menu* menu)
839 {
840     vector<MenuEntry*> se = menu->selected_entries();
841     int weight(0);
842     for (int i = 0, size = se.size(); i < size; ++i)
843     {
844         const item_def *item = static_cast<item_def*>(se[i]->data);
845         if (se[i]->selected_qty > 0)
846             weight += item_mass(*item) * se[i]->selected_qty;
847     }
848     return weight;
849 }
850
851 static string _menu_burden_invstatus(const Menu *menu, bool is_pickup = false)
852 {
853     int sel_weight = _menu_selection_weight(menu);
854     int new_burd = you.burden + (is_pickup ? sel_weight : -sel_weight);
855     string sw = sel_weight ? make_stringf(">%.0f", new_burd * BURDEN_TO_AUM) : "";
856     //TODO: Should somehow colour burdened/overloaded in LIGHTRED/RED
857     //      respectively {kittel}
858     string newstate =
859         new_burd > carrying_capacity(BS_ENCUMBERED) ? "overloaded)" :
860       new_burd > carrying_capacity(BS_UNENCUMBERED) ? "burdened)"
861                                                     : "unencumbered)";
862
863     string burden = "(Burden: ";
864     burden += Options.show_inventory_weights ?
865                   make_stringf("%.0f%s/%.0f aum)",
866                       you.burden * BURDEN_TO_AUM,
867                       sw.c_str(),
868                       carrying_capacity(BS_UNENCUMBERED) * BURDEN_TO_AUM)
869                 : newstate;
870     return burden;
871 }
872
873 static string _pickup_menu_title(const Menu *menu, const string &oldt)
874 {
875     return _menu_burden_invstatus(menu, true) + " " + oldt;
876 }
877
878 void pickup_menu(int item_link)
879 {
880     int n_did_pickup   = 0;
881     int n_tried_pickup = 0;
882
883     vector<const item_def*> items;
884     item_list_on_square(items, item_link, false);
885
886 #ifdef TOUCH_UI
887     string prompt = "Pick up what? (<Enter> or tap header to pick up)";
888 #else
889     string prompt = "Pick up what? (_ for help)";
890 #endif
891     if (items.size() == 1 && items[0]->quantity > 1)
892         prompt = "Select pick up quantity by entering a number, then select the item";
893     vector<SelItem> selected = select_items(items, prompt.c_str(), false,
894                                             MT_PICKUP, _pickup_menu_title);
895     if (selected.empty())
896         canned_msg(MSG_OK);
897     redraw_screen();
898
899     string pickup_warning;
900     for (int i = 0, count = selected.size(); i < count; ++i)
901         for (int j = item_link; j != NON_ITEM; j = mitm[j].link)
902         {
903             if (&mitm[j] == selected[i].item)
904             {
905                 if (j == item_link)
906                     item_link = mitm[j].link;
907
908                 int num_to_take = selected[i].quantity;
909                 const bool take_all = (num_to_take == mitm[j].quantity);
910                 iflags_t oldflags = mitm[j].flags;
911                 mitm[j].flags &= ~(ISFLAG_THROWN | ISFLAG_DROPPED);
912                 int result = move_item_to_player(j, num_to_take);
913
914                 // If we cleared any flags on the items, but the pickup was
915                 // partial, reset the flags for the items that remain on the
916                 // floor.
917                 if (result == 0 || result == -1)
918                 {
919                     n_tried_pickup++;
920                     if (result == 0)
921                         pickup_warning = "You can't carry that much weight.";
922                     else
923                         pickup_warning = "You can't carry that many items.";
924
925                     if (mitm[j].defined())
926                         mitm[j].flags = oldflags;
927                 }
928                 else
929                 {
930                     n_did_pickup++;
931                     // If we deliberately chose to take only part of a
932                     // pile, we consider the rest to have been
933                     // "dropped."
934                     if (!take_all && mitm[j].defined())
935                         mitm[j].flags |= ISFLAG_DROPPED;
936                 }
937             }
938         }
939
940     if (!pickup_warning.empty())
941     {
942         mpr(pickup_warning.c_str());
943         learned_something_new(HINT_HEAVY_LOAD);
944     }
945
946     if (n_did_pickup)
947         you.turn_is_over = true;
948 }
949
950 bool origin_known(const item_def &item)
951 {
952     return (item.orig_place != 0);
953 }
954
955 void origin_reset(item_def &item)
956 {
957     item.orig_place  = 0;
958     item.orig_monnum = 0;
959 }
960
961 // We have no idea where the player found this item.
962 void origin_set_unknown(item_def &item)
963 {
964     if (!origin_known(item))
965     {
966         item.orig_place  = 0xFFFF;
967         item.orig_monnum = 0;
968     }
969 }
970
971 // This item is starting equipment.
972 void origin_set_startequip(item_def &item)
973 {
974     if (!origin_known(item))
975     {
976         item.orig_place  = 0xFFFF;
977         item.orig_monnum = -IT_SRC_START;
978     }
979 }
980
981 void origin_set_monster(item_def &item, const monster* mons)
982 {
983     if (!origin_known(item))
984     {
985         if (!item.orig_monnum)
986             item.orig_monnum = mons->type;
987         item.orig_place = get_packed_place();
988     }
989 }
990
991 void origin_purchased(item_def &item)
992 {
993     // We don't need to check origin_known if it's a shop purchase
994     item.orig_place  = get_packed_place();
995     item.orig_monnum = -IT_SRC_SHOP;
996 }
997
998 void origin_acquired(item_def &item, int agent)
999 {
1000     // We don't need to check origin_known if it's a divine gift
1001     item.orig_place  = get_packed_place();
1002     item.orig_monnum = -agent;
1003 }
1004
1005 void origin_set_inventory(void (*oset)(item_def &item))
1006 {
1007     for (int i = 0; i < ENDOFPACK; ++i)
1008         if (you.inv[i].defined())
1009             oset(you.inv[i]);
1010 }
1011
1012 static string _milestone_rune(const item_def &item)
1013 {
1014     return string("found ") + item.name(DESC_A) + ".";
1015 }
1016
1017 static void _milestone_check(const item_def &item)
1018 {
1019     if (item_is_rune(item))
1020         mark_milestone("rune", _milestone_rune(item));
1021     else if (item_is_orb(item))
1022         mark_milestone("orb", "found the Orb of Zot!");
1023 }
1024
1025 static void _check_note_item(item_def &item)
1026 {
1027     if (item.flags & (ISFLAG_NOTED_GET | ISFLAG_NOTED_ID))
1028         return;
1029
1030     if (item_is_rune(item) || item_is_orb(item) || is_artefact(item))
1031     {
1032         take_note(Note(NOTE_GET_ITEM, 0, 0, item.name(DESC_A).c_str(),
1033                        origin_desc(item).c_str()));
1034         item.flags |= ISFLAG_NOTED_GET;
1035
1036         // If it's already fully identified when picked up, don't take
1037         // further notes.
1038         if (fully_identified(item))
1039             item.flags |= ISFLAG_NOTED_ID;
1040         _milestone_check(item);
1041     }
1042 }
1043
1044 void origin_set(const coord_def& where)
1045 {
1046     unsigned short pplace = get_packed_place();
1047     for (stack_iterator si(where); si; ++si)
1048     {
1049         if (origin_known(*si))
1050             continue;
1051
1052         si->orig_place  = pplace;
1053     }
1054 }
1055
1056 static void _origin_freeze(item_def &item, const coord_def& where)
1057 {
1058     if (!origin_known(item))
1059     {
1060         item.orig_place = get_packed_place();
1061         _check_note_item(item);
1062     }
1063 }
1064
1065 static string _origin_monster_name(const item_def &item)
1066 {
1067     const monster_type monnum = static_cast<monster_type>(item.orig_monnum);
1068     if (monnum == MONS_PLAYER_GHOST)
1069         return "a player ghost";
1070     else if (monnum == MONS_PANDEMONIUM_LORD)
1071         return "a pandemonium lord";
1072     return mons_type_name(monnum, DESC_A);
1073 }
1074
1075 static string _origin_place_desc(const item_def &item)
1076 {
1077     return prep_branch_level_name(item.orig_place);
1078 }
1079
1080 bool origin_describable(const item_def &item)
1081 {
1082     return (origin_known(item)
1083             && item.orig_place != 0xFFFFU
1084             && !is_stackable_item(item)
1085             && item.quantity == 1
1086             && item.base_type != OBJ_CORPSES
1087             && (item.base_type != OBJ_FOOD || item.sub_type != FOOD_CHUNK));
1088 }
1089
1090 static string _article_it(const item_def &item)
1091 {
1092     // "it" is always correct, since gloves and boots also come in pairs.
1093     return "it";
1094 }
1095
1096 static bool _origin_is_original_equip(const item_def &item)
1097 {
1098     return (item.orig_place == 0xFFFFU && item.orig_monnum == -IT_SRC_START);
1099 }
1100
1101 bool origin_is_god_gift(const item_def& item, god_type *god)
1102 {
1103     god_type ogod = static_cast<god_type>(-item.orig_monnum);
1104     if (ogod <= GOD_NO_GOD || ogod >= NUM_GODS)
1105         ogod = GOD_NO_GOD;
1106
1107     if (god)
1108         *god = ogod;
1109     return ogod;
1110 }
1111
1112 bool origin_is_acquirement(const item_def& item, item_source_type *type)
1113 {
1114     item_source_type junk;
1115     if (type == NULL)
1116         type = &junk;
1117     *type = IT_SRC_NONE;
1118
1119     const int iorig = -item.orig_monnum;
1120     if (iorig == AQ_SCROLL || iorig == AQ_CARD_GENIE
1121         || iorig == AQ_WIZMODE)
1122     {
1123         *type = static_cast<item_source_type>(iorig);
1124         return true;
1125     }
1126
1127     return false;
1128 }
1129
1130 string origin_desc(const item_def &item)
1131 {
1132     if (!origin_describable(item))
1133         return "";
1134
1135     if (_origin_is_original_equip(item))
1136         return "Original Equipment";
1137
1138     string desc;
1139     if (item.orig_monnum)
1140     {
1141         if (item.orig_monnum < 0)
1142         {
1143             int iorig = -item.orig_monnum;
1144             switch (iorig)
1145             {
1146             case IT_SRC_SHOP:
1147                 desc += "You bought " + _article_it(item) + " in a shop ";
1148                 break;
1149             case IT_SRC_START:
1150                 desc += "Buggy Original Equipment: ";
1151                 break;
1152             case AQ_SCROLL:
1153                 desc += "You acquired " + _article_it(item) + " ";
1154                 break;
1155             case AQ_CARD_GENIE:
1156                 desc += "You drew the Genie ";
1157                 break;
1158             case AQ_WIZMODE:
1159                 desc += "Your wizardly powers created "+ _article_it(item)+ " ";
1160                 break;
1161             default:
1162                 if (iorig > GOD_NO_GOD && iorig < NUM_GODS)
1163                 {
1164                     desc += god_name(static_cast<god_type>(iorig))
1165                         + " gifted " + _article_it(item) + " to you ";
1166                 }
1167                 else
1168                 {
1169                     // Bug really.
1170                     desc += "You stumbled upon " + _article_it(item) + " ";
1171                 }
1172                 break;
1173             }
1174         }
1175         else if (item.orig_monnum == MONS_DANCING_WEAPON)
1176             desc += "You subdued it ";
1177         else
1178         {
1179             desc += "You took " + _article_it(item) + " off "
1180                     + _origin_monster_name(item) + " ";
1181         }
1182     }
1183     else
1184         desc += "You found " + _article_it(item) + " ";
1185
1186     desc += _origin_place_desc(item);
1187     return desc;
1188 }
1189
1190 bool pickup_single_item(int link, int qty)
1191 {
1192     item_def* item = &mitm[link];
1193     if (item->base_type == OBJ_GOLD && !qty && !i_feel_safe()
1194         && !yesno("Are you sure you want to pick up this pile of gold now?",
1195                   true, 'n'))
1196     {
1197         canned_msg(MSG_OK);
1198         return false;
1199     }
1200     if (qty == 0 && item->quantity > 1 && item->base_type != OBJ_GOLD)
1201     {
1202         const string prompt
1203                 = make_stringf("Pick up how many of %s (; or enter for all)? ",
1204                                item->name(DESC_THE, false,
1205                                           false, false).c_str());
1206
1207         qty = prompt_for_quantity(prompt.c_str());
1208         if (qty == -1)
1209             qty = item->quantity;
1210         else if (qty == 0)
1211         {
1212             canned_msg(MSG_OK);
1213             return false;
1214         }
1215         else if (qty < item->quantity)
1216         {
1217             // Mark rest item as not eligible for autopickup.
1218             item->flags |= ISFLAG_DROPPED;
1219             item->flags &= ~ISFLAG_THROWN;
1220         }
1221     }
1222
1223     if (qty < 1 || qty > item->quantity)
1224         qty = item->quantity;
1225
1226     iflags_t oldflags = item->flags;
1227     item->flags &= ~(ISFLAG_THROWN | ISFLAG_DROPPED);
1228     int num = move_item_to_player(link, qty);
1229     if (item->defined())
1230         item->flags = oldflags;
1231
1232     if (num == -1)
1233     {
1234         mpr("You can't carry that many items.");
1235         learned_something_new(HINT_HEAVY_LOAD);
1236         return false;
1237     }
1238     else if (num == 0)
1239     {
1240         mpr("You can't carry that much weight.");
1241         learned_something_new(HINT_HEAVY_LOAD);
1242         return false;
1243     }
1244
1245     return true;
1246 }
1247
1248 bool player_on_single_stack()
1249 {
1250     int o = you.visible_igrd(you.pos());
1251     if (o == NON_ITEM)
1252         return false;
1253     else
1254         return (mitm[o].link == NON_ITEM && mitm[o].quantity > 1);
1255 }
1256
1257 void pickup(bool partial_quantity)
1258 {
1259     int keyin = 'x';
1260
1261     int o = you.visible_igrd(you.pos());
1262     const int num_nonsquelched = _count_nonsquelched_items(o);
1263
1264     // Store last_pickup in case we need to restore it.
1265     // Then clear it to fill with items picked up.
1266     map<int,int> tmp_l_p = you.last_pickup;
1267     you.last_pickup.clear();
1268
1269     if (o == NON_ITEM)
1270         mpr("There are no items here.");
1271     else if (you.form == TRAN_ICE_BEAST && grd(you.pos()) == DNGN_DEEP_WATER)
1272         mpr("You can't reach the bottom while floating on water.");
1273     else if (mitm[o].link == NON_ITEM)      // just one item?
1274     {
1275         // Deliberately allowing the player to pick up
1276         // a killed item here.
1277         pickup_single_item(o, partial_quantity ? 0 : mitm[o].quantity);
1278     }
1279     else if (Options.pickup_mode != -1
1280              && num_nonsquelched >= Options.pickup_mode)
1281     {
1282         pickup_menu(o);
1283     }
1284     else
1285     {
1286         int next;
1287         mpr("There are several objects here.");
1288         string pickup_warning;
1289         while (o != NON_ITEM)
1290         {
1291             // Must save this because pickup can destroy the item.
1292             next = mitm[o].link;
1293
1294             if (num_nonsquelched && _invisible_to_player(mitm[o]))
1295             {
1296                 o = next;
1297                 continue;
1298             }
1299
1300             if (keyin != 'a')
1301             {
1302                 string prompt = "Pick up %s? ((y)es/(n)o/(a)ll/(m)enu/*?g,/q)";
1303
1304                 mprf(MSGCH_PROMPT, prompt.c_str(),
1305                      get_menu_colour_prefix_tags(mitm[o],
1306                                                  DESC_A).c_str());
1307
1308                 mouse_control mc(MOUSE_MODE_YESNO);
1309                 keyin = getchk();
1310             }
1311
1312             if (keyin == '*' || keyin == '?' || keyin == ',' || keyin == 'g'
1313                 || keyin == 'm' || keyin == CK_MOUSE_CLICK)
1314             {
1315                 pickup_menu(o);
1316                 break;
1317             }
1318
1319             if (keyin == 'q' || key_is_escape(keyin))
1320             {
1321                 canned_msg(MSG_OK);
1322                 break;
1323             }
1324
1325             if (keyin == 'y' || keyin == 'a')
1326             {
1327                 int num_to_take = mitm[o].quantity;
1328                 const iflags_t old_flags(mitm[o].flags);
1329                 mitm[o].flags &= ~(ISFLAG_THROWN | ISFLAG_DROPPED);
1330                 int result = move_item_to_player(o, num_to_take);
1331
1332                 if (result == 0 || result == -1)
1333                 {
1334                     if (result == 0)
1335                         pickup_warning = "You can't carry that much weight.";
1336                     else
1337                         pickup_warning = "You can't carry that many items.";
1338
1339                     mitm[o].flags = old_flags;
1340                 }
1341             }
1342
1343             o = next;
1344
1345             if (o == NON_ITEM && keyin != 'y' && keyin != 'a')
1346                 canned_msg(MSG_OK);
1347         }
1348
1349         if (!pickup_warning.empty())
1350             mpr(pickup_warning.c_str());
1351     }
1352     if (you.last_pickup.empty())
1353         you.last_pickup = tmp_l_p;
1354 }
1355
1356 bool is_stackable_item(const item_def &item)
1357 {
1358     if (!item.defined())
1359         return false;
1360
1361     if (item.base_type == OBJ_MISSILES
1362         || item.base_type == OBJ_FOOD
1363         || item.base_type == OBJ_SCROLLS
1364         || item.base_type == OBJ_POTIONS
1365         || item.base_type == OBJ_GOLD)
1366     {
1367         return true;
1368     }
1369
1370     return false;
1371 }
1372
1373 bool items_similar(const item_def &item1, const item_def &item2)
1374 {
1375     // Base and sub-types must always be the same to stack.
1376     if (item1.base_type != item2.base_type || item1.sub_type != item2.sub_type)
1377         return false;
1378
1379     if (item1.base_type == OBJ_GOLD || item_is_rune(item1))
1380         return true;
1381
1382     if (is_artefact(item1) != is_artefact(item2))
1383         return false;
1384     else if (is_artefact(item1)
1385              && get_artefact_name(item1) != get_artefact_name(item2))
1386     {
1387         return false;
1388     }
1389
1390     // These classes also require pluses and special.
1391     if (item1.base_type == OBJ_WEAPONS         // only throwing weapons
1392         || item1.base_type == OBJ_MISSILES
1393         || item1.base_type == OBJ_FOOD)        // chunks
1394     {
1395         if (item1.plus != item2.plus
1396             || item1.plus2 != item2.plus2
1397             || ((item1.base_type == OBJ_FOOD && item2.sub_type == FOOD_CHUNK) ?
1398                 // Reject chunk merge if chunk ages differ by more than 5
1399                 abs(item1.special - item2.special) > 5
1400                 // Non-chunk item specials must match exactly.
1401                 : item1.special != item2.special))
1402         {
1403             return false;
1404         }
1405     }
1406
1407 #define NO_MERGE_FLAGS (ISFLAG_MIMIC | ISFLAG_SUMMONED)
1408     if ((item1.flags & NO_MERGE_FLAGS) != (item2.flags & NO_MERGE_FLAGS))
1409         return false;
1410
1411     // The inscriptions can differ if one of them is blank, but if they
1412     // are differing non-blank inscriptions then don't stack.
1413     if (item1.inscription != item2.inscription
1414         && !item1.inscription.empty() && !item2.inscription.empty())
1415     {
1416         return false;
1417     }
1418
1419     return true;
1420 }
1421
1422 bool items_stack(const item_def &item1, const item_def &item2,
1423                  bool force_merge)
1424 {
1425     // Both items must be stackable.
1426     if (!force_merge
1427         && (!is_stackable_item(item1) || !is_stackable_item(item2))
1428         || static_cast<int>(item1.quantity) + item2.quantity > 32767)
1429     {
1430         COMPILE_CHECK(sizeof(item1.quantity) == 2); // can be relaxed otherwise
1431
1432         return false;
1433     }
1434
1435     return items_similar(item1, item2);
1436 }
1437
1438 void merge_item_stacks(item_def &source, item_def &dest, int quant)
1439 {
1440     if (quant == -1)
1441         quant = source.quantity;
1442
1443     ASSERT_RANGE(quant, 0 + 1, source.quantity + 1);
1444
1445     if (is_blood_potion(source) && is_blood_potion(dest))
1446        merge_blood_potion_stacks(source, dest, quant);
1447 }
1448
1449 static int _userdef_find_free_slot(const item_def &i)
1450 {
1451 #ifdef CLUA_BINDINGS
1452     int slot = -1;
1453     if (!clua.callfn("c_assign_invletter", "u>d", &i, &slot))
1454         return -1;
1455
1456     return slot;
1457 #else
1458     return -1;
1459 #endif
1460 }
1461
1462 int find_free_slot(const item_def &i)
1463 {
1464 #define slotisfree(s) \
1465             ((s) >= 0 && (s) < ENDOFPACK && !you.inv[s].defined())
1466
1467     bool searchforward = false;
1468     // If we're doing Lua, see if there's a Lua function that can give
1469     // us a free slot.
1470     int slot = _userdef_find_free_slot(i);
1471     if (slot == -2 || Options.assign_item_slot == SS_FORWARD)
1472         searchforward = true;
1473
1474     if (slotisfree(slot))
1475         return slot;
1476
1477     // See if the item remembers where it's been. Lua code can play with
1478     // this field so be extra careful.
1479     if (isaalpha(i.slot))
1480         slot = letter_to_index(i.slot);
1481
1482     if (slotisfree(slot))
1483         return slot;
1484
1485     FixedBitVector<ENDOFPACK> disliked;
1486     if (i.base_type == OBJ_FOOD)
1487         disliked.set('e' - 'a'), disliked.set('y' - 'a');
1488     else if (i.base_type == OBJ_POTIONS)
1489         disliked.set('y' - 'a');
1490
1491     if (!searchforward)
1492     {
1493         // This is the new default free slot search. We look for the last
1494         // available slot that does not leave a gap in the inventory.
1495         for (slot = ENDOFPACK - 1; slot >= 0; --slot)
1496         {
1497             if (you.inv[slot].defined())
1498             {
1499                 if (slot + 1 < ENDOFPACK && !you.inv[slot + 1].defined()
1500                     && !disliked[slot + 1])
1501                 {
1502                     return (slot + 1);
1503                 }
1504             }
1505             else
1506             {
1507                 if (slot + 1 < ENDOFPACK && you.inv[slot + 1].defined()
1508                     && !disliked[slot])
1509                 {
1510                     return slot;
1511                 }
1512             }
1513         }
1514     }
1515
1516     // Either searchforward is true, or search backwards failed and
1517     // we re-try searching the oposite direction.
1518
1519     int badslot = -1;
1520     // Return first free slot
1521     for (slot = 0; slot < ENDOFPACK; ++slot)
1522         if (!you.inv[slot].defined())
1523             if (disliked[slot])
1524                 badslot = slot;
1525             else
1526                 return slot;
1527
1528     // If the least preferred slot is the only choice, so be it.
1529     return badslot;
1530 #undef slotisfree
1531 }
1532
1533 static void _got_item(item_def& item, int quant)
1534 {
1535     seen_item(item);
1536     shopping_list.cull_identical_items(item);
1537
1538     if (item.props.exists("needs_autopickup"))
1539         item.props.erase("needs_autopickup");
1540 }
1541
1542 static void _got_gold(item_def& item, int quant, bool quiet)
1543 {
1544     you.attribute[ATTR_GOLD_FOUND] += quant;
1545
1546     if (you.religion == GOD_ZIN && !(item.flags & ISFLAG_THROWN))
1547         quant -= zin_tithe(item, quant, quiet);
1548     if (quant <= 0)
1549         return;
1550     you.add_gold(quant);
1551
1552     if (!quiet)
1553     {
1554         const string gain = quant != you.gold
1555                             ? make_stringf(" (gained %d)", quant)
1556                             : "";
1557
1558         mprf("You now have %d gold piece%s%s.",
1559              you.gold, you.gold != 1 ? "s" : "", gain.c_str());
1560         learned_something_new(HINT_SEEN_GOLD);
1561     }
1562 }
1563
1564 void note_inscribe_item(item_def &item)
1565 {
1566     _autoinscribe_item(item);
1567     _origin_freeze(item, you.pos());
1568     _check_note_item(item);
1569 }
1570
1571 static void _fish(item_def &item, short quant = 0)
1572 {
1573     if (you.species != SP_DJINNI || !feat_is_watery(grd(you.pos())))
1574         return;
1575
1576     unwind_var<short> partial(item.quantity, quant ? quant : item.quantity);
1577     mprf("You fish the %s out of the water.", item.name(DESC_PLAIN).c_str());
1578     you.time_taken += 5;
1579 }
1580
1581 // Returns quantity of items moved into player's inventory and -1 if
1582 // the player's inventory is full.
1583 int move_item_to_player(int obj, int quant_got, bool quiet,
1584                         bool ignore_burden)
1585 {
1586     item_def &it = mitm[obj];
1587
1588     if (item_is_stationary(it))
1589     {
1590         mpr("You cannot pick up the net that holds you!");
1591         // Fake a successful pickup (return 1), so we can continue to
1592         // pick up anything else that might be on this square.
1593         return 1;
1594     }
1595
1596     if (it.base_type == OBJ_ORBS && crawl_state.game_is_zotdef())
1597     {
1598         if (runes_in_pack() < 15)
1599         {
1600             mpr("You must possess at least fifteen runes to touch the sacred Orb which you defend.");
1601             return 1;
1602         }
1603     }
1604
1605     int retval = quant_got;
1606
1607     // Gold has no mass, so we handle it first.
1608     if (it.base_type == OBJ_GOLD)
1609     {
1610         _fish(it);
1611         _got_gold(it, quant_got, quiet);
1612         dec_mitm_item_quantity(obj, quant_got);
1613
1614         you.turn_is_over = true;
1615         return retval;
1616     }
1617     // So do runes.
1618     if (item_is_rune(it))
1619     {
1620         if (!you.runes[it.plus])
1621         {
1622             you.runes.set(it.plus);
1623             _check_note_item(it);
1624         }
1625
1626         if (!quiet)
1627         {
1628             _fish(it);
1629             mprf("You pick up the %s rune and feel its power.",
1630                  rune_type_name(it.plus));
1631             int nrunes = runes_in_pack();
1632             if (nrunes >= you.obtainable_runes)
1633                 mpr("You have collected all the runes! Now go and win!");
1634             else if (nrunes == NUMBER_OF_RUNES_NEEDED
1635                      && !crawl_state.game_is_zotdef())
1636             {
1637                 // might be inappropriate in new Sprints, please change it then
1638                 mprf("%d runes! That's enough to enter the realm of Zot.",
1639                      nrunes);
1640             }
1641             else if (nrunes > 1)
1642                 mprf("You now have %d runes.", nrunes);
1643
1644             mpr("Press } to see all the runes you have collected.");
1645         }
1646
1647         if (it.plus == RUNE_ABYSSAL)
1648             mpr("You feel the abyssal rune guiding you out of this place.");
1649
1650         if (it.plus == RUNE_TOMB)
1651             add_daction(DACT_TOMB_CTELE);
1652
1653         if (it.plus >= RUNE_DIS && it.plus <= RUNE_TARTARUS)
1654             unset_level_flags(LFLAG_NO_TELE_CONTROL);
1655
1656         dungeon_events.fire_position_event(
1657             dgn_event(DET_ITEM_PICKUP, you.pos(), 0, obj, -1), you.pos());
1658
1659         dec_mitm_item_quantity(obj, quant_got);
1660         you.turn_is_over = true;
1661
1662         return retval;
1663     }
1664
1665     const int unit_mass = item_mass(it);
1666     if (quant_got > it.quantity || quant_got <= 0)
1667         quant_got = it.quantity;
1668
1669     int imass = unit_mass * quant_got;
1670     if (!ignore_burden && (you.burden + imass > carrying_capacity()))
1671     {
1672         if (drop_spoiled_chunks(you.burden + imass - carrying_capacity()))
1673             imass = unit_mass * quant_got;
1674     }
1675
1676     bool partial_pickup = false;
1677
1678     if (!ignore_burden && (you.burden + imass > carrying_capacity()))
1679     {
1680         // calculate quantity we can actually pick up
1681         int part = (carrying_capacity() - you.burden) / unit_mass;
1682
1683         if (part < 1)
1684             return 0;
1685
1686         // only pickup 'part' items
1687         quant_got = part;
1688         partial_pickup = true;
1689
1690         retval = part;
1691     }
1692
1693     if (is_stackable_item(it))
1694     {
1695         for (int m = 0; m < ENDOFPACK; m++)
1696         {
1697             if (items_stack(you.inv[m], it))
1698             {
1699                 if (!quiet && partial_pickup)
1700                     mpr("You can only carry some of what is here.");
1701                 if (!quiet)
1702                     _fish(it, quant_got);
1703
1704                 _check_note_item(it);
1705
1706                 // If the object on the ground is inscribed, but not
1707                 // the one in inventory, then the inventory object
1708                 // picks up the other's inscription.
1709                 if (!(it.inscription).empty()
1710                     && you.inv[m].inscription.empty())
1711                 {
1712                     you.inv[m].inscription = it.inscription;
1713                 }
1714
1715                 merge_item_stacks(it, you.inv[m], quant_got);
1716
1717                 inc_inv_item_quantity(m, quant_got);
1718                 dec_mitm_item_quantity(obj, quant_got);
1719                 burden_change();
1720
1721                 _got_item(it, quant_got);
1722
1723                 if (!quiet)
1724                 {
1725                     mprf_nocap("%s (gained %d)",
1726                                get_menu_colour_prefix_tags(you.inv[m],
1727                                    DESC_INVENTORY).c_str(),
1728                                quant_got);
1729                 }
1730                 you.turn_is_over = true;
1731
1732                 you.last_pickup[m] = quant_got;
1733                 return retval;
1734             }
1735         }
1736     }
1737
1738     // Can't combine, check for slot space.
1739     if (inv_count() >= ENDOFPACK)
1740         drop_spoiled_chunks(1, true);
1741     if (inv_count() >= ENDOFPACK)
1742         return -1;
1743
1744     if (!quiet && partial_pickup)
1745         mpr("You can only carry some of what is here.");
1746     if (!quiet)
1747         _fish(it, quant_got);
1748
1749     int freeslot = find_free_slot(it);
1750     ASSERT(freeslot >= 0 && freeslot < ENDOFPACK);
1751     ASSERT(!you.inv[freeslot].defined());
1752
1753     if (it.base_type == OBJ_ORBS
1754         && you.char_direction == GDT_DESCENDING)
1755     {
1756         // Take a note!
1757         _check_note_item(it);
1758
1759         env.orb_pos = you.pos(); // can be wrong in wizmode
1760         orb_pickup_noise(you.pos(), 30);
1761
1762         mpr("The lords of Pandemonium are not amused. Beware!", MSGCH_WARN);
1763
1764         if (you.religion == GOD_CHEIBRIADOS)
1765             simple_god_message(" tells them not to hurry.");
1766
1767         mpr("Now all you have to do is get back out of the dungeon!", MSGCH_ORB);
1768
1769         you.char_direction = GDT_ASCENDING;
1770         xom_is_stimulated(200, XM_INTRIGUED);
1771         invalidate_agrid(true);
1772     }
1773
1774     coord_def p = it.pos;
1775     // If moving an item directly from a monster to the player without the
1776     // item having been on the grid, then it really isn't a position event.
1777     if (in_bounds(p))
1778     {
1779         dungeon_events.fire_position_event(
1780             dgn_event(DET_ITEM_PICKUP, p, 0, obj, -1), p);
1781     }
1782
1783     item_def &item = you.inv[freeslot];
1784     // Copy item.
1785     item        = it;
1786     item.link   = freeslot;
1787     item.slot   = index_to_letter(item.link);
1788     item.pos.set(-1, -1);
1789     // Remove "dropped by ally" flag.
1790     // Also, remove "unobtainable" as it was just proven false.
1791     item.flags &= ~(ISFLAG_DROPPED_BY_ALLY | ISFLAG_UNOBTAINABLE);
1792
1793     god_id_item(item);
1794     maybe_id_weapon(item);
1795     if (item.base_type == OBJ_BOOKS)
1796         maybe_id_book(item, true);
1797
1798     note_inscribe_item(item);
1799
1800     item.quantity = quant_got;
1801     if (is_blood_potion(it))
1802     {
1803         if (quant_got != it.quantity)
1804         {
1805             // Remove oldest timers from original stack.
1806             for (int i = 0; i < quant_got; i++)
1807                 remove_oldest_blood_potion(it);
1808
1809             // ... and newest ones from picked up stack
1810             remove_newest_blood_potion(item);
1811         }
1812     }
1813     dec_mitm_item_quantity(obj, quant_got);
1814     you.m_quiver->on_inv_quantity_changed(freeslot, quant_got);
1815     burden_change();
1816
1817     if (!quiet)
1818     {
1819         mpr_nocap(get_menu_colour_prefix_tags(you.inv[freeslot],
1820                                               DESC_INVENTORY).c_str());
1821     }
1822     if (crawl_state.game_is_hints())
1823     {
1824         taken_new_item(item.base_type);
1825         if (is_artefact(item) || get_equip_desc(item) != ISFLAG_NO_DESC)
1826             learned_something_new(HINT_SEEN_RANDART);
1827     }
1828
1829     _got_item(item, item.quantity);
1830
1831     you.turn_is_over = true;
1832
1833     you.last_pickup[item.link] = retval;
1834
1835     item_skills(item, you.start_train);
1836
1837     return retval;
1838 }
1839
1840 void mark_items_non_pickup_at(const coord_def &pos)
1841 {
1842     int item = igrd(pos);
1843     while (item != NON_ITEM)
1844     {
1845         mitm[item].flags |= ISFLAG_DROPPED;
1846         mitm[item].flags &= ~ISFLAG_THROWN;
1847         item = mitm[item].link;
1848     }
1849 }
1850
1851 void mark_items_non_visit_at(const coord_def &pos)
1852 {
1853     int item = igrd(pos);
1854     while (item != NON_ITEM)
1855     {
1856         if (god_likes_item(you.religion, mitm[item]))
1857             mitm[item].flags |= ISFLAG_DROPPED;
1858         item = mitm[item].link;
1859     }
1860 }
1861
1862 // Moves mitm[obj] to p... will modify the value of obj to
1863 // be the index of the final object (possibly different).
1864 //
1865 // Done this way in the hopes that it will be obvious from
1866 // calling code that "obj" is possibly modified.
1867 //
1868 // Returns false on error or level full - cases where you
1869 // keep the item.
1870 bool move_item_to_grid(int *const obj, const coord_def& p, bool silent)
1871 {
1872     ASSERT_IN_BOUNDS(p);
1873
1874     int& ob(*obj);
1875     // Must be a valid reference to a valid object.
1876     if (ob == NON_ITEM || !mitm[ob].defined())
1877         return false;
1878
1879     item_def& item(mitm[ob]);
1880
1881     if (feat_destroys_item(grd(p), mitm[ob], !silenced(p) && !silent))
1882     {
1883         item_was_destroyed(item, NON_MONSTER);
1884         destroy_item(ob);
1885         ob = NON_ITEM;
1886
1887         return true;
1888     }
1889
1890     if (you.see_cell(p))
1891         god_id_item(item);
1892
1893     // If it's a stackable type...
1894     if (is_stackable_item(item))
1895     {
1896         // Look for similar item to stack:
1897         for (stack_iterator si(p); si; ++si)
1898         {
1899             // Check if item already linked here -- don't want to unlink it.
1900             if (ob == si->index())
1901                 return false;
1902
1903             if (items_stack(item, *si))
1904             {
1905                 // Add quantity to item already here, and dispose
1906                 // of obj, while returning the found item. -- bwr
1907                 inc_mitm_item_quantity(si->index(), item.quantity);
1908                 merge_item_stacks(item, *si);
1909                 destroy_item(ob);
1910                 ob = si->index();
1911                 return true;
1912             }
1913         }
1914     }
1915     // Non-stackable item that's been fudge-stacked (monster throwing weapons).
1916     // Explode the stack when dropped. We have to special case chunks, ew.
1917     else if (item.quantity > 1
1918              && (item.base_type != OBJ_FOOD
1919                  || item.sub_type != FOOD_CHUNK))
1920     {
1921         while (item.quantity > 1)
1922         {
1923             // If we can't copy the items out, we lose the surplus.
1924             if (copy_item_to_grid(item, p, 1, false, true))
1925                 --item.quantity;
1926             else
1927                 item.quantity = 1;
1928         }
1929     }
1930
1931     ASSERT(ob != NON_ITEM);
1932
1933     // Need to actually move object, so first unlink from old position.
1934     unlink_item(ob);
1935
1936     // Move item to coord.
1937     item.pos = p;
1938
1939     // Link item to top of list.
1940     item.link = igrd(p);
1941     igrd(p) = ob;
1942
1943     if (item_is_orb(item))
1944         env.orb_pos = p;
1945
1946     return true;
1947 }
1948
1949 void move_item_stack_to_grid(const coord_def& from, const coord_def& to)
1950 {
1951     if (igrd(from) == NON_ITEM)
1952         return;
1953
1954     // Tell all items in stack what the new coordinate is.
1955     for (stack_iterator si(from); si; ++si)
1956     {
1957         si->pos = to;
1958
1959         // Link last of the stack to the top of the old stack.
1960         if (si->link == NON_ITEM && igrd(to) != NON_ITEM)
1961         {
1962             si->link = igrd(to);
1963             break;
1964         }
1965     }
1966
1967     igrd(to) = igrd(from);
1968     igrd(from) = NON_ITEM;
1969 }
1970
1971
1972 // Returns false if no items could be dropped.
1973 bool copy_item_to_grid(const item_def &item, const coord_def& p,
1974                         int quant_drop, bool mark_dropped, bool silent)
1975 {
1976     ASSERT_IN_BOUNDS(p);
1977
1978     if (quant_drop == 0)
1979         return false;
1980
1981     if (feat_destroys_item(grd(p), item, !silenced(p) && !silent))
1982     {
1983         if (item_is_spellbook(item))
1984             destroy_spellbook(item);
1985
1986         item_was_destroyed(item, NON_MONSTER);
1987
1988         return true;
1989     }
1990
1991     // default quant_drop == -1 => drop all
1992     if (quant_drop < 0)
1993         quant_drop = item.quantity;
1994
1995     // Loop through items at current location.
1996     if (is_stackable_item(item))
1997     {
1998         for (stack_iterator si(p); si; ++si)
1999         {
2000             if (items_stack(item, *si))
2001             {
2002                 inc_mitm_item_quantity(si->index(), quant_drop);
2003                 item_def copy = item;
2004                 merge_item_stacks(copy, *si, quant_drop);
2005
2006                 if (mark_dropped)
2007                 {
2008                     // If the items on the floor already have a nonzero slot,
2009                     // leave it as such, otherwise set the slot.
2010                     if (!si->slot)
2011                         si->slot = index_to_letter(item.link);
2012
2013                     si->flags |= ISFLAG_DROPPED;
2014                     si->flags &= ~ISFLAG_THROWN;
2015                 }
2016                 return true;
2017             }
2018         }
2019     }
2020
2021     // Item not found in current stack, add new item to top.
2022     int new_item_idx = get_mitm_slot(10);
2023     if (new_item_idx == NON_ITEM)
2024         return false;
2025     item_def& new_item = mitm[new_item_idx];
2026
2027     // Copy item.
2028     new_item = item;
2029
2030     // Set quantity, and set the item as unlinked.
2031     new_item.quantity = quant_drop;
2032     new_item.pos.reset();
2033     new_item.link = NON_ITEM;
2034
2035     if (mark_dropped)
2036     {
2037         new_item.slot   = index_to_letter(item.link);
2038         new_item.flags |= ISFLAG_DROPPED;
2039         new_item.flags &= ~ISFLAG_THROWN;
2040         origin_set_unknown(new_item);
2041     }
2042
2043     move_item_to_grid(&new_item_idx, p, true);
2044     if (is_blood_potion(item)
2045         && item.quantity != quant_drop) // partial drop only
2046     {
2047         // Since only the oldest potions have been dropped,
2048         // remove the newest ones.
2049         remove_newest_blood_potion(new_item);
2050     }
2051
2052     return true;
2053 }
2054
2055 coord_def item_pos(const item_def &item)
2056 {
2057     coord_def pos = item.pos;
2058     if (pos.equals(-2, -2))
2059         if (const monster *mon = item.holding_monster())
2060             pos = mon->pos();
2061         else
2062             die("item held by an invalid monster");
2063     else if (pos.equals(-1, -1))
2064         pos = you.pos();
2065     return pos;
2066 }
2067
2068 //---------------------------------------------------------------
2069 //
2070 // move_top_item -- moves the top item of a stack to a new
2071 // location.
2072 //
2073 //---------------------------------------------------------------
2074 bool move_top_item(const coord_def &pos, const coord_def &dest)
2075 {
2076     int item = igrd(pos);
2077     if (item == NON_ITEM)
2078         return false;
2079
2080     dungeon_events.fire_position_event(
2081         dgn_event(DET_ITEM_MOVED, pos, 0, item, -1, dest), pos);
2082
2083     // Now move the item to its new possition...
2084     move_item_to_grid(&item, dest);
2085
2086     return true;
2087 }
2088
2089 const item_def* top_item_at(const coord_def& where)
2090 {
2091     const int link = you.visible_igrd(where);
2092     return (link == NON_ITEM) ? NULL : &mitm[link];
2093 }
2094
2095 bool multiple_items_at(const coord_def& where)
2096 {
2097     int found_count = 0;
2098
2099     for (stack_iterator si(where); si && found_count < 2; ++si)
2100         ++found_count;
2101
2102     return (found_count > 1);
2103 }
2104
2105 bool drop_item(int item_dropped, int quant_drop)
2106 {
2107     if (quant_drop < 0 || quant_drop > you.inv[item_dropped].quantity)
2108         quant_drop = you.inv[item_dropped].quantity;
2109
2110     if (item_dropped == you.equip[EQ_LEFT_RING]
2111      || item_dropped == you.equip[EQ_RIGHT_RING]
2112      || item_dropped == you.equip[EQ_AMULET]
2113      || item_dropped == you.equip[EQ_RING_ONE]
2114      || item_dropped == you.equip[EQ_RING_TWO]
2115      || item_dropped == you.equip[EQ_RING_THREE]
2116      || item_dropped == you.equip[EQ_RING_FOUR]
2117      || item_dropped == you.equip[EQ_RING_FIVE]
2118      || item_dropped == you.equip[EQ_RING_SIX]
2119      || item_dropped == you.equip[EQ_RING_SEVEN]
2120      || item_dropped == you.equip[EQ_RING_EIGHT])
2121     {
2122         if (!Options.easy_unequip)
2123         {
2124             mpr("You will have to take that off first.");
2125             return false;
2126         }
2127
2128         if (remove_ring(item_dropped, true))
2129             start_delay(DELAY_DROP_ITEM, 1, item_dropped, 1);
2130
2131         return false;
2132     }
2133
2134     if (you.inv[item_dropped].base_type == OBJ_ORBS)
2135     {
2136         mpr("You don't feel like leaving the orb behind!");
2137         return false;
2138     }
2139
2140     if (item_dropped == you.equip[EQ_WEAPON]
2141         && you.inv[item_dropped].base_type == OBJ_WEAPONS
2142         && you.inv[item_dropped].cursed())
2143     {
2144         mprf("%s is stuck to you!", you.inv[item_dropped].name(DESC_THE).c_str());
2145         return false;
2146     }
2147
2148     for (int i = EQ_MIN_ARMOUR; i <= EQ_MAX_ARMOUR; i++)
2149     {
2150         if (item_dropped == you.equip[i] && you.equip[i] != -1)
2151         {
2152             if (!Options.easy_unequip)
2153                 mpr("You will have to take that off first.");
2154             else if (check_warning_inscriptions(you.inv[item_dropped],
2155                                                 OPER_TAKEOFF))
2156             {
2157                 // If we take off the item, cue up the item being dropped
2158                 if (takeoff_armour(item_dropped))
2159                     start_delay(DELAY_DROP_ITEM, 1, item_dropped, 1);
2160             }
2161
2162             // Regardless, we want to return here because either we're
2163             // aborting the drop, or the drop is delayed until after
2164             // the armour is removed. -- bwr
2165             return false;
2166         }
2167     }
2168
2169     // [ds] easy_unequip does not apply to weapons.
2170     //
2171     // Unwield needs to be done before copy in order to clear things
2172     // like temporary brands. -- bwr
2173     if (item_dropped == you.equip[EQ_WEAPON]
2174         && quant_drop >= you.inv[item_dropped].quantity)
2175     {
2176         int old_time = you.time_taken;
2177         if (!wield_weapon(true, SLOT_BARE_HANDS))
2178             return false;
2179         // Dropping a wielded item isn't any faster.
2180         you.time_taken = old_time;
2181     }
2182
2183     const dungeon_feature_type my_grid = grd(you.pos());
2184
2185     if (!copy_item_to_grid(you.inv[item_dropped],
2186                             you.pos(), quant_drop, true, true))
2187     {
2188         mpr("Too many items on this level, not dropping the item.");
2189         return false;
2190     }
2191
2192     mprf("You drop %s.",
2193          quant_name(you.inv[item_dropped], quant_drop, DESC_A).c_str());
2194
2195     bool quiet = silenced(you.pos());
2196
2197     // If you drop an item in as a merfolk, it is below the water line and
2198     // makes no noise falling.
2199     if (you.swimming())
2200         quiet = true;
2201
2202     if (feat_destroys_item(my_grid, you.inv[item_dropped], !quiet))
2203         ;
2204     else if (strstr(you.inv[item_dropped].inscription.c_str(), "=s") != 0)
2205         StashTrack.add_stash();
2206
2207     if (is_blood_potion(you.inv[item_dropped])
2208         && you.inv[item_dropped].quantity != quant_drop)
2209     {
2210         // Oldest potions have been dropped.
2211         for (int i = 0; i < quant_drop; i++)
2212             remove_oldest_blood_potion(you.inv[item_dropped]);
2213     }
2214
2215     dec_inv_item_quantity(item_dropped, quant_drop);
2216     you.turn_is_over = true;
2217     you.time_taken = div_rand_round(you.time_taken * 8, 10);
2218
2219     you.last_pickup.erase(item_dropped);
2220
2221     return true;
2222 }
2223
2224 void drop_last()
2225 {
2226     vector<SelItem> items_to_drop;
2227
2228     for (map<int,int>::iterator it = you.last_pickup.begin();
2229         it != you.last_pickup.end(); ++it)
2230     {
2231         const item_def* item = &you.inv[it->first];
2232         if (item->quantity > 0)
2233             items_to_drop.push_back(SelItem(it->first, it->second, item));
2234     }
2235
2236     if (items_to_drop.empty())
2237         mprf("No item to drop.");
2238     else
2239     {
2240         you.last_pickup.clear();
2241         _multidrop(items_to_drop);
2242     }
2243 }
2244
2245 static string _drop_menu_title(const Menu *menu, const string &oldt)
2246 {
2247     string res = _menu_burden_invstatus(menu) + " " + oldt;
2248     if (menu->is_set(MF_SINGLESELECT))
2249         res = "[Single drop] " + res;
2250
2251     return res;
2252 }
2253
2254 int get_equip_slot(const item_def *item)
2255 {
2256     int worn = -1;
2257     if (item && in_inventory(*item))
2258     {
2259         for (int i = 0; i < NUM_EQUIP; ++i)
2260         {
2261             if (you.equip[i] == item->link)
2262             {
2263                 worn = i;
2264                 break;
2265             }
2266         }
2267     }
2268     return worn;
2269 }
2270
2271 mon_inv_type get_mon_equip_slot(const monster* mon, const item_def &item)
2272 {
2273     ASSERT(mon->alive());
2274
2275     mon_inv_type slot = item_to_mslot(item);
2276
2277     if (slot == NUM_MONSTER_SLOTS)
2278         return NUM_MONSTER_SLOTS;
2279
2280     if (mon->mslot_item(slot) == &item)
2281         return slot;
2282
2283     if (slot == MSLOT_WEAPON && mon->mslot_item(MSLOT_ALT_WEAPON) == &item)
2284         return MSLOT_ALT_WEAPON;
2285
2286     return NUM_MONSTER_SLOTS;
2287 }
2288
2289 static string _drop_selitem_text(const vector<MenuEntry*> *s)
2290 {
2291     bool extraturns = false;
2292
2293     if (s->empty())
2294         return "";
2295
2296     for (int i = 0, size = s->size(); i < size; ++i)
2297     {
2298         const item_def *item = static_cast<item_def *>((*s)[i]->data);
2299         const int eq = get_equip_slot(item);
2300         if (eq > EQ_WEAPON && eq < NUM_EQUIP)
2301         {
2302             extraturns = true;
2303             break;
2304         }
2305     }
2306
2307     return (make_stringf(" (%u%s turn%s)",
2308                 (unsigned int)s->size(),
2309                 extraturns? "+" : "",
2310                 s->size() > 1? "s" : ""));
2311 }
2312
2313 vector<SelItem> items_for_multidrop;
2314
2315 // Arrange items that have been selected for multidrop so that
2316 // equipped items are dropped after other items, and equipped items
2317 // are dropped in the same order as their EQ_ slots are numbered.
2318 static bool _drop_item_order(const SelItem &first, const SelItem &second)
2319 {
2320     const item_def &i1 = you.inv[first.slot];
2321     const item_def &i2 = you.inv[second.slot];
2322
2323     const int slot1 = get_equip_slot(&i1),
2324               slot2 = get_equip_slot(&i2);
2325
2326     if (slot1 != -1 && slot2 != -1)
2327         return (slot1 < slot2);
2328     else if (slot1 != -1 && slot2 == -1)
2329         return false;
2330     else if (slot2 != -1 && slot1 == -1)
2331         return true;
2332
2333     return (first.slot < second.slot);
2334 }
2335
2336 //---------------------------------------------------------------
2337 //
2338 // drop
2339 //
2340 // Prompts the user for an item to drop
2341 //
2342 //---------------------------------------------------------------
2343 void drop()
2344 {
2345     if (inv_count() < 1 && you.gold == 0)
2346     {
2347         canned_msg(MSG_NOTHING_CARRIED);
2348         return;
2349     }
2350
2351     vector<SelItem> tmp_items;
2352 #ifdef TOUCH_UI
2353     tmp_items = prompt_invent_items("Drop what? (<Enter> or tap header to drop)",
2354                                     MT_DROP,
2355 #else
2356     tmp_items = prompt_invent_items("Drop what? (_ for help)", MT_DROP,
2357 #endif
2358                                      -1, _drop_menu_title, true, true, 0,
2359                                      &Options.drop_filter, _drop_selitem_text,
2360                                      &items_for_multidrop);
2361
2362     if (tmp_items.empty())
2363     {
2364         canned_msg(MSG_OK);
2365         return;
2366     }
2367
2368     _multidrop(tmp_items);
2369 }
2370
2371 static void _multidrop(vector<SelItem> tmp_items)
2372 {
2373     // Sort the dropped items so we don't see weird behaviour when
2374     // dropping a worn robe before a cloak (old behaviour: remove
2375     // cloak, remove robe, wear cloak, drop robe, remove cloak, drop
2376     // cloak).
2377     sort(tmp_items.begin(), tmp_items.end(), _drop_item_order);
2378
2379     // If the user answers "no" to an item an with a warning inscription,
2380     // then remove it from the list of items to drop by not copying it
2381     // over to items_for_multidrop.
2382     items_for_multidrop.clear();
2383     for (unsigned int i = 0; i < tmp_items.size(); ++i)
2384     {
2385         SelItem& si(tmp_items[i]);
2386
2387         const int item_quant = si.item->quantity;
2388
2389         // EVIL HACK: Fix item quantity to match the quantity we will drop,
2390         // in order to prevent misleading messages when dropping
2391         // 15 of 25 arrows inscribed with {!d}.
2392         if (si.quantity && si.quantity != item_quant)
2393             const_cast<item_def*>(si.item)->quantity = si.quantity;
2394
2395         // Check if we can add it to the multidrop list.
2396         bool warning_ok = check_warning_inscriptions(*(si.item), OPER_DROP);
2397
2398         // Restore the item quantity if we mangled it.
2399         if (item_quant != si.item->quantity)
2400             const_cast<item_def*>(si.item)->quantity = item_quant;
2401
2402         if (warning_ok)
2403             items_for_multidrop.push_back(si);
2404     }
2405
2406     if (items_for_multidrop.empty()) // no items.
2407     {
2408         canned_msg(MSG_OK);
2409         return;
2410     }
2411
2412     if (items_for_multidrop.size() == 1) // only one item
2413     {
2414         drop_item(items_for_multidrop[0].slot, items_for_multidrop[0].quantity);
2415         items_for_multidrop.clear();
2416     }
2417     else
2418         start_delay(DELAY_MULTIDROP, items_for_multidrop.size());
2419 }
2420
2421 static void _autoinscribe_item(item_def& item)
2422 {
2423     // If there's an inscription already, do nothing - except
2424     // for automatically generated inscriptions
2425     if (!item.inscription.empty())
2426         return;
2427     const string old_inscription = item.inscription;
2428     item.inscription.clear();
2429
2430     string iname = _autopickup_item_name(item);
2431
2432     for (unsigned i = 0; i < Options.autoinscriptions.size(); ++i)
2433     {
2434         if (Options.autoinscriptions[i].first.matches(iname))
2435         {
2436             // Don't autoinscribe dropped items on ground with
2437             // "=g".  If the item matches a rule which adds "=g",
2438             // "=g" got added to it before it was dropped, and
2439             // then the user explicitly removed it because they
2440             // don't want to autopickup it again.
2441             string str = Options.autoinscriptions[i].second;
2442             if ((item.flags & ISFLAG_DROPPED) && !in_inventory(item))
2443                 str = replace_all(str, "=g", "");
2444
2445             // Note that this might cause the item inscription to
2446             // pass 80 characters.
2447             item.inscription += str;
2448         }
2449     }
2450     if (!old_inscription.empty())
2451     {
2452         if (item.inscription.empty())
2453             item.inscription = old_inscription;
2454         else
2455             item.inscription = old_inscription + ", " + item.inscription;
2456     }
2457 }
2458
2459 static void _autoinscribe_floor_items()
2460 {
2461     for (stack_iterator si(you.pos()); si; ++si)
2462         _autoinscribe_item(*si);
2463 }
2464
2465 static void _autoinscribe_inventory()
2466 {
2467     for (int i = 0; i < ENDOFPACK; i++)
2468         if (you.inv[i].defined())
2469             _autoinscribe_item(you.inv[i]);
2470 }
2471
2472 bool need_to_autoinscribe()
2473 {
2474     return will_autoinscribe;
2475 }
2476
2477 void request_autoinscribe(bool do_inscribe)
2478 {
2479     will_autoinscribe = do_inscribe;
2480 }
2481
2482 void autoinscribe()
2483 {
2484     _autoinscribe_floor_items();
2485     _autoinscribe_inventory();
2486
2487     will_autoinscribe = false;
2488 }
2489
2490 static int _autopickup_subtype(const item_def &item)
2491 {
2492     // Sensed items.
2493     if (item.base_type >= NUM_OBJECT_CLASSES)
2494         return MAX_SUBTYPES - 1;
2495
2496     const int max_type = get_max_subtype(item.base_type);
2497
2498     // item_infos of unknown subtype.
2499     if (max_type > 0 && item.sub_type >= max_type)
2500         return max_type;
2501
2502     // Only where item_type_known() refers to the subtype (as opposed to the
2503     // brand, for example) do we have to check it.  For weapons etc. we always
2504     // know the subtype.
2505     switch (item.base_type)
2506     {
2507     case OBJ_WANDS:
2508     case OBJ_SCROLLS:
2509     case OBJ_JEWELLERY:
2510     case OBJ_POTIONS:
2511     case OBJ_STAVES:
2512         return item_type_known(item) ? item.sub_type : max_type;
2513     case OBJ_FOOD:
2514         return (item.sub_type == FOOD_CHUNK) ? item.sub_type
2515              : food_is_meaty(item)           ? FOOD_MEAT_RATION
2516              : is_fruit(item)                ? FOOD_PEAR
2517                                              : FOOD_HONEYCOMB;
2518     case OBJ_MISCELLANY:
2519         return (item.sub_type == MISC_RUNE_OF_ZOT) ? item.sub_type : max_type;
2520     case OBJ_BOOKS:
2521         return (item.sub_type == BOOK_MANUAL) ? item.sub_type : max_type;
2522     case OBJ_RODS:
2523     case OBJ_GOLD:
2524         return max_type;
2525     default:
2526         return item.sub_type;
2527     }
2528 }
2529
2530 static bool _is_option_autopickup(const item_def &item, string &iname)
2531 {
2532     if (iname.empty())
2533         iname = _autopickup_item_name(item);
2534
2535     if (item.base_type < NUM_OBJECT_CLASSES)
2536     {
2537         const int force = you.force_autopickup[item.base_type][_autopickup_subtype(item)];
2538         if (force != 0)
2539             return (force == 1);
2540     }
2541     else
2542         return false;
2543
2544     //Check for initial settings
2545     for (int i = 0; i < (int)Options.force_autopickup.size(); ++i)
2546         if (Options.force_autopickup[i].first.matches(iname))
2547             return Options.force_autopickup[i].second;
2548
2549 #ifdef CLUA_BINDINGS
2550     bool res = clua.callbooleanfn(false, "ch_force_autopickup", "is",
2551                                         &item, iname.c_str());
2552     if (!clua.error.empty())
2553     {
2554         mprf(MSGCH_ERROR, "ch_force_autopickup failed: %s",
2555              clua.error.c_str());
2556     }
2557
2558     if (res)
2559         return true;
2560
2561     res = clua.callbooleanfn(false, "ch_deny_autopickup", "is",
2562                              &item, iname.c_str());
2563     if (!clua.error.empty())
2564     {
2565         mprf(MSGCH_ERROR, "ch_deny_autopickup failed: %s",
2566              clua.error.c_str());
2567     }
2568
2569     if (res)
2570         return false;
2571 #endif
2572
2573     return Options.autopickups[item.base_type];
2574 }
2575
2576 bool item_needs_autopickup(const item_def &item)
2577 {
2578     if (item_is_stationary(item))
2579         return false;
2580
2581     if (item.inscription.find("=g") != string::npos)
2582         return true;
2583
2584     if ((item.flags & ISFLAG_THROWN) && Options.pickup_thrown)
2585         return true;
2586
2587     if (item.flags & ISFLAG_DROPPED)
2588         return false;
2589
2590     if (item.props.exists("needs_autopickup"))
2591         return true;
2592
2593     string itemname;
2594     return _is_option_autopickup(item, itemname);
2595 }
2596
2597 bool can_autopickup()
2598 {
2599     // [ds] Checking for autopickups == 0 is a bad idea because
2600     // autopickup is still possible with inscriptions and
2601     // pickup_thrown.
2602     if (Options.autopickup_on <= 0)
2603         return false;
2604
2605     if (!i_feel_safe())
2606         return false;
2607
2608     return true;
2609 }
2610
2611 typedef bool (*item_comparer)(const item_def& pickup_item,
2612                               const item_def& inv_item);
2613
2614 static bool _identical_types(const item_def& pickup_item,
2615                              const item_def& inv_item)
2616 {
2617     return ((pickup_item.base_type == inv_item.base_type)
2618             && (pickup_item.sub_type == inv_item.sub_type));
2619 }
2620
2621 static bool _edible_food(const item_def& pickup_item,
2622                          const item_def& inv_item)
2623 {
2624     return (inv_item.base_type == OBJ_FOOD && !is_inedible(inv_item));
2625 }
2626
2627 static bool _similar_equip(const item_def& pickup_item,
2628                            const item_def& inv_item)
2629 {
2630     const equipment_type inv_slot = get_item_slot(inv_item);
2631
2632     if (inv_slot == EQ_NONE)
2633         return false;
2634
2635     // If it's an unequipped cursed item the player might be looking
2636     // for a replacement.
2637     if (item_known_cursed(inv_item) && !item_is_equipped(inv_item))
2638         return false;
2639
2640     if (get_item_slot(pickup_item) != inv_slot)
2641         return false;
2642
2643     // Just filling the same slot is enough for armour to be considered
2644     // similar.
2645     if (pickup_item.base_type == OBJ_ARMOUR)
2646         return true;
2647
2648     // Launchers of the same type are similar.
2649     if ((pickup_item.sub_type >= WPN_BLOWGUN
2650          && pickup_item.sub_type <= WPN_LONGBOW)
2651              || pickup_item.sub_type == WPN_SLING)
2652     {
2653         return (pickup_item.sub_type != inv_item.sub_type);
2654     }
2655
2656     return ((weapon_skill(pickup_item) == weapon_skill(inv_item))
2657             && (get_damage_type(pickup_item) == get_damage_type(inv_item)));
2658 }
2659
2660 static bool _similar_wands(const item_def& pickup_item,
2661                            const item_def& inv_item)
2662 {
2663     if (inv_item.base_type != OBJ_WANDS)
2664         return false;
2665
2666     if (pickup_item.sub_type != inv_item.sub_type)
2667         return false;
2668
2669     // Not similar if wand in inventory is known to be empty.
2670     return (inv_item.plus2 != ZAPCOUNT_EMPTY
2671             || (item_ident(inv_item, ISFLAG_KNOW_PLUSES)
2672                 && inv_item.plus > 0));
2673 }
2674
2675 static bool _similar_jewellery(const item_def& pickup_item,
2676                                const item_def& inv_item)
2677 {
2678     if (inv_item.base_type != OBJ_JEWELLERY)
2679         return false;
2680
2681     if (pickup_item.sub_type != inv_item.sub_type)
2682         return false;
2683
2684     // For jewellery of the same sub-type, unidentified jewellery is
2685     // always considered similar, as is identified jewellery whose
2686     // effect doesn't stack.
2687     return (!item_type_known(inv_item)
2688             || (!jewellery_is_amulet(inv_item)
2689                 && !ring_has_stackable_effect(inv_item)));
2690 }
2691
2692 static bool _item_different_than_inv(const item_def& pickup_item,
2693                                      item_comparer comparer)
2694 {
2695     for (int i = 0; i < ENDOFPACK; i++)
2696     {
2697         const item_def& inv_item(you.inv[i]);
2698
2699         if (!inv_item.defined())
2700             continue;
2701
2702         if ((*comparer)(pickup_item, inv_item))
2703             return false;
2704     }
2705
2706     return true;
2707 }
2708
2709 static bool _interesting_explore_pickup(const item_def& item)
2710 {
2711     if (!(Options.explore_stop & ES_GREEDY_PICKUP_MASK))
2712         return false;
2713
2714     if (item.base_type == OBJ_GOLD)
2715         return (Options.explore_stop & ES_GREEDY_PICKUP_GOLD);
2716
2717     if ((Options.explore_stop & ES_GREEDY_PICKUP_THROWN)
2718         && (item.flags & ISFLAG_THROWN))
2719     {
2720         return true;
2721     }
2722
2723     vector<text_pattern> &ignores = Options.explore_stop_pickup_ignore;
2724     if (!ignores.empty())
2725     {
2726         const string name = item.name(DESC_PLAIN);
2727
2728         for (unsigned int i = 0; i < ignores.size(); i++)
2729             if (ignores[i].matches(name))
2730                 return false;
2731     }
2732
2733     if (!(Options.explore_stop & ES_GREEDY_PICKUP_SMART))
2734         return true;
2735     // "Smart" code follows.
2736
2737     // If ES_GREEDY_PICKUP_THROWN isn't set, then smart greedy pickup
2738     // will ignore thrown items.
2739     if (item.flags & ISFLAG_THROWN)
2740         return false;
2741
2742     if (is_artefact(item))
2743         return true;
2744
2745     // Possbible ego items.
2746     if (!item_type_known(item) & (item.flags & ISFLAG_COSMETIC_MASK))
2747         return true;
2748
2749     switch (item.base_type)
2750     {
2751     case OBJ_WEAPONS:
2752     case OBJ_MISSILES:
2753     case OBJ_ARMOUR:
2754         // Ego items.
2755         if (item.special != 0)
2756             return true;
2757         break;
2758
2759     default:
2760         break;
2761     }
2762
2763     switch (item.base_type)
2764     {
2765     case OBJ_WEAPONS:
2766     case OBJ_ARMOUR:
2767         return _item_different_than_inv(item, _similar_equip);
2768
2769     case OBJ_WANDS:
2770         return _item_different_than_inv(item, _similar_wands);
2771
2772     case OBJ_JEWELLERY:
2773         return _item_different_than_inv(item, _similar_jewellery);
2774
2775     case OBJ_FOOD:
2776         if (you.religion == GOD_FEDHAS && is_fruit(item))
2777             return true;
2778
2779         if (is_inedible(item))
2780             return false;
2781
2782         // Interesting if we don't have any other edible food.
2783         return _item_different_than_inv(item, _edible_food);
2784
2785     case OBJ_RODS:
2786         // Rods are always interesting, even if you already have one of
2787         // the same type, since each rod has its own mana.
2788         return true;
2789
2790         // Intentional fall-through.
2791     case OBJ_MISCELLANY:
2792         // Runes are always interesting.
2793         if (item_is_rune(item))
2794             return true;
2795
2796         // Decks always start out unidentified.
2797         if (is_deck(item))
2798             return true;
2799
2800         // Intentional fall-through.
2801     case OBJ_SCROLLS:
2802     case OBJ_POTIONS:
2803     case OBJ_STAVES:
2804         // Item is boring only if there's an identical one in inventory.
2805         return _item_different_than_inv(item, _identical_types);
2806
2807     case OBJ_BOOKS:
2808         // Books always start out unidentified.
2809         return true;
2810
2811     case OBJ_ORBS:
2812         // Orb is always interesting.
2813         return true;
2814
2815     default:
2816         break;
2817     }
2818
2819     return false;
2820 }
2821
2822 static void _do_autopickup()
2823 {
2824     bool did_pickup     = false;
2825     int  n_did_pickup   = 0;
2826     int  n_tried_pickup = 0;
2827
2828     will_autopickup = false;
2829
2830     if (!can_autopickup())
2831     {
2832         item_check(false);
2833         return;
2834     }
2835
2836     // Store last_pickup in case we need to restore it.
2837     // Then clear it to fill with items picked up.
2838     map<int,int> tmp_l_p = you.last_pickup;
2839     you.last_pickup.clear();
2840
2841     int o = you.visible_igrd(you.pos());
2842
2843     string pickup_warning;
2844     while (o != NON_ITEM)
2845     {
2846         const int next = mitm[o].link;
2847
2848         if (item_needs_autopickup(mitm[o]))
2849         {
2850             int num_to_take = mitm[o].quantity;
2851             int unit_mass = item_mass(mitm[o]);
2852             if (Options.autopickup_no_burden && unit_mass != 0)
2853             {
2854                 int capacity = carrying_capacity(you.burden_state);
2855                 int num_can_take = (capacity - you.burden) / unit_mass;
2856
2857                 if (num_can_take < num_to_take
2858                     && drop_spoiled_chunks(you.burden
2859                            + num_to_take * unit_mass - capacity))
2860                 {
2861                     // Yay, some new space, retry.
2862                     // Compare to the old burden capacity, not the new one.
2863                     num_can_take = (capacity - you.burden) / unit_mass;
2864                 }
2865
2866                 if (num_can_take < num_to_take)
2867                 {
2868                     if (!n_tried_pickup)
2869                     {
2870                         mpr("You can't pick everything up without burdening "
2871                             "yourself.");
2872                     }
2873                     n_tried_pickup++;
2874                     num_to_take = num_can_take;
2875                 }
2876
2877                 if (num_can_take == 0)
2878                 {
2879                     o = next;
2880                     continue;
2881                 }
2882             }
2883
2884             // Do this before it's picked up, otherwise the picked up
2885             // item will be in inventory and _interesting_explore_pickup()
2886             // will always return false.
2887             const bool interesting_pickup
2888                 = _interesting_explore_pickup(mitm[o]);
2889
2890             const iflags_t iflags(mitm[o].flags);
2891             if ((iflags & ISFLAG_THROWN))
2892                 learned_something_new(HINT_AUTOPICKUP_THROWN);
2893
2894             mitm[o].flags &= ~(ISFLAG_THROWN | ISFLAG_DROPPED);
2895
2896             const int result = move_item_to_player(o, num_to_take);
2897
2898             if (result == 0 || result == -1)
2899             {
2900                 n_tried_pickup++;
2901                 if (result == 0)
2902                     pickup_warning = "You can't carry any more.";
2903                 else
2904                     pickup_warning = "Your pack is full.";
2905                 mitm[o].flags = iflags;
2906             }
2907             else
2908             {
2909                 did_pickup = true;
2910                 if (interesting_pickup)
2911                     n_did_pickup++;
2912             }
2913         }
2914
2915         o = next;
2916     }
2917
2918     if (!pickup_warning.empty())
2919         mpr(pickup_warning.c_str());
2920
2921     if (did_pickup)
2922         you.turn_is_over = true;
2923
2924     if (you.last_pickup.empty())
2925         you.last_pickup = tmp_l_p;
2926
2927     item_check(false);
2928
2929     explore_pickup_event(n_did_pickup, n_tried_pickup);
2930 }
2931
2932 void autopickup()
2933 {
2934     _autoinscribe_floor_items();
2935     _do_autopickup();
2936 }
2937
2938 int inv_count(void)
2939 {
2940     int count = 0;
2941
2942     for (int i = 0; i < ENDOFPACK; i++)
2943         if (you.inv[i].defined())
2944             count++;
2945
2946     return count;
2947 }
2948
2949 item_def *find_floor_item(object_class_type cls, int sub_type)
2950 {
2951     for (int y = 0; y < GYM; ++y)
2952         for (int x = 0; x < GXM; ++x)
2953             for (stack_iterator si(coord_def(x,y)); si; ++si)
2954                 if (si->defined()
2955                     && si->base_type == cls && si->sub_type == sub_type
2956                     && !(si->flags & ISFLAG_MIMIC))
2957                 {
2958                     return &*si;
2959                 }
2960
2961     return NULL;
2962 }
2963
2964 int item_on_floor(const item_def &item, const coord_def& where)
2965 {
2966     // Check if the item is on the floor and reachable.
2967     for (int link = igrd(where); link != NON_ITEM; link = mitm[link].link)
2968         if (&mitm[link] == &item)
2969             return link;
2970
2971     return NON_ITEM;
2972 }
2973
2974 int get_max_subtype(object_class_type base_type)
2975 {
2976     static int max_subtype[] =
2977     {
2978         NUM_WEAPONS,
2979         NUM_MISSILES,
2980         NUM_ARMOURS,
2981         NUM_WANDS,
2982         NUM_FOODS,
2983         NUM_SCROLLS,
2984         NUM_JEWELLERY,
2985         NUM_POTIONS,
2986         NUM_BOOKS,
2987         NUM_STAVES,
2988         1,              // Orbs         -- only one
2989         NUM_MISCELLANY,
2990         -1,              // corpses     -- handled specially
2991         1,              // gold         -- handled specially
2992         NUM_RODS,
2993     };
2994     COMPILE_CHECK(ARRAYSZ(max_subtype) == NUM_OBJECT_CLASSES);
2995
2996     ASSERT(base_type < NUM_OBJECT_CLASSES);
2997
2998     return max_subtype[base_type];
2999 }
3000
3001 equipment_type item_equip_slot(const item_def& item)
3002 {
3003     if (!in_inventory(item))
3004         return EQ_NONE;
3005
3006     for (int i = 0; i < NUM_EQUIP; i++)
3007         if (item.link == you.equip[i])
3008             return static_cast<equipment_type>(i);
3009
3010     return EQ_NONE;
3011 }
3012
3013 // Includes melded items.
3014 bool item_is_equipped(const item_def &item, bool quiver_too)
3015 {
3016     return (item_equip_slot(item) != EQ_NONE
3017             || quiver_too && in_inventory(item)
3018                && item.link == you.m_quiver->get_fire_item());
3019 }
3020
3021 bool item_is_melded(const item_def& item)
3022 {
3023     equipment_type eq = item_equip_slot(item);
3024     return (eq != EQ_NONE && you.melded[eq]);
3025 }
3026
3027 ////////////////////////////////////////////////////////////////////////
3028 // item_def functions.
3029
3030 bool item_def::has_spells() const
3031 {
3032     return (item_is_spellbook(*this) && item_type_known(*this)
3033             || count_rod_spells(*this, true) > 0);
3034 }
3035
3036 int item_def::book_number() const
3037 {
3038     return (base_type == OBJ_BOOKS  ? sub_type :
3039             base_type == OBJ_RODS   ? sub_type + NUM_FIXED_BOOKS
3040                                     : -1);
3041 }
3042
3043 bool item_def::cursed() const
3044 {
3045     return (flags & ISFLAG_CURSED);
3046 }
3047
3048 bool item_def::launched_by(const item_def &launcher) const
3049 {
3050     if (base_type != OBJ_MISSILES)
3051         return false;
3052     const missile_type mt = fires_ammo_type(launcher);
3053     return (sub_type == mt || (mt == MI_STONE && sub_type == MI_SLING_BULLET));
3054 }
3055
3056 zap_type item_def::zap() const
3057 {
3058     if (base_type != OBJ_WANDS)
3059         return ZAP_DEBUGGING_RAY;
3060
3061     zap_type result = ZAP_DEBUGGING_RAY;
3062     wand_type wand_sub_type = static_cast<wand_type>(sub_type);
3063
3064     if (wand_sub_type == WAND_RANDOM_EFFECTS)
3065     {
3066         while (wand_sub_type == WAND_RANDOM_EFFECTS
3067                || wand_sub_type == WAND_HEAL_WOUNDS)
3068         {
3069             wand_sub_type = static_cast<wand_type>(random2(NUM_WANDS));
3070         }
3071     }
3072
3073     switch (wand_sub_type)
3074     {
3075     case WAND_FLAME:           result = ZAP_THROW_FLAME;     break;
3076     case WAND_FROST:           result = ZAP_THROW_FROST;     break;
3077     case WAND_SLOWING:         result = ZAP_SLOW;            break;
3078     case WAND_HASTING:         result = ZAP_HASTE;           break;
3079     case WAND_MAGIC_DARTS:     result = ZAP_MAGIC_DART;      break;
3080     case WAND_HEAL_WOUNDS:     result = ZAP_MAJOR_HEALING;   break;
3081     case WAND_PARALYSIS:       result = ZAP_PARALYSE;        break;
3082     case WAND_FIRE:            result = ZAP_BOLT_OF_FIRE;    break;
3083     case WAND_COLD:            result = ZAP_BOLT_OF_COLD;    break;
3084     case WAND_CONFUSION:       result = ZAP_CONFUSE;         break;
3085     case WAND_INVISIBILITY:    result = ZAP_INVISIBILITY;    break;
3086     case WAND_DIGGING:         result = ZAP_DIG;             break;
3087     case WAND_FIREBALL:        result = ZAP_FIREBALL;        break;
3088     case WAND_TELEPORTATION:   result = ZAP_TELEPORT_OTHER;  break;
3089     case WAND_LIGHTNING:       result = ZAP_LIGHTNING_BOLT;  break;
3090     case WAND_POLYMORPH:       result = ZAP_POLYMORPH;       break;
3091     case WAND_ENSLAVEMENT:     result = ZAP_ENSLAVEMENT;     break;
3092     case WAND_DRAINING:        result = ZAP_BOLT_OF_DRAINING; break;
3093     case WAND_DISINTEGRATION:  result = ZAP_DISINTEGRATE;    break;
3094     case WAND_RANDOM_EFFECTS:  /* impossible */
3095     case NUM_WANDS: break;
3096     }
3097     return result;
3098 }
3099
3100 int item_def::index() const
3101 {
3102     return (this - mitm.buffer());
3103 }
3104
3105 int item_def::armour_rating() const
3106 {
3107     if (!defined() || base_type != OBJ_ARMOUR)
3108         return 0;
3109
3110     return (property(*this, PARM_AC) + plus);
3111 }
3112
3113 monster* item_def::holding_monster() const
3114 {
3115     if (!pos.equals(-2, -2))
3116         return NULL;
3117     const int midx = link - NON_ITEM - 1;
3118     if (invalid_monster_index(midx))
3119         return NULL;
3120
3121     return &menv[midx];
3122 }
3123
3124 void item_def::set_holding_monster(int midx)
3125 {
3126     ASSERT(midx != NON_MONSTER);
3127     pos.set(-2, -2);
3128     link = NON_ITEM + 1 + midx;
3129 }
3130
3131 bool item_def::held_by_monster() const
3132 {
3133     return (pos.equals(-2, -2) && !invalid_monster_index(link - NON_ITEM - 1));
3134 }
3135
3136 // Note:  This function is to isolate all the checks to see if
3137 //        an item is valid (often just checking the quantity).
3138 //
3139 //        It shouldn't be used a a substitute for those cases
3140 //        which actually want to check the quantity (as the
3141 //        rules for unused objects might change).
3142 bool item_def::defined() const
3143 {
3144     return (base_type != OBJ_UNASSIGNED && quantity > 0);
3145 }
3146
3147 bool item_type_has_unidentified(object_class_type base_type)
3148 {
3149     return base_type == OBJ_WANDS
3150         || base_type == OBJ_SCROLLS
3151         || base_type == OBJ_JEWELLERY
3152         || base_type == OBJ_POTIONS
3153         || base_type == OBJ_BOOKS
3154         || base_type == OBJ_STAVES
3155         || base_type == OBJ_RODS
3156         || base_type == OBJ_MISCELLANY;
3157 }
3158
3159 // Checks whether the item is actually a good one.
3160 // TODO: check brands, etc.
3161 bool item_def::is_valid(bool iinfo) const
3162 {
3163     if (base_type == OBJ_DETECTED)
3164         return iinfo;
3165     else if (!defined())
3166         return false;
3167     const int max_sub = get_max_subtype(base_type);
3168     if (max_sub != -1 && sub_type >= max_sub)
3169     {
3170         if (!iinfo || sub_type > max_sub || !item_type_has_unidentified(base_type))
3171             return false;
3172     }
3173     if (colour == 0)
3174         return false; // No black items.
3175     return true;
3176 }
3177
3178 // The Orb of Zot and unique runes are considered critical.
3179 bool item_def::is_critical() const
3180 {
3181     if (!defined())
3182         return false;
3183
3184     if (base_type == OBJ_ORBS)
3185         return true;
3186
3187     return (base_type == OBJ_MISCELLANY
3188             && sub_type == MISC_RUNE_OF_ZOT
3189             && plus != RUNE_DEMONIC
3190             && plus != RUNE_ABYSSAL);
3191 }
3192
3193 // Is item something that no one would usually bother enchanting?
3194 bool item_def::is_mundane() const
3195 {
3196     switch (base_type)
3197     {
3198     case OBJ_WEAPONS:
3199         if (sub_type == WPN_CLUB
3200             || is_giant_club_type(sub_type))
3201         {
3202             return true;
3203         }
3204         break;
3205
3206     case OBJ_ARMOUR:
3207         if (sub_type == ARM_ANIMAL_SKIN)
3208             return true;
3209         break;
3210
3211     default:
3212         break;
3213     }
3214
3215     return false;
3216 }
3217
3218 // Does the item causes autoexplore to visit it. It excludes ?RC for Ash,
3219 // disabled items for Nemelex and items already visited (dropped flag).
3220 bool item_def::is_greedy_sacrificeable() const
3221 {
3222     if (!god_likes_items(you.religion, true))
3223         return false;
3224
3225     if (you.religion == GOD_NEMELEX_XOBEH
3226         && !check_nemelex_sacrificing_item_type(*this)
3227         || flags & (ISFLAG_DROPPED | ISFLAG_THROWN)
3228         || item_is_stationary(*this))
3229     {
3230         return false;
3231     }
3232
3233     return god_likes_item(you.religion, *this);
3234 }
3235
3236 static void _rune_from_specs(const char* _specs, item_def &item)
3237 {
3238     char specs[80];
3239
3240     item.sub_type = MISC_RUNE_OF_ZOT;
3241
3242     if (strstr(_specs, "rune of zot"))
3243     {
3244         strlcpy(specs, _specs, min(strlen(_specs) - strlen(" of zot") + 1,
3245                                    sizeof(specs)));
3246     }
3247     else
3248         strlcpy(specs, _specs, sizeof(specs));
3249
3250     if (strlen(specs) > 4)
3251     {
3252         for (int i = 0; i < NUM_RUNE_TYPES; ++i)
3253         {
3254             item.plus = i;
3255
3256             if (lowercase_string(item.name(DESC_PLAIN)).find(specs) != string::npos)
3257                 return;
3258         }
3259     }
3260
3261     while (true)
3262     {
3263         string line;
3264         for (int i = 0; i < NUM_RUNE_TYPES; i++)
3265         {
3266             line += make_stringf("[%c] %-10s ", i + 'a', rune_type_name(i));
3267             if (i % 5 == 4 || i == NUM_RUNE_TYPES - 1)
3268             {
3269                 mpr(line, MSGCH_PROMPT);
3270                 line.clear();
3271             }
3272         }
3273         mpr("Which rune (ESC to exit)? ", MSGCH_PROMPT);
3274
3275         int keyin = toalower(get_ch());
3276
3277         if (key_is_escape(keyin) || keyin == ' '
3278             || keyin == '\r' || keyin == '\n')
3279         {
3280             canned_msg(MSG_OK);
3281             item.base_type = OBJ_UNASSIGNED;
3282             return;
3283         }
3284
3285         if (keyin < 'a' || keyin >= 'a' + NUM_RUNE_TYPES)
3286             continue;
3287
3288         item.plus = keyin - 'a';
3289
3290         return;
3291     }
3292 }
3293
3294 static void _deck_from_specs(const char* _specs, item_def &item)
3295 {
3296     string specs    = _specs;
3297     string type_str = "";
3298
3299     trim_string(specs);
3300
3301     if (specs.find(" of ") != string::npos)
3302     {
3303         type_str = specs.substr(specs.find(" of ") + 4);
3304
3305         if (type_str.find("card") != string::npos
3306             || type_str.find("deck") != string::npos)
3307         {
3308             type_str = "";
3309         }
3310
3311         trim_string(type_str);
3312     }
3313
3314     misc_item_type types[] = {
3315         MISC_DECK_OF_ESCAPE,
3316         MISC_DECK_OF_DESTRUCTION,
3317         MISC_DECK_OF_DUNGEONS,
3318         MISC_DECK_OF_SUMMONING,
3319         MISC_DECK_OF_WONDERS,
3320         MISC_DECK_OF_PUNISHMENT,
3321         MISC_DECK_OF_WAR,
3322         MISC_DECK_OF_CHANGES,
3323         MISC_DECK_OF_DEFENCE,
3324         NUM_MISCELLANY
3325     };
3326
3327     item.special  = DECK_RARITY_COMMON;
3328     item.sub_type = NUM_MISCELLANY;
3329
3330     if (!type_str.empty())
3331     {
3332         for (int i = 0; types[i] != NUM_MISCELLANY; ++i)
3333         {
3334             item.sub_type = types[i];
3335             item.plus     = 1;
3336             init_deck(item);
3337             // Remove "plain " from front.
3338             string name = item.name(DESC_PLAIN).substr(6);
3339             item.props.clear();
3340
3341             if (name.find(type_str) != string::npos)
3342                 break;
3343         }
3344     }
3345
3346     if (item.sub_type == NUM_MISCELLANY)
3347     {
3348         while (true)
3349         {
3350             mpr(
3351 "[a] escape     [b] destruction [c] dungeons [d] summoning [e] wonders",
3352                 MSGCH_PROMPT);
3353             mpr(
3354 "[f] punishment [g] war         [h] changes  [i] defence",
3355                 MSGCH_PROMPT);
3356             mpr("Which deck (ESC to exit)? ");
3357
3358             const int keyin = toalower(get_ch());
3359
3360             if (key_is_escape(keyin) || keyin == ' '
3361                 || keyin == '\r' || keyin == '\n')
3362             {
3363                 canned_msg(MSG_OK);
3364                 item.base_type = OBJ_UNASSIGNED;
3365                 return;
3366             }
3367
3368             if (keyin < 'a' || keyin > 'i')
3369                 continue;
3370
3371             item.sub_type = types[keyin - 'a'];
3372             break;
3373         }
3374     }
3375
3376     const char* rarities[] = {
3377         "plain",
3378         "ornate",
3379         "legendary",
3380         NULL
3381     };
3382
3383     int rarity_val = -1;
3384
3385     for (int i = 0; rarities[i] != NULL; ++i)
3386         if (specs.find(rarities[i]) != string::npos)
3387         {
3388             rarity_val = i;
3389             break;
3390         }
3391
3392     if (rarity_val == -1)
3393     {
3394         while (true)
3395         {
3396             mpr("[a] plain [b] ornate [c] legendary? (ESC to exit)",
3397                 MSGCH_PROMPT);
3398
3399             int keyin = toalower(get_ch());
3400
3401             if (key_is_escape(keyin) || keyin == ' '
3402                 || keyin == '\r' || keyin == '\n')
3403             {
3404                 canned_msg(MSG_OK);
3405                 item.base_type = OBJ_UNASSIGNED;
3406                 return;
3407             }
3408
3409             switch (keyin)
3410             {
3411             case 'p': keyin = 'a'; break;
3412             case 'o': keyin = 'b'; break;
3413             case 'l': keyin = 'c'; break;
3414             }
3415
3416             if (keyin < 'a' || keyin > 'c')
3417                 continue;
3418
3419             rarity_val = keyin - 'a';
3420             break;
3421         }
3422     }
3423
3424     const deck_rarity_type rarity =
3425         static_cast<deck_rarity_type>(DECK_RARITY_COMMON + rarity_val);
3426     item.special = rarity;
3427
3428     int num = prompt_for_int("How many cards? ", false);
3429
3430     if (num <= 0)
3431     {
3432         canned_msg(MSG_OK);
3433         item.base_type = OBJ_UNASSIGNED;
3434         return;
3435     }
3436
3437     item.plus = num;
3438
3439     init_deck(item);
3440 }
3441
3442 static void _rune_or_deck_from_specs(const char* specs, item_def &item)
3443 {
3444     if (strstr(specs, "rune"))
3445         _rune_from_specs(specs, item);
3446     else if (strstr(specs, "deck") || strstr(specs, "card"))
3447         _deck_from_specs(specs, item);
3448 }
3449
3450 static bool _book_from_spell(const char* specs, item_def &item)
3451 {
3452     spell_type type = spell_by_name(specs, true);
3453
3454     if (type == SPELL_NO_SPELL)
3455         return false;
3456
3457     for (int i = 0; i < NUM_FIXED_BOOKS; ++i)
3458         for (int j = 0; j < 8; ++j)
3459             if (which_spell_in_book(i, j) == type)
3460             {
3461                 item.sub_type = i;
3462                 return true;
3463             }
3464
3465     return false;
3466 }
3467
3468 bool get_item_by_name(item_def *item, char* specs,
3469                       object_class_type class_wanted, bool create_for_real)
3470 {
3471     int            type_wanted    = -1;
3472     int            special_wanted = 0;
3473
3474     // In order to get the sub-type, we'll fill out the base type...
3475     // then we're going to iterate over all possible subtype values
3476     // and see if we get a winner. -- bwr
3477     item->base_type = class_wanted;
3478     item->sub_type  = 0;
3479     item->plus      = 0;
3480     item->plus2     = 0;
3481     item->special   = 0;
3482     item->flags     = 0;
3483     item->quantity  = 1;
3484     // Don't use set_ident_flags(), to avoid getting a spurious ID note.
3485     item->flags    |= ISFLAG_IDENT_MASK;
3486
3487     if (class_wanted == OBJ_MISCELLANY)
3488     {
3489         // Leaves object unmodified if it wasn't a rune or deck.
3490         _rune_or_deck_from_specs(specs, *item);
3491
3492         if (item->base_type == OBJ_UNASSIGNED)
3493         {
3494             // Rune or deck creation canceled, clean up item->
3495             return false;
3496         }
3497     }
3498
3499     if (!item->sub_type)
3500     {
3501         type_wanted = -1;
3502         size_t best_index  = 10000;
3503
3504         for (int i = 0; i < get_max_subtype(item->base_type); ++i)
3505         {
3506             item->sub_type = i;
3507             size_t pos = lowercase_string(item->name(DESC_PLAIN)).find(specs);
3508             if (pos != string::npos)
3509             {
3510                 // Earliest match is the winner.
3511                 if (pos < best_index)
3512                 {
3513                     if (create_for_real)
3514                         mpr(item->name(DESC_PLAIN).c_str());
3515                     type_wanted = i;
3516                     best_index = pos;
3517                 }
3518             }
3519         }
3520
3521         if (type_wanted != -1)
3522         {
3523             item->sub_type = type_wanted;
3524             if (!create_for_real)
3525                 return true;
3526         }
3527         else
3528         {
3529             switch (class_wanted)
3530             {
3531             case OBJ_BOOKS:
3532                 // Try if we get a match against a spell.
3533                 if (_book_from_spell(specs, *item))
3534                     type_wanted = item->sub_type;
3535                 break;
3536
3537             // Search for a matching unrandart.
3538             case OBJ_WEAPONS:
3539             case OBJ_ARMOUR:
3540             case OBJ_JEWELLERY:
3541             {
3542                 for (int unrand = 0; unrand < NO_UNRANDARTS; ++unrand)
3543                 {
3544                     int index = unrand + UNRAND_START;
3545                     const unrandart_entry* entry = get_unrand_entry(index);
3546
3547                     size_t pos = lowercase_string(entry->name).find(specs);
3548                     if (pos != string::npos && entry->base_type == class_wanted)
3549                     {
3550                         make_item_unrandart(*item, index);
3551                         if (create_for_real)
3552                         {
3553                             mprf("%s (%s)", entry->name,
3554                                  debug_art_val_str(*item).c_str());
3555                         }
3556                         return true;
3557                     }
3558                 }
3559
3560                 // Reset base type to class_wanted, if nothing found.
3561                 item->base_type = class_wanted;
3562                 item->sub_type  = 0;
3563                 break;
3564             }
3565
3566             default:
3567                 break;
3568             }
3569         }
3570
3571         if (type_wanted == -1)
3572         {
3573             // ds -- If specs is a valid int, try using that.
3574             //       Since zero is atoi's copout, the wizard
3575             //       must enter (subtype + 1).
3576             if (!(type_wanted = atoi(specs)))
3577                 return false;
3578
3579             type_wanted--;
3580
3581             item->sub_type = type_wanted;
3582         }
3583     }
3584
3585     if (!create_for_real)
3586         return true;
3587
3588     switch (item->base_type)
3589     {
3590     case OBJ_MISSILES:
3591         item->quantity = 30;
3592         // intentional fall-through
3593     case OBJ_WEAPONS:
3594     case OBJ_ARMOUR:
3595     {
3596         char buf[80];
3597         msgwin_get_line_autohist("What ego type? ", buf, sizeof(buf));
3598
3599         if (buf[0] != '\0')
3600         {
3601             string buf_lwr = lowercase_string(buf);
3602             special_wanted = 0;
3603             size_t best_index = 10000;
3604
3605             for (int i = SPWPN_NORMAL + 1; i < SPWPN_DEBUG_RANDART; ++i)
3606             {
3607                 item->special = i;
3608                 size_t pos = lowercase_string(item->name(DESC_PLAIN)).find(buf_lwr);
3609                 if (pos != string::npos)
3610                 {
3611                     // earliest match is the winner
3612                     if (pos < best_index)
3613                     {
3614                         if (create_for_real)
3615                             mpr(item->name(DESC_PLAIN).c_str());
3616                         special_wanted = i;
3617                         best_index = pos;
3618                     }
3619                 }
3620             }
3621
3622             item->special = special_wanted;
3623         }
3624         break;
3625     }
3626
3627     case OBJ_BOOKS:
3628         if (item->sub_type == BOOK_MANUAL)
3629         {
3630             skill_type skill =
3631                     debug_prompt_for_skill("A manual for which skill? ");