30093a3c9335213f4f26eafdac8c6ff57773d1c8
[crawl.git] / crawl-ref / source / item_use.cc
1 /**
2  * @file
3  * @brief Functions for making use of inventory items.
4 **/
5
6 #include "AppHdr.h"
7
8 #include "item_use.h"
9
10 #include "ability.h"
11 #include "act-iter.h"
12 #include "areas.h"
13 #include "artefact.h"
14 #include "art-enum.h"
15 #include "butcher.h"
16 #include "chardump.h"
17 #include "cloud.h"
18 #include "colour.h"
19 #include "coordit.h"
20 #include "decks.h"
21 #include "delay.h"
22 #include "describe.h"
23 #include "directn.h"
24 #include "english.h"
25 #include "env.h"
26 #include "evoke.h"
27 #include "exercise.h"
28 #include "food.h"
29 #include "godabil.h"
30 #include "godconduct.h"
31 #include "goditem.h"
32 #include "godpassive.h"
33 #include "hints.h"
34 #include "invent.h"
35 #include "itemprop.h"
36 #include "items.h"
37 #include "libutil.h"
38 #include "macro.h"
39 #include "makeitem.h"
40 #include "message.h"
41 #include "misc.h"
42 #include "mon-behv.h"
43 #include "mutation.h"
44 #include "output.h"
45 #include "player-equip.h"
46 #include "player-stats.h"
47 #include "potion.h"
48 #include "prompt.h"
49 #include "religion.h"
50 #include "rot.h"
51 #include "shout.h"
52 #include "skills.h"
53 #include "spl-book.h"
54 #include "spl-clouds.h"
55 #include "spl-goditem.h"
56 #include "spl-selfench.h"
57 #include "spl-summoning.h"
58 #include "spl-transloc.h"
59 #include "spl-wpnench.h"
60 #include "spl-zap.h"
61 #include "state.h"
62 #include "stringutil.h"
63 #include "target.h"
64 #include "throw.h"
65 #include "transform.h"
66 #include "uncancel.h"
67 #include "unwind.h"
68 #include "view.h"
69 #include "xom.h"
70
71 static bool _safe_to_remove_or_wear(const item_def &item, bool remove,
72                                     bool quiet = false);
73
74 // Rather messy - we've gathered all the can't-wield logic from wield_weapon()
75 // here.
76 bool can_wield(const item_def *weapon, bool say_reason,
77                bool ignore_temporary_disability, bool unwield, bool only_known)
78 {
79 #define SAY(x) {if (say_reason) { x; }}
80     if (!ignore_temporary_disability && you.berserk())
81     {
82         SAY(canned_msg(MSG_TOO_BERSERK));
83         return false;
84     }
85
86     if (you.melded[EQ_WEAPON] && unwield)
87     {
88         SAY(mpr("Your weapon is melded into your body!"));
89         return false;
90     }
91
92     if (!ignore_temporary_disability && !form_can_wield(you.form))
93     {
94         SAY(mpr("You can't wield anything in your present form."));
95         return false;
96     }
97
98     if (!ignore_temporary_disability
99         && you.weapon()
100         && is_weapon(*you.weapon())
101         && you.weapon()->cursed())
102     {
103         SAY(mprf("You can't unwield your weapon%s!",
104                  !unwield ? " to draw a new one" : ""));
105         return false;
106     }
107
108     // If we don't have an actual weapon to check, return now.
109     if (!weapon)
110         return true;
111
112     if (player_mutation_level(MUT_MISSING_HAND)
113             && you.hands_reqd(*weapon) == HANDS_TWO)
114     {
115         SAY(mpr("You can't wield that without your missing limb."));
116         return false;
117     }
118
119     for (int i = EQ_MIN_ARMOUR; i <= EQ_MAX_WORN; i++)
120     {
121         if (you.equip[i] != -1 && &you.inv[you.equip[i]] == weapon)
122         {
123             SAY(mpr("You are wearing that object!"));
124             return false;
125         }
126     }
127
128     if (!you.could_wield(*weapon, true, true, !say_reason))
129         return false;
130
131     // All non-weapons only need a shield check.
132     if (weapon->base_type != OBJ_WEAPONS)
133     {
134         if (!ignore_temporary_disability && is_shield_incompatible(*weapon))
135         {
136             SAY(mpr("You can't wield that with a shield."));
137             return false;
138         }
139         else
140             return true;
141     }
142
143     bool id_brand = false;
144
145     if (you.undead_or_demonic() && is_holy_item(*weapon)
146         && (item_type_known(*weapon) || !only_known))
147     {
148         if (say_reason)
149         {
150             mpr("This weapon is holy and will not allow you to wield it.");
151             id_brand = true;
152         }
153     }
154     else if (!ignore_temporary_disability
155              && you.hunger_state < HS_FULL
156              && get_weapon_brand(*weapon) == SPWPN_VAMPIRISM
157              && you.undead_state() == US_ALIVE
158              && !you_foodless()
159              && (item_type_known(*weapon) || !only_known))
160     {
161         if (say_reason)
162         {
163             mpr("This weapon is vampiric, and you must be Full or above to equip it.");
164             id_brand = true;
165         }
166     }
167 #if TAG_MAJOR_VERSION == 34
168     else if (you.species == SP_DJINNI
169              && get_weapon_brand(*weapon) == SPWPN_ANTIMAGIC
170              && (item_type_known(*weapon) || !only_known))
171     {
172         if (say_reason)
173         {
174             mpr("As you grasp it, you feel your magic disrupted. Quickly, you stop.");
175             id_brand = true;
176         }
177     }
178 #endif
179
180     if (id_brand)
181     {
182         auto wwpn = const_cast<item_def*>(weapon);
183         if (!is_artefact(*weapon) && !is_blessed(*weapon)
184             && !item_type_known(*weapon))
185         {
186             set_ident_flags(*wwpn, ISFLAG_KNOW_TYPE);
187             if (in_inventory(*weapon))
188                 mprf_nocap("%s", weapon->name(DESC_INVENTORY_EQUIP).c_str());
189         }
190         else if (is_artefact(*weapon) && !item_type_known(*weapon))
191             artefact_learn_prop(*wwpn, ARTP_BRAND);
192         return false;
193     }
194
195     if (!ignore_temporary_disability && is_shield_incompatible(*weapon))
196     {
197         SAY(mpr("You can't wield that with a shield."));
198         return false;
199     }
200
201     // We can wield this weapon. Phew!
202     return true;
203
204 #undef SAY
205 }
206
207 /**
208  * @param force If true, don't check weapon inscriptions.
209  * (Assuming the player was already prompted for that.)
210  */
211 bool wield_weapon(bool auto_wield, int slot, bool show_weff_messages,
212                   bool force, bool show_unwield_msg, bool show_wield_msg,
213                   bool adjust_time_taken)
214 {
215     if (inv_count() < 1)
216     {
217         canned_msg(MSG_NOTHING_CARRIED);
218         return false;
219     }
220
221     // Look for conditions like berserking that could prevent wielding
222     // weapons.
223     if (!can_wield(nullptr, true, false, slot == SLOT_BARE_HANDS))
224         return false;
225
226     int item_slot = 0;          // default is 'a'
227
228     if (auto_wield)
229     {
230         if (item_slot == you.equip[EQ_WEAPON]
231             || you.equip[EQ_WEAPON] == -1
232                && !item_is_wieldable(you.inv[item_slot]))
233         {
234             item_slot = 1;      // backup is 'b'
235         }
236
237         if (slot != -1)         // allow external override
238             item_slot = slot;
239     }
240
241     // If the swap slot has a bad (but valid) item in it,
242     // the swap will be to bare hands.
243     const bool good_swap = (item_slot == SLOT_BARE_HANDS
244                             || item_is_wieldable(you.inv[item_slot]));
245
246     // Prompt if not using the auto swap command, or if the swap slot
247     // is empty.
248     if (item_slot != SLOT_BARE_HANDS
249         && (!auto_wield || !you.inv[item_slot].defined() || !good_swap))
250     {
251         if (!auto_wield)
252         {
253             item_slot = prompt_invent_item(
254                             "Wield which item (- for none, * to show all)?",
255                             MT_INVLIST, OSEL_WIELD,
256                             true, true, true, '-', -1, nullptr, OPER_WIELD);
257         }
258         else
259             item_slot = SLOT_BARE_HANDS;
260     }
261
262     if (prompt_failed(item_slot))
263         return false;
264     else if (item_slot == you.equip[EQ_WEAPON])
265     {
266         mpr("You are already wielding that!");
267         return true;
268     }
269
270     // Reset the warning counter.
271     you.received_weapon_warning = false;
272
273     if (item_slot == SLOT_BARE_HANDS)
274     {
275         if (const item_def* wpn = you.weapon())
276         {
277             bool penance = false;
278             // Can we safely unwield this item?
279             if (needs_handle_warning(*wpn, OPER_WIELD, penance))
280             {
281                 string prompt =
282                     "Really unwield " + wpn->name(DESC_INVENTORY) + "?";
283                 if (penance)
284                     prompt += " This could place you under penance!";
285
286                 if (!yesno(prompt.c_str(), false, 'n'))
287                 {
288                     canned_msg(MSG_OK);
289                     return false;
290                 }
291             }
292
293             // check if you'd get stat-zeroed
294             if (!_safe_to_remove_or_wear(*wpn, true))
295                 return false;
296
297             if (!unwield_item(show_weff_messages))
298                 return false;
299
300             if (show_unwield_msg)
301                 canned_msg(MSG_EMPTY_HANDED_NOW);
302
303             // Switching to bare hands is extra fast.
304             you.turn_is_over = true;
305             if (adjust_time_taken)
306             {
307                 you.time_taken *= 3;
308                 you.time_taken /= 10;
309             }
310         }
311         else
312             canned_msg(MSG_EMPTY_HANDED_ALREADY);
313
314         return true;
315     }
316
317     item_def& new_wpn(you.inv[item_slot]);
318
319     // Non-auto_wield cases are checked below.
320     if (auto_wield && !force
321         && !check_warning_inscriptions(new_wpn, OPER_WIELD))
322     {
323         return false;
324     }
325
326     // Ensure wieldable, stat loss non-fatal
327     if (!can_wield(&new_wpn, true) || !_safe_to_remove_or_wear(new_wpn, false))
328         return false;
329
330     // Really ensure wieldable, even unknown brand
331     if (!can_wield(&new_wpn, true, false, false, false))
332         return false;
333
334     // Unwield any old weapon.
335     if (you.weapon())
336     {
337         if (unwield_item(show_weff_messages))
338         {
339             // Enable skills so they can be re-disabled later
340             update_can_train();
341         }
342         else
343             return false;
344     }
345
346     const unsigned int old_talents = your_talents(false).size();
347
348     // Go ahead and wield the weapon.
349     equip_item(EQ_WEAPON, item_slot, show_weff_messages);
350
351     if (show_wield_msg)
352         mprf_nocap("%s", new_wpn.name(DESC_INVENTORY_EQUIP).c_str());
353
354     check_item_hint(new_wpn, old_talents);
355
356     // Time calculations.
357     if (adjust_time_taken)
358         you.time_taken /= 2;
359
360     you.wield_change  = true;
361     you.m_quiver.on_weapon_changed();
362     you.turn_is_over  = true;
363
364     return true;
365 }
366
367 bool item_is_worn(int inv_slot)
368 {
369     for (int i = EQ_MIN_ARMOUR; i <= EQ_MAX_WORN; ++i)
370         if (inv_slot == you.equip[i])
371             return true;
372
373     return false;
374 }
375
376 /**
377  * Prompt user for carried armour.
378  *
379  * @param mesg Title for the prompt
380  * @param index[out] the inventory slot of the item chosen; not initialised
381  *                   if a valid item was not chosen.
382  * @param oper if equal to OPER_TAKEOFF, only show items relevant to the 'T'
383  *             command.
384  * @return whether a valid armour item was chosen.
385  */
386 bool armour_prompt(const string & mesg, int *index, operation_types oper)
387 {
388     ASSERT(index != nullptr);
389
390     if (inv_count() < 1)
391         canned_msg(MSG_NOTHING_CARRIED);
392     else if (you.berserk())
393         canned_msg(MSG_TOO_BERSERK);
394     else
395     {
396         int selector = OBJ_ARMOUR;
397         if (oper == OPER_TAKEOFF && !Options.equip_unequip)
398             selector = OSEL_WORN_ARMOUR;
399         int slot = prompt_invent_item(mesg.c_str(), MT_INVLIST, selector,
400                                       true, true, true, 0, -1, nullptr,
401                                       oper);
402
403         if (!prompt_failed(slot))
404         {
405             *index = slot;
406             return true;
407         }
408     }
409
410     return false;
411 }
412
413
414 void wear_armour(int slot) // slot is for tiles
415 {
416     if (you.species == SP_FELID)
417     {
418         mpr("You can't wear anything.");
419         return;
420     }
421
422     if (!form_can_wear())
423     {
424         mpr("You can't wear anything in your present form.");
425         return;
426     }
427
428     int armour_wear_2 = 0;
429
430     if (slot != -1)
431         armour_wear_2 = slot;
432     else if (!armour_prompt("Wear which item?", &armour_wear_2, OPER_WEAR))
433         return;
434
435     do_wear_armour(armour_wear_2, false);
436 }
437
438 /**
439  * The number of turns it takes to put on or take off a given piece of armour.
440  *
441  * @param item      The armour in question.
442  * @return          The number of turns it takes to don or doff the item.
443  */
444 static int armour_equip_delay(const item_def &item)
445 {
446     return 5;
447 }
448
449 /**
450  * Can you wear this item of armour currently?
451  *
452  * Ignores whether or not an item is equipped in its slot already.
453  * If the item is Lear's hauberk, some of this comment may be incorrect.
454  *
455  * @param item The item. Only the base_type and sub_type really should get
456  *             checked, since you_can_wear passes in a dummy item.
457  * @param verbose Whether to print a message about your inability to wear item.
458  * @param ignore_temporary Whether to take into account forms/fishtail. Note
459  *                         that no matter what this is set to, all mutations
460  *                         will be taken into account, except for Beastly
461  *                         Appendage (and then only if this is false).
462  */
463 bool can_wear_armour(const item_def &item, bool verbose, bool ignore_temporary)
464 {
465     const object_class_type base_type = item.base_type;
466     if (base_type != OBJ_ARMOUR || you.species == SP_FELID)
467     {
468         if (verbose)
469             mpr("You can't wear that.");
470
471         return false;
472     }
473
474     const int sub_type = item.sub_type;
475     const equipment_type slot = get_armour_slot(item);
476
477     if (you.species == SP_OCTOPODE && slot != EQ_HELMET && slot != EQ_SHIELD)
478     {
479         if (verbose)
480             mpr("You can't wear that!");
481         return false;
482     }
483
484     if (species_is_draconian(you.species) && slot == EQ_BODY_ARMOUR)
485     {
486         if (verbose)
487         {
488             mprf("Your wings%s won't fit in that.", you.mutation[MUT_BIG_WINGS]
489                  ? "" : ", even vestigial as they are,");
490         }
491         return false;
492     }
493
494     if (sub_type == ARM_NAGA_BARDING || sub_type == ARM_CENTAUR_BARDING)
495     {
496         if (you.species == SP_NAGA && sub_type == ARM_NAGA_BARDING
497             || you.species == SP_CENTAUR && sub_type == ARM_CENTAUR_BARDING)
498         {
499             if (ignore_temporary || !player_is_shapechanged())
500                 return true;
501             else if (verbose)
502                 mpr("You can wear that only in your normal form.");
503         }
504         else if (verbose)
505             mpr("You can't wear that!");
506         return false;
507     }
508
509     if (player_mutation_level(MUT_MISSING_HAND) && is_shield(item))
510     {
511         if (verbose)
512         {
513             if (you.species == SP_OCTOPODE)
514                 mpr("You need the rest of your tentacles for walking.");
515             else
516                 mprf("You'd need another %s to do that!", you.hand_name(false).c_str());
517         }
518         return false;
519     }
520
521     if (!ignore_temporary && you.weapon()
522         && is_shield(item)
523         && is_shield_incompatible(*you.weapon(), &item))
524     {
525         if (verbose)
526         {
527             if (you.species == SP_OCTOPODE)
528                 mpr("You need the rest of your tentacles for walking.");
529             else
530             {
531                 // Singular hand should have already been handled above.
532                 mprf("You'd need three %s to do that!",
533                      you.hand_name(true).c_str());
534             }
535         }
536         return false;
537     }
538
539     // Lear's hauberk covers also head, hands and legs.
540     if (is_unrandom_artefact(item, UNRAND_LEAR))
541     {
542         if (!player_has_feet(!ignore_temporary))
543         {
544             if (verbose)
545                 mpr("You have no feet.");
546             return false;
547         }
548
549         if (ignore_temporary)
550         {
551             // Hooves and talons were already checked by player_has_feet.
552
553             if (player_mutation_level(MUT_CLAWS, false) >= 3)
554             {
555                 if (verbose)
556                 {
557                     mprf("The hauberk won't fit your %s.",
558                          you.hand_name(true).c_str());
559                 }
560                 return false;
561             }
562
563             if (player_mutation_level(MUT_HORNS, false) >= 3
564                 || player_mutation_level(MUT_ANTENNAE, false) >= 3)
565             {
566                 if (verbose)
567                     mpr("The hauberk won't fit your head.");
568                 return false;
569             }
570         }
571         else
572         {
573             for (int s = EQ_HELMET; s <= EQ_BOOTS; s++)
574             {
575                 // No strange race can wear this.
576                 const string parts[] = { "head", you.hand_name(true),
577                                          you.foot_name(true) };
578                 COMPILE_CHECK(ARRAYSZ(parts) == EQ_BOOTS - EQ_HELMET + 1);
579
580                 // Auto-disrobing would be nice.
581                 if (you.equip[s] != -1)
582                 {
583                     if (verbose)
584                     {
585                         mprf("You'd need your %s free.",
586                              parts[s - EQ_HELMET].c_str());
587                     }
588                     return false;
589                 }
590
591                 if (!get_form()->slot_available(s))
592                 {
593                     if (verbose)
594                     {
595                         mprf("The hauberk won't fit your %s.",
596                              parts[s - EQ_HELMET].c_str());
597                     }
598                     return false;
599                 }
600             }
601         }
602     }
603     else if (slot >= EQ_HELMET && slot <= EQ_BOOTS
604              && !ignore_temporary
605              && player_equip_unrand(UNRAND_LEAR))
606     {
607         // The explanation is iffy for loose headgear, especially crowns:
608         // kings loved hooded hauberks, according to portraits.
609         if (verbose)
610             mpr("You can't wear this over your hauberk.");
611         return false;
612     }
613
614     size_type player_size = you.body_size(PSIZE_TORSO, ignore_temporary);
615     int bad_size = fit_armour_size(item, player_size);
616     if (is_unrandom_artefact(item, UNRAND_TALOS))
617     {
618         // adjust bad_size for the oversized plate armour
619         // negative means levels too small, positive means levels too large
620         bad_size = SIZE_LARGE - player_size;
621     }
622
623     if (bad_size)
624     {
625         if (verbose)
626         {
627             mprf("This armour is too %s for you!",
628                  (bad_size > 0) ? "big" : "small");
629         }
630
631         return false;
632     }
633
634     if (you.form == TRAN_APPENDAGE
635         && ignore_temporary
636         && slot == beastly_slot(you.attribute[ATTR_APPENDAGE])
637         && you.mutation[you.attribute[ATTR_APPENDAGE]])
638     {
639         unwind_var<uint8_t> mutv(you.mutation[you.attribute[ATTR_APPENDAGE]], 0);
640         // disable the mutation then check again
641         return can_wear_armour(item, verbose, ignore_temporary);
642     }
643
644     if (sub_type == ARM_GLOVES)
645     {
646         if (you.has_claws(false) == 3)
647         {
648             if (verbose)
649             {
650                 mprf("You can't wear a glove with your huge claw%s!",
651                      player_mutation_level(MUT_MISSING_HAND) ? "" : "s");
652             }
653             return false;
654         }
655     }
656
657     if (sub_type == ARM_BOOTS)
658     {
659         if (player_mutation_level(MUT_HOOVES, false) == 3)
660         {
661             if (verbose)
662                 mpr("You can't wear boots with hooves!");
663             return false;
664         }
665
666         if (you.has_talons(false) == 3)
667         {
668             if (verbose)
669                 mpr("Boots don't fit your talons!");
670             return false;
671         }
672
673         if (you.species == SP_NAGA
674 #if TAG_MAJOR_VERSION == 34
675             || you.species == SP_DJINNI
676 #endif
677            )
678         {
679             if (verbose)
680                 mpr("You have no legs!");
681             return false;
682         }
683
684         if (!ignore_temporary && you.fishtail)
685         {
686             if (verbose)
687                 mpr("You don't currently have feet!");
688             return false;
689         }
690     }
691
692     if (slot == EQ_HELMET)
693     {
694         // Horns 3 & Antennae 3 mutations disallow all headgear
695         if (player_mutation_level(MUT_HORNS, false) == 3)
696         {
697             if (verbose)
698                 mpr("You can't wear any headgear with your large horns!");
699             return false;
700         }
701
702         if (player_mutation_level(MUT_ANTENNAE, false) == 3)
703         {
704             if (verbose)
705                 mpr("You can't wear any headgear with your large antennae!");
706             return false;
707         }
708
709         // Soft helmets (caps and wizard hats) always fit, otherwise.
710         if (is_hard_helmet(item))
711         {
712             if (player_mutation_level(MUT_HORNS, false))
713             {
714                 if (verbose)
715                     mpr("You can't wear that with your horns!");
716                 return false;
717             }
718
719             if (player_mutation_level(MUT_BEAK, false))
720             {
721                 if (verbose)
722                     mpr("You can't wear that with your beak!");
723                 return false;
724             }
725
726             if (player_mutation_level(MUT_ANTENNAE, false))
727             {
728                 if (verbose)
729                     mpr("You can't wear that with your antennae!");
730                 return false;
731             }
732
733             if (species_is_draconian(you.species))
734             {
735                 if (verbose)
736                     mpr("You can't wear that with your reptilian head.");
737                 return false;
738             }
739
740             if (you.species == SP_OCTOPODE)
741             {
742                 if (verbose)
743                     mpr("You can't wear that!");
744                 return false;
745             }
746         }
747     }
748
749     // Can't just use Form::slot_available because of shroom caps.
750     if (!ignore_temporary && !get_form()->can_wear_item(item))
751     {
752         if (verbose)
753             mpr("You can't wear that in your present form.");
754         return false;
755     }
756
757     return true;
758 }
759
760 bool do_wear_armour(int item, bool quiet)
761 {
762     const item_def &invitem = you.inv[item];
763     if (!invitem.defined())
764     {
765         if (!quiet)
766             mpr("You don't have any such object.");
767         return false;
768     }
769
770     if (!can_wear_armour(invitem, !quiet, false))
771         return false;
772
773     const equipment_type slot = get_armour_slot(invitem);
774
775     if (item == you.equip[EQ_WEAPON])
776     {
777         if (!quiet)
778             mpr("You are wielding that object!");
779         return false;
780     }
781
782     if (item_is_worn(item))
783     {
784         if (Options.equip_unequip)
785             return !takeoff_armour(item);
786         else
787         {
788             mpr("You're already wearing that object!");
789             return false;
790         }
791     }
792
793     bool swapping = false;
794     if ((slot == EQ_CLOAK
795            || slot == EQ_HELMET
796            || slot == EQ_GLOVES
797            || slot == EQ_BOOTS
798            || slot == EQ_SHIELD
799            || slot == EQ_BODY_ARMOUR)
800         && you.equip[slot] != -1)
801     {
802         if (!takeoff_armour(you.equip[slot]))
803             return false;
804         swapping = true;
805     }
806
807     you.turn_is_over = true;
808
809     if (!_safe_to_remove_or_wear(invitem, false))
810         return false;
811
812     const int delay = armour_equip_delay(invitem);
813     if (delay)
814         start_delay(DELAY_ARMOUR_ON, delay - (swapping ? 0 : 1), item);
815
816     return true;
817 }
818
819 bool takeoff_armour(int item)
820 {
821     const item_def& invitem = you.inv[item];
822
823     if (invitem.base_type != OBJ_ARMOUR)
824     {
825         mpr("You aren't wearing that!");
826         return false;
827     }
828
829     if (you.berserk())
830     {
831         canned_msg(MSG_TOO_BERSERK);
832         return false;
833     }
834
835     const equipment_type slot = get_armour_slot(invitem);
836     if (item == you.equip[slot] && you.melded[slot])
837     {
838         mprf("%s is melded into your body!",
839              invitem.name(DESC_YOUR).c_str());
840         return false;
841     }
842
843     if (!item_is_worn(item))
844     {
845         if (Options.equip_unequip)
846             return do_wear_armour(item, true);
847         else
848         {
849             mpr("You aren't wearing that object!");
850             return false;
851         }
852     }
853
854     // If we get here, we're wearing the item.
855     if (invitem.cursed())
856     {
857         mprf("%s is stuck to your body!", invitem.name(DESC_YOUR).c_str());
858         return false;
859     }
860
861     if (!_safe_to_remove_or_wear(invitem, true))
862         return false;
863
864
865     switch (slot)
866     {
867     case EQ_BODY_ARMOUR:
868     case EQ_SHIELD:
869     case EQ_CLOAK:
870     case EQ_HELMET:
871     case EQ_GLOVES:
872     case EQ_BOOTS:
873         if (item != you.equip[slot])
874         {
875             mpr("You aren't wearing that!");
876             return false;
877         }
878         break;
879
880     default:
881         break;
882     }
883
884     you.turn_is_over = true;
885
886     const int delay = armour_equip_delay(invitem);
887     start_delay(DELAY_ARMOUR_OFF, delay - 1, item);
888
889     return true;
890 }
891
892 // Returns a list of possible ring slots.
893 static vector<equipment_type> _current_ring_types()
894 {
895     vector<equipment_type> ret;
896     if (you.species == SP_OCTOPODE)
897     {
898         for (int i = 0; i < 8; ++i)
899         {
900             const equipment_type slot = (equipment_type)(EQ_RING_ONE + i);
901
902             if (player_mutation_level(MUT_MISSING_HAND)
903                 && slot == EQ_RING_EIGHT)
904             {
905                 continue;
906             }
907
908             if (get_form()->slot_available(slot))
909                 ret.push_back(slot);
910         }
911     }
912     else
913     {
914         if (player_mutation_level(MUT_MISSING_HAND) == 0)
915             ret.push_back(EQ_LEFT_RING);
916         ret.push_back(EQ_RIGHT_RING);
917     }
918     if (player_equip_unrand(UNRAND_FINGER_AMULET))
919         ret.push_back(EQ_RING_AMULET);
920     return ret;
921 }
922
923 static vector<equipment_type> _current_jewellery_types()
924 {
925     vector<equipment_type> ret = _current_ring_types();
926     ret.push_back(EQ_AMULET);
927     return ret;
928 }
929
930 static const char _ring_slot_key(equipment_type slot)
931 {
932     switch (slot)
933     {
934     case EQ_LEFT_RING:      return '<';
935     case EQ_RIGHT_RING:     return '>';
936     case EQ_RING_AMULET:    return '^';
937     case EQ_RING_ONE:       return '1';
938     case EQ_RING_TWO:       return '2';
939     case EQ_RING_THREE:     return '3';
940     case EQ_RING_FOUR:      return '4';
941     case EQ_RING_FIVE:      return '5';
942     case EQ_RING_SIX:       return '6';
943     case EQ_RING_SEVEN:     return '7';
944     case EQ_RING_EIGHT:     return '8';
945     default:
946         die("Invalid ring slot");
947     }
948 }
949
950 static int _prompt_ring_to_remove(int new_ring)
951 {
952     const vector<equipment_type> ring_types = _current_ring_types();
953     vector<char> slot_chars;
954     vector<item_def*> rings;
955     for (auto eq : ring_types)
956     {
957         rings.push_back(you.slot_item(eq, true));
958         ASSERT(rings.back());
959         slot_chars.push_back(index_to_letter(rings.back()->link));
960     }
961
962     clear_messages();
963
964     mprf(MSGCH_PROMPT,
965          "You're wearing all the rings you can. Remove which one?");
966     mprf(MSGCH_PROMPT, "(<w>?</w> for menu, <w>Esc</w> to cancel)");
967
968     // FIXME: Needs TOUCH_UI version
969
970     for (size_t i = 0; i < rings.size(); i++)
971     {
972         string m = "<w>";
973         const char key = _ring_slot_key(ring_types[i]);
974         m += key;
975         if (key == '<')
976             m += '<';
977
978         m += "</w> or " + rings[i]->name(DESC_INVENTORY);
979         mprf_nocap("%s", m.c_str());
980     }
981     flush_prev_message();
982
983     // Deactivate choice from tile inventory.
984     // FIXME: We need to be able to get the choice (item letter)n
985     //        *without* the choice taking action by itself!
986     int eqslot = EQ_NONE;
987
988     mouse_control mc(MOUSE_MODE_PROMPT);
989     int c;
990     do
991     {
992         c = getchm();
993         for (size_t i = 0; i < slot_chars.size(); i++)
994         {
995             if (c == slot_chars[i]
996                 || c == _ring_slot_key(ring_types[i]))
997             {
998                 eqslot = ring_types[i];
999                 c = ' ';
1000                 break;
1001             }
1002         }
1003     } while (!key_is_escape(c) && c != ' ' && c != '?');
1004
1005     clear_messages();
1006
1007     if (c == '?')
1008         return EQ_NONE;
1009     else if (key_is_escape(c) || eqslot == EQ_NONE)
1010         return -2;
1011
1012     return you.equip[eqslot];
1013 }
1014
1015 // Checks whether a to-be-worn or to-be-removed item affects
1016 // character stats and whether wearing/removing it could be fatal.
1017 // If so, warns the player, or just returns false if quiet is true.
1018 static bool _safe_to_remove_or_wear(const item_def &item, bool remove, bool quiet)
1019 {
1020     if (remove && !safe_to_remove(item, quiet))
1021         return false;
1022
1023     int prop_str = 0;
1024     int prop_dex = 0;
1025     int prop_int = 0;
1026     if (item.base_type == OBJ_JEWELLERY
1027         && item_ident(item, ISFLAG_KNOW_PLUSES))
1028     {
1029         switch (item.sub_type)
1030         {
1031         case RING_STRENGTH:
1032             if (item.plus != 0)
1033                 prop_str = item.plus;
1034             break;
1035         case RING_DEXTERITY:
1036             if (item.plus != 0)
1037                 prop_dex = item.plus;
1038             break;
1039         case RING_INTELLIGENCE:
1040             if (item.plus != 0)
1041                 prop_int = item.plus;
1042             break;
1043         default:
1044             break;
1045         }
1046     }
1047     else if (item.base_type == OBJ_ARMOUR && item_type_known(item))
1048     {
1049         switch (item.brand)
1050         {
1051         case SPARM_STRENGTH:
1052             prop_str = 3;
1053             break;
1054         case SPARM_INTELLIGENCE:
1055             prop_int = 3;
1056             break;
1057         case SPARM_DEXTERITY:
1058             prop_dex = 3;
1059             break;
1060         default:
1061             break;
1062         }
1063     }
1064
1065     if (is_artefact(item))
1066     {
1067         prop_str += artefact_known_property(item, ARTP_STRENGTH);
1068         prop_int += artefact_known_property(item, ARTP_INTELLIGENCE);
1069         prop_dex += artefact_known_property(item, ARTP_DEXTERITY);
1070     }
1071
1072     if (!remove)
1073     {
1074         prop_str *= -1;
1075         prop_int *= -1;
1076         prop_dex *= -1;
1077     }
1078     stat_type red_stat = NUM_STATS;
1079     if (prop_str >= you.strength() && you.strength() > 0)
1080         red_stat = STAT_STR;
1081     else if (prop_int >= you.intel() && you.intel() > 0)
1082         red_stat = STAT_INT;
1083     else if (prop_dex >= you.dex() && you.dex() > 0)
1084         red_stat = STAT_DEX;
1085
1086     if (red_stat == NUM_STATS)
1087         return true;
1088
1089     if (quiet)
1090         return false;
1091
1092     string verb = "";
1093     if (remove)
1094     {
1095         if (item.base_type == OBJ_WEAPONS)
1096             verb = "Unwield";
1097         else
1098             verb = "Remov"; // -ing, not a typo
1099     }
1100     else
1101     {
1102         if (item.base_type == OBJ_WEAPONS)
1103             verb = "Wield";
1104         else
1105             verb = "Wear";
1106     }
1107
1108     string prompt = make_stringf("%sing this item will reduce your %s to zero "
1109                                  "or below. Continue?", verb.c_str(),
1110                                  stat_desc(red_stat, SD_NAME));
1111     if (!yesno(prompt.c_str(), true, 'n', true, false))
1112     {
1113         canned_msg(MSG_OK);
1114         return false;
1115     }
1116     return true;
1117 }
1118
1119 // Checks whether removing an item would cause flight to end and the
1120 // player to fall to their death.
1121 bool safe_to_remove(const item_def &item, bool quiet)
1122 {
1123     item_info inf = get_item_info(item);
1124
1125     const bool grants_flight =
1126          inf.is_type(OBJ_JEWELLERY, RING_FLIGHT)
1127          || inf.base_type == OBJ_ARMOUR && inf.brand == SPARM_FLYING
1128          || is_artefact(inf)
1129             && artefact_known_property(inf, ARTP_FLY);
1130
1131     // assumes item can't grant flight twice
1132     const bool removing_ends_flight = you.airborne()
1133           && !you.racial_permanent_flight()
1134           && !you.attribute[ATTR_FLIGHT_UNCANCELLABLE]
1135           && (you.evokable_flight() == 1);
1136
1137     const dungeon_feature_type feat = grd(you.pos());
1138
1139     if (grants_flight && removing_ends_flight
1140         && is_feat_dangerous(feat, false, true))
1141     {
1142         if (!quiet)
1143             mpr("Losing flight right now would be fatal!");
1144         return false;
1145     }
1146
1147     return true;
1148 }
1149
1150 // Assumptions:
1151 // you.inv[ring_slot] is a valid ring.
1152 // EQ_LEFT_RING and EQ_RIGHT_RING are both occupied, and ring_slot is not
1153 // one of the worn rings.
1154 //
1155 // Does not do amulets.
1156 static bool _swap_rings(int ring_slot)
1157 {
1158     vector<equipment_type> ring_types = _current_ring_types();
1159     const int num_rings = ring_types.size();
1160     int unwanted = 0;
1161     int last_inscribed = 0;
1162     int cursed = 0;
1163     int inscribed = 0;
1164     int melded = 0; // Both melded rings and unavailable slots.
1165     int available = 0;
1166     bool all_same = true;
1167     item_def* first_ring = nullptr;
1168     for (auto eq : ring_types)
1169     {
1170         item_def* ring = you.slot_item(eq, true);
1171         if (!you_can_wear(eq, true) || you.melded[eq])
1172             melded++;
1173         else if (ring != nullptr)
1174         {
1175             if (first_ring == nullptr)
1176                 first_ring = ring;
1177             else if (all_same)
1178             {
1179                 if (ring->sub_type != first_ring->sub_type
1180                     || ring->plus  != first_ring->plus
1181                     || is_artefact(*ring) || is_artefact(*first_ring))
1182                 {
1183                     all_same = false;
1184                 }
1185             }
1186
1187             if (ring->cursed())
1188                 cursed++;
1189             else if (strstr(ring->inscription.c_str(), "=R"))
1190             {
1191                 inscribed++;
1192                 last_inscribed = you.equip[eq];
1193             }
1194             else
1195             {
1196                 available++;
1197                 unwanted = you.equip[eq];
1198             }
1199         }
1200     }
1201
1202     // If the only swappable rings are inscribed =R, go ahead and use them.
1203     if (available == 0 && inscribed > 0)
1204     {
1205         available += inscribed;
1206         unwanted = last_inscribed;
1207     }
1208
1209     // We can't put a ring on, because we're wearing all cursed ones.
1210     if (melded == num_rings)
1211     {
1212         // Shouldn't happen, because hogs and bats can't put on jewellery at
1213         // all and thus won't get this far.
1214         mpr("You can't wear that in your present form.");
1215         return false;
1216     }
1217     else if (available == 0)
1218     {
1219         mprf("You're already wearing %s cursed ring%s!%s",
1220              number_in_words(cursed).c_str(),
1221              (cursed == 1 ? "" : "s"),
1222              (cursed > 2 ? " Isn't that enough for you?" : ""));
1223         return false;
1224     }
1225     // The simple case - only one available ring.
1226     // If the jewellery_prompt option is true, always allow choosing the
1227     // ring slot (even if we still have empty slots).
1228     else if (available == 1 && !Options.jewellery_prompt)
1229     {
1230         if (!remove_ring(unwanted, false))
1231             return false;
1232     }
1233     // We can't put a ring on without swapping - because we found
1234     // multiple available rings.
1235     else
1236     {
1237         // Don't prompt if all the rings are the same.
1238         if (!all_same || Options.jewellery_prompt)
1239             unwanted = _prompt_ring_to_remove(ring_slot);
1240
1241         // Cancelled:
1242         if (unwanted < -1)
1243         {
1244             canned_msg(MSG_OK);
1245             return false;
1246         }
1247
1248         if (!remove_ring(unwanted, false))
1249             return false;
1250     }
1251
1252     // Put on the new ring.
1253     start_delay(DELAY_JEWELLERY_ON, 1, ring_slot);
1254
1255     return true;
1256 }
1257
1258 static equipment_type _choose_ring_slot()
1259 {
1260     clear_messages();
1261
1262     mprf(MSGCH_PROMPT,
1263          "Put ring on which %s? (<w>Esc</w> to cancel)", you.hand_name(false).c_str());
1264
1265     const vector<equipment_type> slots = _current_ring_types();
1266     for (auto eq : slots)
1267     {
1268         string msg = "<w>";
1269         const char key = _ring_slot_key(eq);
1270         msg += key;
1271         if (key == '<')
1272             msg += '<';
1273
1274         item_def* ring = you.slot_item(eq, true);
1275         if (ring)
1276             msg += "</w> or " + ring->name(DESC_INVENTORY);
1277         else
1278             msg += "</w> - no ring";
1279
1280         if (eq == EQ_LEFT_RING)
1281             msg += " (left)";
1282         else if (eq == EQ_RIGHT_RING)
1283             msg += " (right)";
1284         else if (eq == EQ_RING_AMULET)
1285             msg += " (amulet)";
1286         mprf_nocap("%s", msg.c_str());
1287     }
1288     flush_prev_message();
1289
1290     equipment_type eqslot = EQ_NONE;
1291     mouse_control mc(MOUSE_MODE_PROMPT);
1292     int c;
1293     do
1294     {
1295         c = getchm();
1296         for (auto eq : slots)
1297         {
1298             if (c == _ring_slot_key(eq)
1299                 || (you.slot_item(eq, true)
1300                     && c == index_to_letter(you.slot_item(eq, true)->link)))
1301             {
1302                 eqslot = eq;
1303                 c = ' ';
1304                 break;
1305             }
1306         }
1307     } while (!key_is_escape(c) && c != ' ');
1308
1309     clear_messages();
1310
1311     return eqslot;
1312 }
1313
1314 static bool _puton_item(int item_slot, bool prompt_slot)
1315 {
1316     item_def& item = you.inv[item_slot];
1317
1318     for (int eq = EQ_LEFT_RING; eq < NUM_EQUIP; eq++)
1319         if (item_slot == you.equip[eq])
1320         {
1321             // "Putting on" an equipped item means taking it off.
1322             if (Options.equip_unequip)
1323                 return !remove_ring(item_slot);
1324             else
1325             {
1326                 mpr("You're already wearing that object!");
1327                 return false;
1328             }
1329         }
1330
1331     if (item_slot == you.equip[EQ_WEAPON])
1332     {
1333         mpr("You are wielding that object.");
1334         return false;
1335     }
1336
1337     if (item.base_type != OBJ_JEWELLERY)
1338     {
1339         mpr("You can only put on jewellery.");
1340         return false;
1341     }
1342
1343     const bool is_amulet = jewellery_is_amulet(item);
1344
1345     if (is_amulet && !you_can_wear(EQ_AMULET, true)
1346         || !is_amulet && !you_can_wear(EQ_RINGS, true))
1347     {
1348         mpr("You can't wear that in your present form.");
1349         return false;
1350     }
1351
1352     const vector<equipment_type> ring_types = _current_ring_types();
1353
1354     if (!is_amulet)     // i.e. it's a ring
1355     {
1356         bool need_swap = true;
1357         for (auto eq : ring_types)
1358         {
1359             if (!you.slot_item(eq, true))
1360             {
1361                 need_swap = false;
1362                 break;
1363             }
1364         }
1365
1366         if (need_swap)
1367             return _swap_rings(item_slot);
1368     }
1369     else if (you.slot_item(EQ_AMULET, true))
1370     {
1371         // Remove the previous one.
1372         if (!remove_ring(you.equip[EQ_AMULET], true))
1373             return false;
1374
1375         // Check for stat loss.
1376         if (!_safe_to_remove_or_wear(item, false))
1377             return false;
1378
1379         // Put on the new amulet.
1380         start_delay(DELAY_JEWELLERY_ON, 1, item_slot);
1381
1382         // Assume it's going to succeed.
1383         return true;
1384     }
1385
1386     // Check for stat loss.
1387     if (!_safe_to_remove_or_wear(item, false))
1388         return false;
1389
1390     equipment_type hand_used = EQ_NONE;
1391
1392     if (is_amulet)
1393         hand_used = EQ_AMULET;
1394     else if (prompt_slot)
1395     {
1396         // Prompt for a slot, even if we have empty ring slots.
1397         hand_used = _choose_ring_slot();
1398
1399         if (hand_used == EQ_NONE)
1400         {
1401             canned_msg(MSG_OK);
1402             return false;
1403         }
1404         // Allow swapping out a ring.
1405         else if (you.slot_item(hand_used, true))
1406         {
1407             if (!remove_ring(you.equip[hand_used], false))
1408                 return false;
1409
1410             start_delay(DELAY_JEWELLERY_ON, 1, item_slot);
1411             return true;
1412         }
1413     }
1414     else
1415     {
1416         for (auto eq : ring_types)
1417         {
1418             if (!you.slot_item(eq, true))
1419             {
1420                 hand_used = eq;
1421                 break;
1422             }
1423         }
1424     }
1425
1426     const unsigned int old_talents = your_talents(false).size();
1427
1428     // Actually equip the item.
1429     equip_item(hand_used, item_slot);
1430
1431     check_item_hint(you.inv[item_slot], old_talents);
1432 #ifdef USE_TILE_LOCAL
1433     if (your_talents(false).size() != old_talents)
1434     {
1435         tiles.layout_statcol();
1436         redraw_screen();
1437     }
1438 #endif
1439
1440     // Putting on jewellery is fast.
1441     you.time_taken /= 2;
1442     you.turn_is_over = true;
1443
1444     return true;
1445 }
1446
1447 bool puton_ring(int slot, bool allow_prompt)
1448 {
1449     int item_slot;
1450
1451     if (inv_count() < 1)
1452     {
1453         canned_msg(MSG_NOTHING_CARRIED);
1454         return false;
1455     }
1456
1457     if (you.berserk())
1458     {
1459         canned_msg(MSG_TOO_BERSERK);
1460         return false;
1461     }
1462
1463     if (slot != -1)
1464         item_slot = slot;
1465     else
1466     {
1467         item_slot = prompt_invent_item("Put on which piece of jewellery?",
1468                                         MT_INVLIST, OBJ_JEWELLERY, true, true,
1469                                         true, 0, -1, nullptr, OPER_PUTON);
1470     }
1471
1472     if (prompt_failed(item_slot))
1473         return false;
1474
1475     bool prompt = allow_prompt ? Options.jewellery_prompt : false;
1476
1477     return _puton_item(item_slot, prompt);
1478 }
1479
1480 bool remove_ring(int slot, bool announce)
1481 {
1482     equipment_type hand_used = EQ_NONE;
1483     int ring_wear_2;
1484     bool has_jewellery = false;
1485     bool has_melded = false;
1486     const vector<equipment_type> jewellery_slots = _current_jewellery_types();
1487
1488     for (auto eq : jewellery_slots)
1489     {
1490         if (you.slot_item(eq))
1491         {
1492             if (has_jewellery || Options.jewellery_prompt)
1493             {
1494                 // At least one other piece, which means we'll have to ask
1495                 hand_used = EQ_NONE;
1496             }
1497             else
1498                 hand_used = eq;
1499
1500             has_jewellery = true;
1501         }
1502         else if (you.melded[eq])
1503             has_melded = true;
1504     }
1505
1506     if (!has_jewellery)
1507     {
1508         if (has_melded)
1509             mpr("You aren't wearing any unmelded rings or amulets.");
1510         else
1511             mpr("You aren't wearing any rings or amulets.");
1512
1513         return false;
1514     }
1515
1516     if (you.berserk())
1517     {
1518         canned_msg(MSG_TOO_BERSERK);
1519         return false;
1520     }
1521
1522     if (hand_used == EQ_NONE)
1523     {
1524         const int equipn =
1525             (slot == -1)? prompt_invent_item("Remove which piece of jewellery?",
1526                                              MT_INVLIST,
1527                                              OBJ_JEWELLERY, true, true, true,
1528                                              0, -1, nullptr, OPER_REMOVE,
1529                                              false, false)
1530                         : slot;
1531
1532         if (prompt_failed(equipn))
1533             return false;
1534
1535         hand_used = item_equip_slot(you.inv[equipn]);
1536         if (hand_used == EQ_NONE)
1537         {
1538             mpr("You aren't wearing that.");
1539             return false;
1540         }
1541         else if (you.inv[equipn].base_type != OBJ_JEWELLERY)
1542         {
1543             mpr("That isn't a piece of jewellery.");
1544             return false;
1545         }
1546     }
1547
1548     if (you.equip[hand_used] == -1)
1549     {
1550         mpr("I don't think you really meant that.");
1551         return false;
1552     }
1553     else if (you.melded[hand_used])
1554     {
1555         mpr("You can't take that off while it's melded.");
1556         return false;
1557     }
1558     else if (hand_used == EQ_AMULET
1559         && you.equip[EQ_RING_AMULET] != -1)
1560     {
1561         // This can be removed in the future if more ring amulets are added.
1562         ASSERT(player_equip_unrand(UNRAND_FINGER_AMULET));
1563
1564         mpr("The amulet cannot be taken off without first removing the ring!");
1565         return false;
1566     }
1567
1568     if (!check_warning_inscriptions(you.inv[you.equip[hand_used]],
1569                                     OPER_REMOVE))
1570     {
1571         canned_msg(MSG_OK);
1572         return false;
1573     }
1574
1575     if (you.inv[you.equip[hand_used]].cursed())
1576     {
1577         if (announce)
1578         {
1579             mprf("%s is stuck to you!",
1580                  you.inv[you.equip[hand_used]].name(DESC_YOUR).c_str());
1581         }
1582         else
1583             mpr("It's stuck to you!");
1584
1585         set_ident_flags(you.inv[you.equip[hand_used]], ISFLAG_KNOW_CURSE);
1586         return false;
1587     }
1588
1589     ring_wear_2 = you.equip[hand_used];
1590
1591     // Remove the ring.
1592     if (!_safe_to_remove_or_wear(you.inv[ring_wear_2], true))
1593         return false;
1594
1595     mprf("You remove %s.", you.inv[ring_wear_2].name(DESC_YOUR).c_str());
1596 #ifdef USE_TILE_LOCAL
1597     const unsigned int old_talents = your_talents(false).size();
1598 #endif
1599     unequip_item(hand_used);
1600 #ifdef USE_TILE_LOCAL
1601     if (your_talents(false).size() != old_talents)
1602     {
1603         tiles.layout_statcol();
1604         redraw_screen();
1605     }
1606 #endif
1607
1608     you.time_taken /= 2;
1609     you.turn_is_over = true;
1610
1611     return true;
1612 }
1613
1614 void prompt_inscribe_item()
1615 {
1616     if (inv_count() < 1)
1617     {
1618         mpr("You don't have anything to inscribe.");
1619         return;
1620     }
1621
1622     int item_slot = prompt_invent_item("Inscribe which item?",
1623                                        MT_INVLIST, OSEL_ANY);
1624
1625     if (prompt_failed(item_slot))
1626         return;
1627
1628     inscribe_item(you.inv[item_slot]);
1629 }
1630
1631 static bool _check_blood_corpses_on_ground()
1632 {
1633     for (stack_iterator si(you.pos(), true); si; ++si)
1634     {
1635         if (si->is_type(OBJ_CORPSES, CORPSE_BODY)
1636             && mons_has_blood(si->mon_type))
1637         {
1638             return true;
1639         }
1640     }
1641     return false;
1642 }
1643
1644 static void _vampire_corpse_help()
1645 {
1646     if (you.species != SP_VAMPIRE)
1647         return;
1648
1649     if (_check_blood_corpses_on_ground())
1650         mpr("Use <w>e</w> to drain blood from corpses.");
1651 }
1652
1653 void drink(int slot)
1654 {
1655     if (you_foodless(true))
1656     {
1657         mpr("You can't drink.");
1658         return;
1659     }
1660
1661     if (inv_count() == 0)
1662     {
1663         canned_msg(MSG_NOTHING_CARRIED);
1664         _vampire_corpse_help();
1665         return;
1666     }
1667
1668     if (you.berserk())
1669     {
1670         canned_msg(MSG_TOO_BERSERK);
1671         return;
1672     }
1673
1674     if (you.form == TRAN_BAT)
1675     {
1676         canned_msg(MSG_PRESENT_FORM);
1677         _vampire_corpse_help();
1678         return;
1679     }
1680
1681     if (you.duration[DUR_NO_POTIONS])
1682     {
1683         mpr("You cannot drink potions in your current state!");
1684         return;
1685     }
1686
1687     if (slot == -1)
1688     {
1689         slot = prompt_invent_item("Drink which item?",
1690                                   MT_INVLIST, OBJ_POTIONS,
1691                                   true, true, true, 0, -1, nullptr,
1692                                   OPER_QUAFF);
1693         if (prompt_failed(slot))
1694         {
1695             _vampire_corpse_help();
1696             return;
1697         }
1698     }
1699
1700     item_def& potion = you.inv[slot];
1701
1702     if (potion.base_type != OBJ_POTIONS)
1703     {
1704         if (you.species == SP_VAMPIRE && potion.base_type == OBJ_CORPSES)
1705             eat_food(slot);
1706         else
1707             mpr("You can't drink that!");
1708         return;
1709     }
1710
1711     const bool alreadyknown = item_type_known(potion);
1712
1713     if (alreadyknown && is_bad_item(potion, true))
1714     {
1715         canned_msg(MSG_UNTHINKING_ACT);
1716         return;
1717     }
1718
1719     // The "> 1" part is to reduce the amount of times that Xom is
1720     // stimulated when you are a low-level 1 trying your first unknown
1721     // potions on monsters.
1722     const bool dangerous = (player_in_a_dangerous_place()
1723                             && you.experience_level > 1);
1724     potion_type pot_type = (potion_type)potion.sub_type;
1725
1726     if (player_under_penance(GOD_GOZAG) && one_chance_in(3))
1727     {
1728         simple_god_message(" petitions for your drink to fail.", GOD_GOZAG);
1729         you.turn_is_over = true;
1730         return;
1731     }
1732
1733     if (!quaff_potion(potion))
1734         return;
1735
1736     if (!alreadyknown && dangerous)
1737     {
1738         // Xom loves it when you drink an unknown potion and there is
1739         // a dangerous monster nearby...
1740         xom_is_stimulated(200);
1741     }
1742     if (is_blood_potion(potion))
1743     {
1744         // Always drink oldest potion.
1745         remove_oldest_perishable_item(potion);
1746     }
1747     dec_inv_item_quantity(slot, 1);
1748     count_action(CACT_USE, OBJ_POTIONS);
1749     auto_assign_item_slot(potion);
1750     you.turn_is_over = true;
1751     // This got deferred from PotionExperience::effect to prevent SIGHUP abuse.
1752     if (pot_type == POT_EXPERIENCE)
1753         level_change();
1754 }
1755
1756 // XXX: there's probably a nicer way of doing this.
1757 bool god_hates_brand(const int brand)
1758 {
1759     if (is_good_god(you.religion)
1760         && (brand == SPWPN_DRAINING
1761             || brand == SPWPN_VAMPIRISM
1762             || brand == SPWPN_CHAOS
1763             || brand == SPWPN_PAIN))
1764     {
1765         return true;
1766     }
1767
1768     if (you_worship(GOD_DITHMENOS)
1769         && (brand == SPWPN_FLAMING
1770             || brand == SPWPN_CHAOS))
1771     {
1772         return true;
1773     }
1774
1775     if (you_worship(GOD_SHINING_ONE) && brand == SPWPN_VENOM)
1776         return true;
1777
1778     if (you_worship(GOD_CHEIBRIADOS) && (brand == SPWPN_CHAOS
1779                                          || brand == SPWPN_SPEED))
1780     {
1781         return true;
1782     }
1783
1784     if (you_worship(GOD_YREDELEMNUL) && brand == SPWPN_HOLY_WRATH)
1785         return true;
1786
1787     return false;
1788 }
1789
1790 static void _rebrand_weapon(item_def& wpn)
1791 {
1792     if (&wpn == you.weapon() && you.duration[DUR_WEAPON_BRAND])
1793         end_weapon_brand(wpn);
1794     int old_brand = get_weapon_brand(wpn);
1795     int new_brand = old_brand;
1796
1797     // now try and find an appropriate brand
1798     while (old_brand == new_brand || god_hates_brand(new_brand))
1799     {
1800         if (is_range_weapon(wpn))
1801         {
1802             new_brand = random_choose_weighted(
1803                                     30, SPWPN_FLAMING,
1804                                     30, SPWPN_FREEZING,
1805                                     20, SPWPN_VENOM,
1806                                     20, SPWPN_VORPAL,
1807                                     12, SPWPN_EVASION,
1808                                     5, SPWPN_ELECTROCUTION,
1809                                     3, SPWPN_CHAOS,
1810                                     0);
1811         }
1812         else
1813         {
1814             new_brand = random_choose_weighted(
1815                                     30, SPWPN_FLAMING,
1816                                     30, SPWPN_FREEZING,
1817                                     25, SPWPN_VORPAL,
1818                                     20, SPWPN_VENOM,
1819                                     15, SPWPN_DRAINING,
1820                                     15, SPWPN_ELECTROCUTION,
1821                                     12, SPWPN_PROTECTION,
1822                                     8, SPWPN_VAMPIRISM,
1823                                     3, SPWPN_CHAOS,
1824                                     0);
1825         }
1826     }
1827
1828     set_item_ego_type(wpn, OBJ_WEAPONS, new_brand);
1829     convert2bad(wpn);
1830 }
1831
1832 static void _brand_weapon(item_def &wpn)
1833 {
1834     you.wield_change = true;
1835
1836     const string itname = wpn.name(DESC_YOUR);
1837
1838     _rebrand_weapon(wpn);
1839
1840     bool success = true;
1841     colour_t flash_colour = BLACK;
1842
1843     switch (get_weapon_brand(wpn))
1844     {
1845     case SPWPN_VORPAL:
1846         flash_colour = YELLOW;
1847         mprf("%s emits a brilliant flash of light!",itname.c_str());
1848         break;
1849
1850     case SPWPN_PROTECTION:
1851         flash_colour = YELLOW;
1852         mprf("%s projects an invisible shield of force!",itname.c_str());
1853         break;
1854
1855     case SPWPN_EVASION:
1856         flash_colour = YELLOW;
1857         mprf("%s emits a repelling force!",itname.c_str());
1858         break;
1859
1860     case SPWPN_FLAMING:
1861         flash_colour = RED;
1862         mprf("%s is engulfed in flames!", itname.c_str());
1863         break;
1864
1865     case SPWPN_FREEZING:
1866         flash_colour = LIGHTCYAN;
1867         mprf("%s is covered with a thin layer of ice!", itname.c_str());
1868         break;
1869
1870     case SPWPN_DRAINING:
1871         flash_colour = DARKGREY;
1872         mprf("%s craves living souls!", itname.c_str());
1873         break;
1874
1875     case SPWPN_VAMPIRISM:
1876         flash_colour = DARKGREY;
1877         mprf("%s thirsts for the lives of mortals!", itname.c_str());
1878         break;
1879
1880     case SPWPN_VENOM:
1881         flash_colour = GREEN;
1882         mprf("%s drips with poison.", itname.c_str());
1883         break;
1884
1885     case SPWPN_ELECTROCUTION:
1886         flash_colour = LIGHTCYAN;
1887         mprf("%s crackles with electricity.", itname.c_str());
1888         break;
1889
1890     case SPWPN_CHAOS:
1891         flash_colour = random_colour();
1892         mprf("%s erupts in a glittering mayhem of colour.", itname.c_str());
1893         break;
1894
1895     default:
1896         success = false;
1897         break;
1898     }
1899
1900     if (success)
1901     {
1902         item_set_appearance(wpn);
1903         // Message would spoil this even if we didn't identify.
1904         set_ident_flags(wpn, ISFLAG_KNOW_TYPE);
1905         mprf_nocap("%s", wpn.name(DESC_INVENTORY_EQUIP).c_str());
1906         // Might be rebranding to/from protection or evasion.
1907         you.redraw_armour_class = true;
1908         you.redraw_evasion = true;
1909         // Might be removing antimagic.
1910         calc_mp();
1911         flash_view_delay(UA_PLAYER, flash_colour, 300);
1912     }
1913     return;
1914 }
1915
1916 static object_selector _enchant_selector(scroll_type scroll)
1917 {
1918     if (scroll == SCR_BRAND_WEAPON)
1919         return OSEL_BRANDABLE_WEAPON;
1920     else if (scroll == SCR_ENCHANT_WEAPON)
1921         return OSEL_ENCHANTABLE_WEAPON;
1922     die("Invalid scroll type %d for _enchant_selector", (int)scroll);
1923 }
1924
1925 // Returns nullptr if no weapon was chosen.
1926 static item_def* _scroll_choose_weapon(bool alreadyknown, const string &pre_msg,
1927                                        scroll_type scroll)
1928 {
1929     int item_slot;
1930     const bool branding = scroll == SCR_BRAND_WEAPON;
1931     const object_selector selector = _enchant_selector(scroll);
1932
1933     while (true)
1934     {
1935         item_slot = prompt_invent_item(branding ? "Brand which weapon?"
1936                                                 : "Enchant which weapon?",
1937                                        MT_INVLIST, selector,
1938                                        true, true, false);
1939         // The scroll is used up if we didn't know what it was originally.
1940         if (item_slot == PROMPT_NOTHING)
1941             return nullptr;
1942
1943         if (item_slot == PROMPT_ABORT)
1944         {
1945             if (alreadyknown
1946                 || crawl_state.seen_hups
1947                 || yesno("Really abort (and waste the scroll)?", false, 0))
1948             {
1949                 canned_msg(MSG_OK);
1950                 return nullptr;
1951             }
1952             else
1953                 continue;
1954         }
1955
1956         item_def* wpn = &you.inv[item_slot];
1957         if (!item_is_selected(*wpn, selector))
1958         {
1959             mpr("Choose a valid weapon, or Esc to abort.");
1960             more();
1961             continue;
1962         }
1963
1964         // Now we're definitely using up the scroll.
1965         if (alreadyknown)
1966             mpr(pre_msg);
1967         return wpn;
1968     }
1969 }
1970
1971 // Returns true if the scroll is used up.
1972 static bool _handle_brand_weapon(bool alreadyknown, const string &pre_msg)
1973 {
1974     item_def* weapon = _scroll_choose_weapon(alreadyknown, pre_msg,
1975                                              SCR_BRAND_WEAPON);
1976     if (!weapon)
1977         return !alreadyknown;
1978
1979     _brand_weapon(*weapon);
1980     return true;
1981 }
1982
1983 bool enchant_weapon(item_def &wpn, bool quiet)
1984 {
1985     bool success = false;
1986
1987     // Get item name now before changing enchantment.
1988     string iname = wpn.name(DESC_YOUR);
1989
1990     if (is_weapon(wpn)
1991         && !is_artefact(wpn)
1992         && wpn.base_type == OBJ_WEAPONS
1993         && wpn.plus < MAX_WPN_ENCHANT)
1994     {
1995         wpn.plus++;
1996         success = true;
1997         if (!quiet)
1998             mprf("%s glows red for a moment.", iname.c_str());
1999     }
2000
2001     if (!success && !quiet)
2002         canned_msg(MSG_NOTHING_HAPPENS);
2003
2004     if (success)
2005         you.wield_change = true;
2006
2007     return success;
2008 }
2009
2010 // Returns true if the scroll is used up.
2011 static bool _identify(bool alreadyknown, const string &pre_msg)
2012 {
2013     int item_slot = -1;
2014     while (true)
2015     {
2016         if (item_slot == -1)
2017         {
2018             item_slot = prompt_invent_item(
2019                 "Identify which item? (\\ to view known items)",
2020                 MT_INVLIST, OSEL_UNIDENT, true, true, false, 0,
2021                 -1, nullptr, OPER_ANY, true);
2022         }
2023
2024         if (item_slot == PROMPT_NOTHING)
2025             return !alreadyknown;
2026
2027         if (item_slot == PROMPT_ABORT)
2028         {
2029             if (alreadyknown
2030                 || crawl_state.seen_hups
2031                 || yesno("Really abort (and waste the scroll)?", false, 0))
2032             {
2033                 canned_msg(MSG_OK);
2034                 return !alreadyknown;
2035             }
2036             else
2037             {
2038                 item_slot = -1;
2039                 continue;
2040             }
2041         }
2042
2043         item_def& item(you.inv[item_slot]);
2044         if (fully_identified(item)
2045             && (!is_deck(item) || top_card_is_known(item)))
2046         {
2047             mpr("Choose an unidentified item, or Esc to abort.");
2048             more();
2049             item_slot = -1;
2050             continue;
2051         }
2052
2053         if (alreadyknown)
2054             mpr(pre_msg);
2055
2056         set_ident_type(item, true);
2057         set_ident_flags(item, ISFLAG_IDENT_MASK);
2058
2059         if (is_deck(item) && !top_card_is_known(item))
2060             deck_identify_first(item_slot);
2061
2062         // Output identified item.
2063         mprf_nocap("%s", item.name(DESC_INVENTORY_EQUIP).c_str());
2064         if (item_slot == you.equip[EQ_WEAPON])
2065             you.wield_change = true;
2066
2067         if (item.is_type(OBJ_JEWELLERY, AMU_INACCURACY)
2068             && item_slot == you.equip[EQ_AMULET]
2069             && !item_known_cursed(item))
2070         {
2071             learned_something_new(HINT_INACCURACY);
2072         }
2073
2074         auto_assign_item_slot(item);
2075         return true;
2076     }
2077 }
2078
2079 static bool _handle_enchant_weapon(bool alreadyknown, const string &pre_msg)
2080 {
2081     item_def* weapon = _scroll_choose_weapon(alreadyknown, pre_msg,
2082                                              SCR_ENCHANT_WEAPON);
2083     if (!weapon)
2084         return !alreadyknown;
2085
2086     enchant_weapon(*weapon, false);
2087     return true;
2088 }
2089
2090 bool enchant_armour(int &ac_change, bool quiet, item_def &arm)
2091 {
2092     ASSERT(arm.defined());
2093     ASSERT(arm.base_type == OBJ_ARMOUR);
2094
2095     ac_change = 0;
2096
2097     // Cannot be enchanted.
2098     if (!is_enchantable_armour(arm))
2099     {
2100         if (!quiet)
2101             canned_msg(MSG_NOTHING_HAPPENS);
2102         return false;
2103     }
2104
2105     // Turn hides into mails where applicable.
2106     // NOTE: It is assumed that armour which changes in this way does
2107     // not change into a form of armour with a different evasion modifier.
2108     if (armour_is_hide(arm, false))
2109     {
2110         if (!quiet)
2111         {
2112             mprf("%s glows purple and changes!",
2113                  arm.name(DESC_YOUR).c_str());
2114         }
2115
2116         ac_change = property(arm, PARM_AC);
2117         hide2armour(arm);
2118         ac_change = property(arm, PARM_AC) - ac_change;
2119
2120         // No additional enchantment.
2121         return true;
2122     }
2123
2124     // Output message before changing enchantment and curse status.
2125     if (!quiet)
2126     {
2127         mprf("%s glows green for a moment.",
2128              arm.name(DESC_YOUR).c_str());
2129     }
2130
2131     arm.plus++;
2132     ac_change++;
2133
2134     return true;
2135 }
2136
2137 static int _handle_enchant_armour(bool alreadyknown, const string &pre_msg)
2138 {
2139     int item_slot = -1;
2140     do
2141     {
2142         if (item_slot == -1)
2143         {
2144             item_slot = prompt_invent_item("Enchant which item?", MT_INVLIST,
2145                                            OSEL_ENCH_ARM, true, true, false);
2146         }
2147
2148         if (item_slot == PROMPT_NOTHING)
2149             return alreadyknown ? -1 : 0;
2150
2151         if (item_slot == PROMPT_ABORT)
2152         {
2153             if (alreadyknown
2154                 || crawl_state.seen_hups
2155                 || yesno("Really abort (and waste the scroll)?", false, 0))
2156             {
2157                 canned_msg(MSG_OK);
2158                 return alreadyknown ? -1 : 0;
2159             }
2160             else
2161             {
2162                 item_slot = -1;
2163                 continue;
2164             }
2165         }
2166
2167         item_def& arm(you.inv[item_slot]);
2168
2169         if (!is_enchantable_armour(arm, true))
2170         {
2171             mpr("Choose some type of armour to enchant, or Esc to abort.");
2172             more();
2173
2174             item_slot = -1;
2175             continue;
2176         }
2177
2178         // Okay, we may actually (attempt to) enchant something.
2179         if (alreadyknown)
2180             mpr(pre_msg);
2181
2182         int ac_change;
2183         bool result = enchant_armour(ac_change, false, arm);
2184
2185         if (ac_change)
2186             you.redraw_armour_class = true;
2187
2188         return result ? 1 : 0;
2189     }
2190     while (true);
2191
2192     return 0;
2193 }
2194
2195 void random_uselessness()
2196 {
2197     ASSERT(!crawl_state.game_is_arena());
2198
2199     switch (random2(8))
2200     {
2201     case 0:
2202     case 1:
2203         mprf("The dust glows %s!", weird_glowing_colour().c_str());
2204         break;
2205
2206     case 2:
2207         if (you.weapon())
2208         {
2209             mprf("%s glows %s for a moment.",
2210                  you.weapon()->name(DESC_YOUR).c_str(),
2211                  weird_glowing_colour().c_str());
2212         }
2213         else
2214         {
2215             mpr(you.hands_act("glow", weird_glowing_colour()
2216                                       + " for a moment."));
2217         }
2218         break;
2219
2220     case 3:
2221         if (you.species == SP_MUMMY)
2222             mpr("Your bandages flutter.");
2223         else // if (you.can_smell())
2224             mprf("You smell %s.", weird_smell().c_str());
2225         break;
2226
2227     case 4:
2228         mpr("You experience a momentary feeling of inescapable doom!");
2229         break;
2230
2231     case 5:
2232         if (player_mutation_level(MUT_BEAK) || one_chance_in(3))
2233             mpr("Your brain hurts!");
2234         else if (you.species == SP_MUMMY || coinflip())
2235             mpr("Your ears itch!");
2236         else
2237             mpr("Your nose twitches suddenly!");
2238         break;
2239
2240     case 6:
2241         mprf(MSGCH_SOUND, "You hear the tinkle of a tiny bell.");
2242         noisy(2, you.pos());
2243         cast_summon_butterflies(100);
2244         break;
2245
2246     case 7:
2247         mprf(MSGCH_SOUND, "You hear %s.", weird_sound().c_str());
2248         noisy(2, you.pos());
2249         break;
2250     }
2251 }
2252
2253 static void _handle_read_book(int item_slot)
2254 {
2255     if (you.berserk())
2256     {
2257         canned_msg(MSG_TOO_BERSERK);
2258         return;
2259     }
2260
2261     if (you.duration[DUR_BRAINLESS])
2262     {
2263         mpr("Reading books requires mental cohesion, which you lack.");
2264         return;
2265     }
2266
2267     item_def& book(you.inv[item_slot]);
2268     ASSERT(book.sub_type != BOOK_MANUAL);
2269
2270 #if TAG_MAJOR_VERSION == 34
2271     if (book.sub_type == BOOK_BUGGY_DESTRUCTION)
2272     {
2273         mpr("This item has been removed, sorry!");
2274         return;
2275     }
2276 #endif
2277
2278     read_book(book);
2279 }
2280
2281 static void _vulnerability_scroll()
2282 {
2283     mon_enchant lowered_mr(ENCH_LOWERED_MR, 1, &you, 400);
2284
2285     // Go over all creatures in LOS.
2286     for (radius_iterator ri(you.pos(), LOS_NO_TRANS); ri; ++ri)
2287     {
2288         if (monster* mon = monster_at(*ri))
2289         {
2290             // If relevant, monsters have their MR halved.
2291             if (!mons_immune_magic(mon))
2292                 mon->add_ench(lowered_mr);
2293
2294             // Annoying but not enough to turn friendlies against you.
2295             if (!mon->wont_attack())
2296                 behaviour_event(mon, ME_ANNOY, &you);
2297         }
2298     }
2299
2300     you.set_duration(DUR_LOWERED_MR, 40, 0, "Magic quickly surges around you.");
2301 }
2302
2303 static bool _is_cancellable_scroll(scroll_type scroll)
2304 {
2305     return scroll == SCR_IDENTIFY
2306            || scroll == SCR_BLINKING
2307            || scroll == SCR_RECHARGING
2308            || scroll == SCR_ENCHANT_ARMOUR
2309            || scroll == SCR_AMNESIA
2310            || scroll == SCR_REMOVE_CURSE
2311 #if TAG_MAJOR_VERSION == 34
2312            || scroll == SCR_CURSE_ARMOUR
2313            || scroll == SCR_CURSE_JEWELLERY
2314 #endif
2315            || scroll == SCR_BRAND_WEAPON
2316            || scroll == SCR_ENCHANT_WEAPON
2317            || scroll == SCR_MAGIC_MAPPING;
2318 }
2319
2320 /**
2321  * Is the player currently able to use the 'r' command (to read books or
2322  * scrolls). Being too berserk, confused, or having no reading material will
2323  * prevent this.
2324  *
2325  * Prints corresponding messages. (Thanks, canned_msg().)
2326  */
2327 bool player_can_read()
2328 {
2329     if (you.berserk())
2330     {
2331         canned_msg(MSG_TOO_BERSERK);
2332         return false;
2333     }
2334
2335     if (you.confused())
2336     {
2337         canned_msg(MSG_TOO_CONFUSED);
2338         return false;
2339     }
2340
2341     if (inv_count() < 1)
2342     {
2343         canned_msg(MSG_NOTHING_CARRIED);
2344         return false;
2345     }
2346
2347     return true;
2348 }
2349
2350 /**
2351  * If the player has no items matching the given selector, give an appropriate
2352  * response to print. Otherwise, if they do have such items, return the empty
2353  * string.
2354  */
2355 static string _no_items_reason(object_selector type)
2356 {
2357     if (!any_items_of_type(type))
2358         return no_selectables_message(type);
2359     return "";
2360 }
2361
2362 /**
2363  * If the player is unable to (r)ead the item in the given slot, return the
2364  * reason why. Otherwise (if they are able to read it), returns "", the empty
2365  * string.
2366  */
2367 string cannot_read_item_reason(const item_def &item)
2368 {
2369     // can read books, except for manuals...
2370     if (item.base_type == OBJ_BOOKS)
2371     {
2372         if (item.sub_type == BOOK_MANUAL)
2373             return "You can't read that!";
2374         return "";
2375     }
2376
2377     // and scrolls - but nothing else.
2378     if (item.base_type != OBJ_SCROLLS)
2379         return "You can't read that!";
2380
2381     // the below only applies to scrolls. (it's easier to read books, since
2382     // that's just a UI/strategic thing.)
2383
2384     if (silenced(you.pos()))
2385         return "Magic scrolls do not work when you're silenced!";
2386
2387     // water elementals
2388     if (you.duration[DUR_WATER_HOLD] && !you.res_water_drowning())
2389         return "You cannot read scrolls while unable to breathe!";
2390
2391     // ru
2392     if (you.duration[DUR_NO_SCROLLS])
2393         return "You cannot read scrolls in your current state!";
2394
2395 #if TAG_MAJOR_VERSION == 34
2396     // Prevent hot lava orcs reading scrolls
2397     if (you.species == SP_LAVA_ORC && temperature_effect(LORC_NO_SCROLLS))
2398         return "You'd burn any scroll you tried to read!";
2399 #endif
2400
2401     // don't waste the player's time reading known scrolls in situations where
2402     // they'd be useless
2403
2404     if (!item_type_known(item))
2405         return "";
2406
2407     switch (item.sub_type)
2408     {
2409         case SCR_BLINKING:
2410         case SCR_TELEPORTATION:
2411             return you.no_tele_reason(false, item.sub_type == SCR_BLINKING);
2412
2413         case SCR_AMNESIA:
2414             if (you.spell_no == 0)
2415                 return "You have no spells to forget!";
2416             return "";
2417
2418 #if TAG_MAJOR_VERSION == 34
2419         case SCR_CURSE_WEAPON:
2420             if (!you.weapon())
2421                 return "This scroll only affects a wielded weapon!";
2422
2423             // assumption: wielded weapons always have their curse & brand known
2424             if (you.weapon()->cursed())
2425                 return "Your weapon is already cursed!";
2426
2427             if (get_weapon_brand(*you.weapon()) == SPWPN_HOLY_WRATH)
2428                 return "Holy weapons cannot be cursed!";
2429             return "";
2430 #endif
2431
2432         case SCR_ENCHANT_ARMOUR:
2433             return _no_items_reason(OSEL_ENCH_ARM);
2434
2435         case SCR_ENCHANT_WEAPON:
2436             return _no_items_reason(OSEL_ENCHANTABLE_WEAPON);
2437
2438         case SCR_IDENTIFY:
2439             return _no_items_reason(OSEL_UNIDENT);
2440
2441         case SCR_RECHARGING:
2442             return _no_items_reason(OSEL_RECHARGE);
2443
2444         case SCR_REMOVE_CURSE:
2445             return _no_items_reason(OSEL_CURSED_WORN);
2446
2447 #if TAG_MAJOR_VERSION == 34
2448         case SCR_CURSE_ARMOUR:
2449             return _no_items_reason(OSEL_UNCURSED_WORN_ARMOUR);
2450
2451         case SCR_CURSE_JEWELLERY:
2452             return _no_items_reason(OSEL_UNCURSED_WORN_JEWELLERY);
2453 #endif
2454
2455         default:
2456             return "";
2457     }
2458 }
2459
2460 /**
2461  * Check to see if the player can read the item in the given slot, and if so,
2462  * reads it. (Examining books, evoking the tome of destruction, & using
2463  * scrolls.)
2464  *
2465  * @param slot      The slot of the item in the player's inventory. If -1, the
2466  *                  player is prompted to choose a slot.
2467  */
2468 void read(int slot)
2469 {
2470     if (!player_can_read())
2471         return;
2472
2473     int item_slot = (slot != -1) ? slot
2474                                  : prompt_invent_item("Read which item?",
2475                                                        MT_INVLIST,
2476                                                        OBJ_SCROLLS,
2477                                                        true, true, true, 0, -1,
2478                                                        nullptr, OPER_READ);
2479
2480     if (prompt_failed(item_slot))
2481         return;
2482
2483     const item_def& scroll = you.inv[item_slot];
2484     const string failure_reason = cannot_read_item_reason(scroll);
2485     if (!failure_reason.empty())
2486     {
2487         mprf(MSGCH_PROMPT, "%s", failure_reason.c_str());
2488         return;
2489     }
2490
2491     if (scroll.base_type == OBJ_BOOKS)
2492     {
2493         _handle_read_book(item_slot);
2494         return;
2495     }
2496
2497     // need to handle this before we waste time (with e.g. blurryvis)
2498     if (scroll.sub_type == SCR_BLINKING && item_type_known(scroll)
2499         && player_has_orb()
2500         && !yesno("Your blink will be uncontrolled - continue anyway?",
2501                   false, 'n'))
2502     {
2503         canned_msg(MSG_OK);
2504         return;
2505     }
2506
2507     if (player_mutation_level(MUT_BLURRY_VISION)
2508         && !i_feel_safe(false, false, true)
2509         && !yesno("Really read with blurry vision while enemies are nearby?",
2510                   false, 'n'))
2511     {
2512         canned_msg(MSG_OK);
2513         return;
2514     }
2515
2516     // Ok - now we FINALLY get to read a scroll !!! {dlb}
2517     you.turn_is_over = true;
2518
2519     if (you.duration[DUR_BRAINLESS] && !one_chance_in(5))
2520     {
2521         mpr("You almost manage to decipher the scroll,"
2522             " but fail in this attempt.");
2523         return;
2524     }
2525
2526     // if we have blurry vision, we need to start a delay before the actual
2527     // scroll effect kicks in.
2528     if (player_mutation_level(MUT_BLURRY_VISION))
2529     {
2530         // takes 0.5, 1, 2 extra turns
2531         const int turns = max(1, player_mutation_level(MUT_BLURRY_VISION) - 1);
2532         start_delay(DELAY_BLURRY_SCROLL, turns, item_slot);
2533         if (player_mutation_level(MUT_BLURRY_VISION) == 1)
2534             you.time_taken /= 2;
2535     }
2536     else
2537         read_scroll(item_slot);
2538 }
2539
2540 /**
2541  * Read the provided scroll.
2542  *
2543  * Does NOT check whether the player can currently read, whether the scroll is
2544  * currently useless, etc. Likewise doesn't handle blurry vision, setting
2545  * you.turn_is_over, and other externals. DOES destroy one scroll, unless the
2546  * player chooses to cancel at the last moment.
2547  *
2548  * @param slot      The slot of the item in the player's inventory.
2549  */
2550 void read_scroll(int item_slot)
2551 {
2552     item_def& scroll = you.inv[item_slot];
2553     const scroll_type which_scroll = static_cast<scroll_type>(scroll.sub_type);
2554     const int prev_quantity = scroll.quantity;
2555     const bool alreadyknown = item_type_known(scroll);
2556
2557     // For cancellable scrolls leave printing this message to their
2558     // respective functions.
2559     const string pre_succ_msg =
2560             make_stringf("As you read the %s, it crumbles to dust.",
2561                           scroll.name(DESC_QUALNAME).c_str());
2562     if (!_is_cancellable_scroll(which_scroll))
2563     {
2564         mpr(pre_succ_msg);
2565         // Actual removal of scroll done afterwards. -- bwr
2566     }
2567
2568     const bool dangerous = player_in_a_dangerous_place();
2569
2570     // ... but some scrolls may still be cancelled afterwards.
2571     bool cancel_scroll = false;
2572     bool bad_effect = false; // for Xom: result is bad (or at least dangerous)
2573
2574     switch (which_scroll)
2575     {
2576     case SCR_RANDOM_USELESSNESS:
2577         random_uselessness();
2578         break;
2579
2580     case SCR_BLINKING:
2581     {
2582         const string reason = you.no_tele_reason(true, true);
2583         if (!reason.empty())
2584         {
2585             mpr(pre_succ_msg);
2586             mpr(reason);
2587             break;
2588         }
2589
2590         const bool safely_cancellable
2591             = alreadyknown && !player_mutation_level(MUT_BLURRY_VISION);
2592
2593         if (player_has_orb())
2594         {
2595             mprf(MSGCH_ORB, "The Orb prevents control of your translocation!");
2596             uncontrolled_blink();
2597         }
2598         else
2599         {
2600             cancel_scroll = (cast_controlled_blink(false, safely_cancellable)
2601                              == SPRET_ABORT) && alreadyknown;
2602         }
2603
2604         if (!cancel_scroll)
2605             mpr(pre_succ_msg); // ordering is iffy but w/e
2606     }
2607         break;
2608
2609     case SCR_TELEPORTATION:
2610         you_teleport();
2611         break;
2612
2613     case SCR_REMOVE_CURSE:
2614         if (!alreadyknown)
2615         {
2616             mpr(pre_succ_msg);
2617             remove_curse(false);
2618         }
2619         else
2620             cancel_scroll = !remove_curse(true, pre_succ_msg);
2621         break;
2622
2623     case SCR_ACQUIREMENT:
2624         mpr("This is a scroll of acquirement!");
2625         // included in default force_more_message
2626         // Identify it early in case the player checks the '\' screen.
2627         set_ident_type(scroll, true);
2628         run_uncancel(UNC_ACQUIREMENT, AQ_SCROLL);
2629         break;
2630
2631     case SCR_FEAR:
2632         mpr("You assume a fearsome visage.");
2633         mass_enchantment(ENCH_FEAR, 1000);
2634         break;
2635
2636     case SCR_NOISE:
2637         noisy(25, you.pos(), "You hear a loud clanging noise!");
2638         break;
2639
2640     case SCR_SUMMONING:
2641         cast_shadow_creatures(MON_SUMM_SCROLL);
2642         break;
2643
2644     case SCR_FOG:
2645         mpr("The scroll dissolves into smoke.");
2646         big_cloud(random_smoke_type(), &you, you.pos(), 50, 8 + random2(8));
2647         break;
2648
2649     case SCR_MAGIC_MAPPING:
2650         if (alreadyknown && !is_map_persistent())
2651         {
2652             cancel_scroll = true;
2653             mpr("It would have no effect in this place.");
2654             break;
2655         }
2656         mpr(pre_succ_msg);
2657         magic_mapping(500, 100, false);
2658         break;
2659
2660     case SCR_TORMENT:
2661         torment(&you, TORMENT_SCROLL, you.pos());
2662
2663         // This is only naughty if you know you're doing it.
2664         did_god_conduct(DID_NECROMANCY, 10, item_type_known(scroll));
2665         bad_effect = true;
2666         break;
2667
2668     case SCR_IMMOLATION:
2669     {
2670         // Dithmenos hates trying to play with fire, even if it does nothing.
2671         did_god_conduct(DID_FIRE, 2 + random2(3), item_type_known(scroll));
2672
2673         bool had_effect = false;
2674         for (monster_near_iterator mi(you.pos(), LOS_NO_TRANS); mi; ++mi)
2675         {
2676             if (mons_immune_magic(*mi) || mi->is_summoned())
2677                 continue;
2678
2679             if (mi->add_ench(mon_enchant(ENCH_INNER_FLAME, 0, &you)))
2680                 had_effect = true;
2681         }
2682
2683         if (had_effect)
2684             mpr("The creatures around you are filled with an inner flame!");
2685         else
2686             mpr("The air around you briefly surges with heat, but it dissipates.");
2687
2688         bad_effect = true;
2689         break;
2690     }
2691
2692 #if TAG_MAJOR_VERSION == 34
2693     case SCR_CURSE_WEAPON:
2694     {
2695         // Not you.weapon() because we want to handle melded weapons too.
2696         item_def * const weapon = you.slot_item(EQ_WEAPON, true);
2697         if (!weapon || !is_weapon(*weapon) || weapon->cursed())
2698         {
2699             bool plural = false;
2700             const string weapon_name =
2701                 weapon ? weapon->name(DESC_YOUR)
2702                        : "Your " + you.hand_name(true, &plural);
2703             mprf("%s very briefly gain%s a black sheen.",
2704                  weapon_name.c_str(), plural ? "" : "s");
2705         }
2706         else
2707         {
2708             // Also sets wield_change.
2709             do_curse_item(*weapon, false);
2710             learned_something_new(HINT_YOU_CURSED);
2711             bad_effect = true;
2712         }
2713         break;
2714     }
2715 #endif
2716
2717     case SCR_ENCHANT_WEAPON:
2718         if (!alreadyknown)
2719         {
2720             mpr(pre_succ_msg);
2721             mpr("It is a scroll of enchant weapon.");
2722             // included in default force_more_message (to show it before menu)
2723         }
2724
2725         cancel_scroll = !_handle_enchant_weapon(alreadyknown, pre_succ_msg);
2726         break;
2727
2728     case SCR_BRAND_WEAPON:
2729         if (!alreadyknown)
2730         {
2731             mpr(pre_succ_msg);
2732             mpr("It is a scroll of brand weapon.");
2733             // included in default force_more_message (to show it before menu)
2734         }
2735
2736         cancel_scroll = !_handle_brand_weapon(alreadyknown, pre_succ_msg);
2737         break;
2738
2739     case SCR_IDENTIFY:
2740         if (!alreadyknown)
2741         {
2742             mpr(pre_succ_msg);
2743             mpr("It is a scroll of identify.");
2744             // included in default force_more_message (to show it before menu)
2745             // Do this here so it doesn't turn up in the ID menu.
2746             set_ident_type(scroll, true);
2747         }
2748         cancel_scroll = !_identify(alreadyknown, pre_succ_msg);
2749         break;
2750
2751     case SCR_RECHARGING:
2752         if (!alreadyknown)
2753         {
2754             mpr(pre_succ_msg);
2755             mpr("It is a scroll of recharging.");
2756             // included in default force_more_message (to show it before menu)
2757         }
2758         cancel_scroll = (recharge_wand(alreadyknown, pre_succ_msg) == -1);
2759         break;
2760
2761     case SCR_ENCHANT_ARMOUR:
2762         if (!alreadyknown)
2763         {
2764             mpr(pre_succ_msg);
2765             mpr("It is a scroll of enchant armour.");
2766             // included in default force_more_message (to show it before menu)
2767         }
2768         cancel_scroll =
2769             (_handle_enchant_armour(alreadyknown, pre_succ_msg) == -1);
2770         break;
2771
2772 #if TAG_MAJOR_VERSION == 34
2773     // Should always be identified by Ashenzari.
2774     case SCR_CURSE_ARMOUR:
2775     case SCR_CURSE_JEWELLERY:
2776     {
2777         const bool armour = which_scroll == SCR_CURSE_ARMOUR;
2778         cancel_scroll = !curse_item(armour, pre_succ_msg);
2779         break;
2780     }
2781 #endif
2782
2783     case SCR_HOLY_WORD:
2784     {
2785         holy_word(100, HOLY_WORD_SCROLL, you.pos(), false, &you);
2786
2787         // This is always naughty, even if you didn't affect anyone.
2788         // Don't speak those foul holy words even in jest!
2789         did_god_conduct(DID_HOLY, 10, item_type_known(scroll));
2790         break;
2791     }
2792
2793     case SCR_SILENCE:
2794         cast_silence(30);
2795         break;
2796
2797     case SCR_VULNERABILITY:
2798         _vulnerability_scroll();
2799         break;
2800
2801     case SCR_AMNESIA:
2802         if (!alreadyknown)
2803         {
2804             mpr(pre_succ_msg);
2805             mpr("It is a scroll of amnesia.");
2806             // included in default force_more_message (to show it before menu)
2807         }
2808         if (you.spell_no == 0)
2809             mpr("You feel forgetful for a moment.");
2810         else if (!alreadyknown)
2811             cast_selective_amnesia();
2812         else
2813             cancel_scroll = (cast_selective_amnesia(pre_succ_msg) == -1);
2814         break;
2815
2816     default:
2817         mpr("Read a buggy scroll, please report this.");
2818         break;
2819     }
2820
2821     if (cancel_scroll)
2822         you.turn_is_over = false;
2823
2824     set_ident_type(scroll, true);
2825     set_ident_flags(scroll, ISFLAG_KNOW_TYPE); // for notes
2826
2827     string scroll_name = scroll.name(DESC_QUALNAME).c_str();
2828
2829     if (!cancel_scroll)
2830     {
2831         dec_inv_item_quantity(item_slot, 1);
2832         count_action(CACT_USE, OBJ_SCROLLS);
2833     }
2834
2835     if (!alreadyknown
2836         && which_scroll != SCR_ACQUIREMENT
2837         && which_scroll != SCR_BRAND_WEAPON
2838         && which_scroll != SCR_ENCHANT_WEAPON
2839         && which_scroll != SCR_IDENTIFY
2840         && which_scroll != SCR_ENCHANT_ARMOUR
2841         && which_scroll != SCR_RECHARGING
2842         && which_scroll != SCR_AMNESIA)
2843     {
2844         mprf("It %s a %s.",
2845              you.inv[item_slot].quantity < prev_quantity ? "was" : "is",
2846              scroll_name.c_str());
2847     }
2848
2849     if (!alreadyknown && dangerous)
2850     {
2851         // Xom loves it when you read an unknown scroll and there is a
2852         // dangerous monster nearby... (though not as much as potions
2853         // since there are no *really* bad scrolls, merely useless ones).
2854         xom_is_stimulated(bad_effect ? 100 : 50);
2855     }
2856
2857     if (!alreadyknown)
2858         auto_assign_item_slot(scroll);
2859
2860 }
2861
2862 bool check_stasis(const char *msg)
2863 {
2864     bool blocked = you.species == SP_FORMICID;
2865     if (blocked)
2866         mpr(msg);
2867     return blocked;
2868 }
2869
2870 #ifdef USE_TILE
2871 // Interactive menu for item drop/use.
2872
2873 void tile_item_use_floor(int idx)
2874 {
2875     if (mitm[idx].is_type(OBJ_CORPSES, CORPSE_BODY))
2876         butchery(&mitm[idx]);
2877 }
2878
2879 void tile_item_pickup(int idx, bool part)
2880 {
2881     if (item_is_stationary(mitm[idx]))
2882     {
2883         mpr("You can't pick that up.");
2884         return;
2885     }
2886
2887     if (part)
2888     {
2889         pickup_menu(idx);
2890         return;
2891     }
2892     pickup_single_item(idx, -1);
2893 }
2894
2895 void tile_item_drop(int idx, bool partdrop)
2896 {
2897     int quantity = you.inv[idx].quantity;
2898     if (partdrop && quantity > 1)
2899     {
2900         quantity = prompt_for_int("Drop how many? ", true);
2901         if (quantity < 1)
2902         {
2903             canned_msg(MSG_OK);
2904             return;
2905         }
2906         if (quantity > you.inv[idx].quantity)
2907             quantity = you.inv[idx].quantity;
2908     }
2909     drop_item(idx, quantity);
2910 }
2911
2912 void tile_item_eat_floor(int idx)
2913 {
2914     // XXX: refactor this
2915     if (mitm[idx].base_type == OBJ_CORPSES
2916             && you.species == SP_VAMPIRE
2917         || mitm[idx].base_type == OBJ_FOOD
2918             && you.undead_state() != US_UNDEAD && you.species != SP_VAMPIRE)
2919     {
2920         if (can_eat(mitm[idx], false))
2921             eat_item(mitm[idx]);
2922     }
2923 }
2924
2925 void tile_item_use_secondary(int idx)
2926 {
2927     const item_def item = you.inv[idx];
2928
2929     if (item.base_type == OBJ_WEAPONS && is_throwable(&you, item))
2930     {
2931         if (check_warning_inscriptions(item, OPER_FIRE))
2932             fire_thing(idx); // fire weapons
2933     }
2934     else if (you.equip[EQ_WEAPON] == idx)
2935         wield_weapon(true, SLOT_BARE_HANDS);
2936     else if (item_is_wieldable(item))
2937     {
2938         // secondary wield for several spells and such
2939         wield_weapon(true, idx); // wield
2940     }
2941 }
2942
2943 void tile_item_use(int idx)
2944 {
2945     const item_def item = you.inv[idx];
2946
2947     // Equipped?
2948     bool equipped = false;
2949     bool equipped_weapon = false;
2950     for (unsigned int i = 0; i < NUM_EQUIP; i++)
2951     {
2952         if (you.equip[i] == idx)
2953         {
2954             equipped = true;
2955             if (i == EQ_WEAPON)
2956                 equipped_weapon = true;
2957             break;
2958         }
2959     }
2960
2961     // Special case for folks who are wielding something
2962     // that they shouldn't be wielding.
2963     // Note that this is only a problem for equipables
2964     // (otherwise it would only waste a turn)
2965     if (you.equip[EQ_WEAPON] == idx
2966         && (item.base_type == OBJ_ARMOUR
2967             || item.base_type == OBJ_JEWELLERY))
2968     {
2969         wield_weapon(true, SLOT_BARE_HANDS);
2970         return;
2971     }
2972
2973     const int type = item.base_type;
2974
2975     // Use it
2976     switch (type)
2977     {
2978         case OBJ_WEAPONS:
2979         case OBJ_STAVES:
2980         case OBJ_RODS:
2981         case OBJ_MISCELLANY:
2982         case OBJ_WANDS:
2983             // Wield any unwielded item of these types.
2984             if (!equipped && item_is_wieldable(item))
2985             {
2986                 wield_weapon(true, idx);
2987                 return;
2988             }
2989             // Evoke misc. items, rods, or wands.
2990             if (item_is_evokable(item, false))
2991             {
2992                 evoke_item(idx);
2993                 return;
2994             }
2995             // Unwield wielded items.
2996             if (equipped)
2997                 wield_weapon(true, SLOT_BARE_HANDS);
2998             return;
2999
3000         case OBJ_MISSILES:
3001             if (check_warning_inscriptions(item, OPER_FIRE))
3002                 fire_thing(idx);
3003             return;
3004
3005         case OBJ_ARMOUR:
3006             if (!form_can_wear())
3007             {
3008                 mpr("You can't wear or remove anything in your present form.");
3009                 return;
3010             }
3011             if (equipped && !equipped_weapon)
3012             {
3013                 if (check_warning_inscriptions(item, OPER_TAKEOFF))
3014                     takeoff_armour(idx);
3015             }
3016             else if (check_warning_inscriptions(item, OPER_WEAR))
3017                 wear_armour(idx);
3018             return;
3019
3020         case OBJ_CORPSES:
3021             if (you.species != SP_VAMPIRE
3022                 || item.sub_type == CORPSE_SKELETON)
3023             {
3024                 break;
3025             }
3026             // intentional fall-through for Vampires
3027         case OBJ_FOOD:
3028             if (check_warning_inscriptions(item, OPER_EAT))
3029                 eat_food(idx);
3030             return;
3031
3032         case OBJ_BOOKS:
3033             if (item.sub_type == BOOK_MANUAL)
3034                 return;
3035             if (!item_is_spellbook(item) || !you.skill(SK_SPELLCASTING))
3036             {
3037                 if (check_warning_inscriptions(item, OPER_READ))
3038                     _handle_read_book(idx);
3039             } // else it's a spellbook
3040             else if (check_warning_inscriptions(item, OPER_MEMORISE))
3041                 learn_spell(); // offers all spells, might not be what we want
3042             return;
3043
3044         case OBJ_SCROLLS:
3045             if (check_warning_inscriptions(item, OPER_READ))
3046                 read(idx);
3047             return;
3048
3049         case OBJ_JEWELLERY:
3050             if (equipped && !equipped_weapon)
3051                 remove_ring(idx);
3052             else if (check_warning_inscriptions(item, OPER_PUTON))
3053                 puton_ring(idx);
3054             return;
3055
3056         case OBJ_POTIONS:
3057             if (check_warning_inscriptions(item, OPER_QUAFF))
3058                 drink(idx);
3059             return;
3060
3061         default:
3062             return;
3063     }
3064 }
3065 #endif