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