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