Revamp Item Destruction
[crawl:crawl.git] / crawl-ref / source / item_use.cc
1 /**
2  * @file
3  * @brief Functions for making use of inventory items.
4 **/
5
6 #include "AppHdr.h"
7
8 #include "item_use.h"
9
10 #include "abl-show.h"
11 #include "areas.h"
12 #include "art-enum.h"
13 #include "artefact.h"
14 #include "cloud.h"
15 #include "colour.h"
16 #include "coordit.h"
17 #include "decks.h"
18 #include "delay.h"
19 #include "describe.h"
20 #include "effects.h"
21 #include "env.h"
22 #include "exercise.h"
23 #include "food.h"
24 #include "godconduct.h"
25 #include "goditem.h"
26 #include "hints.h"
27 #include "invent.h"
28 #include "evoke.h"
29 #include "itemprop.h"
30 #include "items.h"
31 #include "libutil.h"
32 #include "macro.h"
33 #include "makeitem.h"
34 #include "message.h"
35 #include "mgen_data.h"
36 #include "misc.h"
37 #include "mon-behv.h"
38 #include "mon-place.h"
39 #include "mutation.h"
40 #include "options.h"
41 #include "player-equip.h"
42 #include "player-stats.h"
43 #include "potion.h"
44 #include "religion.h"
45 #include "shout.h"
46 #include "skills.h"
47 #include "spl-book.h"
48 #include "spl-clouds.h"
49 #include "spl-damage.h"
50 #include "spl-goditem.h"
51 #include "spl-miscast.h"
52 #include "spl-selfench.h"
53 #include "spl-summoning.h"
54 #include "spl-transloc.h"
55 #include "state.h"
56 #include "stuff.h"
57 #include "target.h"
58 #include "throw.h"
59 #include "transform.h"
60 #include "uncancel.h"
61 #include "unwind.h"
62 #include "view.h"
63 #include "xom.h"
64
65 static bool _drink_fountain();
66 static int _handle_enchant_armour(int item_slot = -1,
67                                   string *pre_msg = NULL);
68
69 static bool _is_cancellable_scroll(scroll_type scroll);
70 static bool _safe_to_remove_or_wear(const item_def &item, bool remove,
71                                     bool quiet = false);
72
73 // Rather messy - we've gathered all the can't-wield logic from wield_weapon()
74 // here.
75 bool can_wield(item_def *weapon, bool say_reason,
76                bool ignore_temporary_disability, bool unwield, bool only_known)
77 {
78 #define SAY(x) {if (say_reason) { x; }}
79
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     for (int i = EQ_MIN_ARMOUR; i <= EQ_MAX_WORN; i++)
113     {
114         if (you.equip[i] != -1 && &you.inv[you.equip[i]] == weapon)
115         {
116             SAY(mpr("You are wearing that object!"));
117             return false;
118         }
119     }
120
121     if (you.species == SP_FELID && is_weapon(*weapon))
122     {
123         SAY(mpr("You can't use weapons."));
124         return false;
125     }
126
127     if (weapon->base_type == OBJ_ARMOUR)
128     {
129         SAY(mpr("You can't wield armour."));
130         return false;
131     }
132
133     if (weapon->base_type == OBJ_JEWELLERY)
134     {
135         SAY(mpr("You can't wield jewellery."));
136         return false;
137     }
138
139     // Only ogres and trolls can wield giant clubs (>= 30 aum)
140     // and large rocks (60 aum).
141     if (you.body_size() < SIZE_LARGE
142         && (item_mass(*weapon) >= 500
143             || weapon->base_type == OBJ_WEAPONS
144                && item_mass(*weapon) >= 300))
145     {
146         SAY(mpr("That's too large and heavy for you to wield."));
147         return false;
148     }
149
150     // All non-weapons only need a shield check.
151     if (weapon->base_type != OBJ_WEAPONS)
152     {
153         if (!ignore_temporary_disability && is_shield_incompatible(*weapon))
154         {
155             SAY(mpr("You can't wield that with a shield."));
156             return false;
157         }
158         else
159             return true;
160     }
161
162     // Small species wielding large weapons...
163     if (you.body_size(PSIZE_BODY) < SIZE_MEDIUM
164         && !check_weapon_wieldable_size(*weapon, you.body_size(PSIZE_BODY)))
165     {
166         SAY(mpr("That's too large for you to wield."));
167         return false;
168     }
169
170     if (you.undead_or_demonic() && is_holy_item(*weapon)
171         && (item_type_known(*weapon) || !only_known))
172     {
173         if (say_reason)
174         {
175             mpr("This weapon is holy and will not allow you to wield it.");
176             // If it's a standard weapon, you know its ego now.
177             if (!is_artefact(*weapon) && !is_blessed(*weapon)
178                 && !item_type_known(*weapon))
179             {
180                 set_ident_flags(*weapon, ISFLAG_KNOW_TYPE);
181                 if (in_inventory(*weapon))
182                     mpr_nocap(weapon->name(DESC_INVENTORY_EQUIP).c_str());
183             }
184             else if (is_artefact(*weapon) && !item_type_known(*weapon))
185                 artefact_wpn_learn_prop(*weapon, ARTP_BRAND);
186         }
187         return false;
188     }
189
190     if (!ignore_temporary_disability
191         && you.hunger_state < HS_FULL
192         && get_weapon_brand(*weapon) == SPWPN_VAMPIRICISM
193         && !crawl_state.game_is_zotdef()
194         && !you.is_undead
195         && !you_foodless()
196         && (item_type_known(*weapon) || !only_known))
197     {
198         if (say_reason)
199         {
200             mpr("As you grasp it, you feel a great hunger. Being not satiated, you stop.");
201             // If it's a standard weapon, you know its ego now.
202             if (!is_artefact(*weapon) && !is_blessed(*weapon)
203                 && !item_type_known(*weapon))
204             {
205                 set_ident_flags(*weapon, ISFLAG_KNOW_TYPE);
206                 if (in_inventory(*weapon))
207                     mpr_nocap(weapon->name(DESC_INVENTORY_EQUIP).c_str());
208             }
209             else if (is_artefact(*weapon) && !item_type_known(*weapon))
210                 artefact_wpn_learn_prop(*weapon, ARTP_BRAND);
211         }
212         return false;
213     }
214
215     if (!ignore_temporary_disability && is_shield_incompatible(*weapon))
216     {
217         SAY(mpr("You can't wield that with a shield."));
218         return false;
219     }
220
221     // We can wield this weapon. Phew!
222     return true;
223
224 #undef SAY
225 }
226
227 static bool _valid_weapon_swap(const item_def &item)
228 {
229     if (is_weapon(item))
230         return (you.species != SP_FELID);
231
232     // Some misc. items need to be wielded to be evoked.
233     if (is_deck(item) || item.base_type == OBJ_MISCELLANY
234                          && item.sub_type == MISC_LANTERN_OF_SHADOWS)
235     {
236         return true;
237     }
238
239     if (item.base_type == OBJ_MISSILES
240         && (item.sub_type == MI_STONE || item.sub_type == MI_LARGE_ROCK))
241     {
242         return you.has_spell(SPELL_SANDBLAST);
243     }
244
245     // Snakable missiles; weapons were already handled above.
246     if (item_is_snakable(item) && you.has_spell(SPELL_STICKS_TO_SNAKES))
247         return true;
248
249     // Sublimation of Blood.
250     if (!you.has_spell(SPELL_SUBLIMATION_OF_BLOOD))
251         return false;
252
253     if (item.base_type == OBJ_FOOD)
254         return (item.sub_type == FOOD_CHUNK);
255
256     if (item.base_type == OBJ_POTIONS && item_type_known(item))
257     {
258         return (item.sub_type == POT_BLOOD
259                 || item.sub_type == POT_BLOOD_COAGULATED);
260     }
261
262     return false;
263 }
264
265 /**
266  * @param force If true, don't check weapon inscriptions.
267  * (Assuming the player was already prompted for that.)
268  */
269 bool wield_weapon(bool auto_wield, int slot, bool show_weff_messages,
270                   bool force, bool show_unwield_msg, bool show_wield_msg)
271 {
272     const bool was_barehanded = you.equip[EQ_WEAPON] == -1;
273
274     if (inv_count() < 1)
275     {
276         canned_msg(MSG_NOTHING_CARRIED);
277         return false;
278     }
279
280     // Look for conditions like berserking that could prevent wielding
281     // weapons.
282     if (!can_wield(NULL, true, false, slot == SLOT_BARE_HANDS))
283         return false;
284
285     int item_slot = 0;          // default is 'a'
286
287     if (auto_wield)
288     {
289         if (item_slot == you.equip[EQ_WEAPON]
290             || you.equip[EQ_WEAPON] == -1
291                && !_valid_weapon_swap(you.inv[item_slot]))
292         {
293             item_slot = 1;      // backup is 'b'
294         }
295
296         if (slot != -1)         // allow external override
297             item_slot = slot;
298     }
299
300     // If the swap slot has a bad (but valid) item in it,
301     // the swap will be to bare hands.
302     const bool good_swap = (item_slot == SLOT_BARE_HANDS
303                             || _valid_weapon_swap(you.inv[item_slot]));
304
305     // Prompt if not using the auto swap command, or if the swap slot
306     // is empty.
307     if (item_slot != SLOT_BARE_HANDS
308         && (!auto_wield || !you.inv[item_slot].defined() || !good_swap))
309     {
310         if (!auto_wield)
311         {
312             item_slot = prompt_invent_item(
313                             "Wield which item (- for none, * to show all)?",
314                             MT_INVLIST, OSEL_WIELD,
315                             true, true, true, '-', -1, NULL, OPER_WIELD);
316         }
317         else
318             item_slot = SLOT_BARE_HANDS;
319     }
320
321     if (prompt_failed(item_slot))
322         return false;
323     else if (item_slot == you.equip[EQ_WEAPON])
324     {
325         mpr("You are already wielding that!");
326         return true;
327     }
328
329     // Now we really change weapons! (Most likely, at least...)
330     if (you.duration[DUR_SURE_BLADE])
331     {
332         mpr("The bond with your blade fades away.");
333         you.duration[DUR_SURE_BLADE] = 0;
334     }
335     // Reset the warning counter.
336     you.received_weapon_warning = false;
337
338     if (item_slot == SLOT_BARE_HANDS)
339     {
340         if (const item_def* wpn = you.weapon())
341         {
342             // Can we safely unwield this item?
343             if (needs_handle_warning(*wpn, OPER_WIELD))
344             {
345                 const string prompt =
346                     "Really unwield " + wpn->name(DESC_INVENTORY) + "?";
347                 if (!yesno(prompt.c_str(), false, 'n'))
348                 {
349                     canned_msg(MSG_OK);
350                     return false;
351                 }
352             }
353
354             if (!unwield_item(show_weff_messages))
355                 return false;
356
357             if (show_unwield_msg)
358                 canned_msg(MSG_EMPTY_HANDED_NOW);
359
360             // Switching to bare hands is extra fast.
361             you.turn_is_over = true;
362             you.time_taken *= 3;
363             you.time_taken /= 10;
364         }
365         else
366             canned_msg(MSG_EMPTY_HANDED_ALREADY);
367
368         return true;
369     }
370
371     item_def& new_wpn(you.inv[item_slot]);
372
373     // Non-auto_wield cases are checked below.
374     if (auto_wield && !force
375         && !check_warning_inscriptions(new_wpn, OPER_WIELD))
376     {
377         return false;
378     }
379
380     // Ensure wieldable, stat loss non-fatal
381     if (!can_wield(&new_wpn, true) || !_safe_to_remove_or_wear(new_wpn, false))
382         return false;
383
384     // Unwield any old weapon.
385     if (you.weapon())
386     {
387         if (unwield_item(show_weff_messages))
388         {
389             // Enable skills so they can be re-disabled later
390             update_can_train();
391         }
392         else
393             return false;
394     }
395
396     // Really ensure wieldable, even unknown brand
397     if (!can_wield(&new_wpn, true, false, false, false))
398     {
399         if (!was_barehanded)
400         {
401             canned_msg(MSG_EMPTY_HANDED_NOW);
402
403             // Switching to bare hands is extra fast.
404             you.turn_is_over = true;
405             you.time_taken *= 3;
406             you.time_taken /= 10;
407         }
408
409         return false;
410     }
411
412     const unsigned int old_talents = your_talents(false).size();
413
414     // Go ahead and wield the weapon.
415     equip_item(EQ_WEAPON, item_slot, show_weff_messages);
416
417     if (show_wield_msg)
418         mpr_nocap(new_wpn.name(DESC_INVENTORY_EQUIP).c_str());
419
420     check_item_hint(new_wpn, old_talents);
421
422     // Time calculations.
423     you.time_taken /= 2;
424
425     you.wield_change  = true;
426     you.m_quiver->on_weapon_changed();
427     you.turn_is_over  = true;
428
429     return true;
430 }
431
432 static const char *shield_base_name(const item_def *shield)
433 {
434     return (shield->sub_type == ARM_BUCKLER? "buckler"
435                                            : "shield");
436 }
437
438 static const char *shield_impact_degree(int impact)
439 {
440     return (impact > 160 ? "severely "      :
441             impact > 130 ? "significantly " :
442             impact > 110 ? ""
443                          : NULL);
444 }
445
446 static void _warn_launcher_shield_slowdown(const item_def &launcher)
447 {
448     const int slowspeed =
449         launcher_final_speed(launcher, you.shield()) * player_speed() / 100;
450     const int normspeed =
451         launcher_final_speed(launcher, NULL) * player_speed() / 100;
452
453     // Don't warn the player unless the slowdown is real.
454     if (slowspeed > normspeed)
455     {
456         const char *slow_degree =
457             shield_impact_degree(slowspeed * 100 / normspeed);
458
459         if (slow_degree)
460         {
461             mprf(MSGCH_WARN,
462                     "Your %s %sslows your rate of fire.",
463                     shield_base_name(you.shield()),
464                     slow_degree);
465         }
466     }
467 }
468
469 // Warn if your shield is greatly impacting the effectiveness of your weapon?
470 void warn_shield_penalties()
471 {
472     if (!you.shield())
473         return;
474
475     // Warnings are limited to launchers at the moment.
476     const item_def *weapon = you.weapon();
477     if (!weapon)
478         return;
479
480     if (is_range_weapon(*weapon))
481         _warn_launcher_shield_slowdown(*weapon);
482 }
483
484 bool item_is_worn(int inv_slot)
485 {
486     for (int i = EQ_MIN_ARMOUR; i <= EQ_MAX_WORN; ++i)
487         if (inv_slot == you.equip[i])
488             return true;
489
490     return false;
491 }
492
493 //---------------------------------------------------------------
494 //
495 // armour_prompt
496 //
497 // Prompt the user for some armour. Returns true if the user picked
498 // something legit.
499 //
500 //---------------------------------------------------------------
501 bool armour_prompt(const string & mesg, int *index, operation_types oper)
502 {
503     ASSERT(index != NULL);
504
505     if (inv_count() < 1)
506         canned_msg(MSG_NOTHING_CARRIED);
507     else if (you.berserk())
508         canned_msg(MSG_TOO_BERSERK);
509     else
510     {
511         int selector = OBJ_ARMOUR;
512         if (oper == OPER_TAKEOFF && !Options.equip_unequip)
513             selector = OSEL_WORN_ARMOUR;
514         int slot = prompt_invent_item(mesg.c_str(), MT_INVLIST, selector,
515                                       true, true, true, 0, -1, NULL,
516                                       oper);
517
518         if (!prompt_failed(slot))
519         {
520             *index = slot;
521             return true;
522         }
523     }
524
525     return false;
526 }
527
528 static bool cloak_is_being_removed(void)
529 {
530     if (current_delay_action() != DELAY_ARMOUR_OFF)
531         return false;
532
533     if (you.delay_queue.front().parm1 != you.equip[ EQ_CLOAK ])
534         return false;
535
536     return true;
537 }
538
539 //---------------------------------------------------------------
540 //
541 // wear_armour
542 //
543 //---------------------------------------------------------------
544 void wear_armour(int slot) // slot is for tiles
545 {
546     if (you.species == SP_FELID)
547     {
548         mpr("You can't wear anything.");
549         return;
550     }
551
552     if (!form_can_wear())
553     {
554         mpr("You can't wear anything in your present form.");
555         return;
556     }
557
558     int armour_wear_2 = 0;
559
560     if (slot != -1)
561         armour_wear_2 = slot;
562     else if (!armour_prompt("Wear which item?", &armour_wear_2, OPER_WEAR))
563         return;
564
565     do_wear_armour(armour_wear_2, false);
566 }
567
568 static int armour_equip_delay(const item_def &item)
569 {
570     int delay = property(item, PARM_AC);
571
572     // Shields are comparatively easy to wear.
573     if (is_shield(item))
574         delay = delay / 2 + 1;
575
576     if (delay < 1)
577         delay = 1;
578
579     return delay;
580 }
581
582 bool can_wear_armour(const item_def &item, bool verbose, bool ignore_temporary)
583 {
584     const object_class_type base_type = item.base_type;
585     if (base_type != OBJ_ARMOUR || you.species == SP_FELID)
586     {
587         if (verbose)
588             mpr("You can't wear that.");
589
590         return false;
591     }
592
593     const int sub_type = item.sub_type;
594     const equipment_type slot = get_armour_slot(item);
595
596     if (you.species == SP_OCTOPODE && slot != EQ_HELMET && slot != EQ_SHIELD)
597     {
598         if (verbose)
599             mpr("You can't wear that!");
600         return false;
601     }
602
603     if (player_genus(GENPC_DRACONIAN) && slot == EQ_BODY_ARMOUR)
604     {
605         if (verbose)
606         {
607             mprf("Your wings%s won't fit in that.", you.mutation[MUT_BIG_WINGS]
608                  ? "" : ", even vestigial as they are,");
609         }
610         return false;
611     }
612
613     if (sub_type == ARM_NAGA_BARDING || sub_type == ARM_CENTAUR_BARDING)
614     {
615         if (you.species == SP_NAGA && sub_type == ARM_NAGA_BARDING
616             || you.species == SP_CENTAUR && sub_type == ARM_CENTAUR_BARDING)
617         {
618             if (ignore_temporary || !player_is_shapechanged())
619                 return true;
620             else if (verbose)
621                 mpr("You can wear that only in your normal form.");
622         }
623         else if (verbose)
624             mpr("You can't wear that!");
625         return false;
626     }
627
628     // Lear's hauberk covers also head, hands and legs.
629     if (is_unrandom_artefact(item) && item.special == UNRAND_LEAR)
630     {
631         if (!player_has_feet(!ignore_temporary))
632         {
633             if (verbose)
634                 mpr("You have no feet.");
635             return false;
636         }
637
638         if (!ignore_temporary)
639         {
640             for (int s = EQ_HELMET; s <= EQ_BOOTS; s++)
641             {
642                 // No strange race can wear this.
643                 const char* parts[] = { "head", "hands", "feet" };
644                 // Auto-disrobing would be nice.
645                 if (you.equip[s] != -1)
646                 {
647                     if (verbose)
648                         mprf("You'd need your %s free.", parts[s - EQ_HELMET]);
649                     return false;
650                 }
651
652                 if (!you_tran_can_wear(s, true))
653                 {
654                     if (verbose)
655                     {
656                         mprf(you_tran_can_wear(s) ? "The hauberk won't fit your %s."
657                                                   : "You have no %s!",
658                              parts[s - EQ_HELMET]);
659                     }
660                     return false;
661                 }
662             }
663         }
664     }
665     else if (slot >= EQ_HELMET && slot <= EQ_BOOTS
666              && !ignore_temporary
667              && player_equip_unrand(UNRAND_LEAR))
668     {
669         // The explanation is iffy for loose headgear, especially crowns:
670         // kings loved hooded hauberks, according to portraits.
671         if (verbose)
672             mpr("You can't wear this over your hauberk.");
673         return false;
674     }
675
676     size_type player_size = you.body_size(PSIZE_TORSO, ignore_temporary);
677     int bad_size = fit_armour_size(item, player_size);
678
679     if (bad_size)
680     {
681         if (verbose)
682             mprf("This armour is too %s for you!",
683                  (bad_size > 0) ? "big" : "small");
684
685         return false;
686     }
687
688     if (you.form == TRAN_APPENDAGE
689         && ignore_temporary
690         && slot == beastly_slot(you.attribute[ATTR_APPENDAGE])
691         && you.mutation[you.attribute[ATTR_APPENDAGE]])
692     {
693         unwind_var<uint8_t> mutv(you.mutation[you.attribute[ATTR_APPENDAGE]], 0);
694         // disable the mutation then check again
695         return can_wear_armour(item, verbose, ignore_temporary);
696     }
697
698     if (sub_type == ARM_GLOVES)
699     {
700         if (you.has_claws(false) == 3)
701         {
702             if (verbose)
703                 mpr("You can't wear gloves with your huge claws!");
704             return false;
705         }
706     }
707
708     if (sub_type == ARM_BOOTS)
709     {
710         if (player_mutation_level(MUT_HOOVES) == 3)
711         {
712             if (verbose)
713                 mpr("You can't wear boots with hooves!");
714             return false;
715         }
716
717         if (you.has_talons(false) == 3)
718         {
719             if (verbose)
720                 mpr("Boots don't fit your talons!");
721             return false;
722         }
723
724         if (you.species == SP_NAGA || you.species == SP_DJINNI)
725         {
726             if (verbose)
727                 mpr("You have no legs!");
728             return false;
729         }
730
731         if (!ignore_temporary && you.fishtail)
732         {
733             if (verbose)
734                 mpr("You don't currently have feet!");
735             return false;
736         }
737     }
738
739     if (slot == EQ_HELMET)
740     {
741         // Horns 3 & Antennae 3 mutations disallow all headgear
742         if (player_mutation_level(MUT_HORNS) == 3)
743         {
744             if (verbose)
745                 mpr("You can't wear any headgear with your large horns!");
746             return false;
747         }
748
749         if (player_mutation_level(MUT_ANTENNAE) == 3)
750         {
751             if (verbose)
752                 mpr("You can't wear any headgear with your large antennae!");
753             return false;
754         }
755
756         // Soft helmets (caps and wizard hats) always fit, otherwise.
757         if (is_hard_helmet(item))
758         {
759             if (player_mutation_level(MUT_HORNS))
760             {
761                 if (verbose)
762                     mpr("You can't wear that with your horns!");
763                 return false;
764             }
765
766             if (player_mutation_level(MUT_BEAK))
767             {
768                 if (verbose)
769                     mpr("You can't wear that with your beak!");
770                 return false;
771             }
772
773             if (player_mutation_level(MUT_ANTENNAE))
774             {
775                 if (verbose)
776                     mpr("You can't wear that with your antennae!");
777                 return false;
778             }
779
780             if (player_genus(GENPC_DRACONIAN))
781             {
782                 if (verbose)
783                     mpr("You can't wear that with your reptilian head.");
784                 return false;
785             }
786
787             if (you.species == SP_OCTOPODE)
788             {
789                 if (verbose)
790                     mpr("You can't wear that!");
791                 return false;
792             }
793         }
794     }
795
796     if (!ignore_temporary && !form_can_wear_item(item, you.form))
797     {
798         if (verbose)
799             mpr("You can't wear that in your present form.");
800         return false;
801     }
802
803     return true;
804 }
805
806 bool do_wear_armour(int item, bool quiet)
807 {
808     const item_def &invitem = you.inv[item];
809     if (!invitem.defined())
810     {
811         if (!quiet)
812             mpr("You don't have any such object.");
813         return false;
814     }
815
816     if (!can_wear_armour(invitem, !quiet, false))
817         return false;
818
819     const equipment_type slot = get_armour_slot(invitem);
820
821     if (item == you.equip[EQ_WEAPON])
822     {
823         if (!quiet)
824             mpr("You are wielding that object!");
825         return false;
826     }
827
828     if (item_is_worn(item))
829     {
830         if (Options.equip_unequip)
831             return !takeoff_armour(item);
832         else
833         {
834             mpr("You're already wearing that object!");
835             return false;
836         }
837     }
838
839     // if you're wielding something,
840     if (you.weapon()
841         // attempting to wear a shield,
842         && is_shield(invitem)
843         && is_shield_incompatible(*you.weapon(), &invitem))
844     {
845         if (!quiet)
846         {
847             if (you.species == SP_OCTOPODE)
848                 mpr("You need the rest of your tentacles for walking.");
849             else
850                 mprf("You'd need three %s to do that!", you.hand_name(true).c_str());
851         }
852         return false;
853     }
854
855     bool removed_cloak = false;
856     int  cloak = -1;
857
858     // Removing body armour requires removing the cloak first.
859     if (slot == EQ_BODY_ARMOUR
860         && you.equip[EQ_CLOAK] != -1 && !cloak_is_being_removed())
861     {
862         if (you.equip[EQ_BODY_ARMOUR] != -1
863             && you.inv[you.equip[EQ_BODY_ARMOUR]].cursed())
864         {
865             if (!quiet)
866             {
867                 mprf("%s is stuck to your body!",
868                      you.inv[you.equip[EQ_BODY_ARMOUR]].name(DESC_YOUR)
869                                                        .c_str());
870             }
871             return false;
872         }
873         if (!you.inv[you.equip[EQ_CLOAK]].cursed())
874         {
875             cloak = you.equip[EQ_CLOAK];
876             if (!takeoff_armour(you.equip[EQ_CLOAK]))
877                 return false;
878
879             removed_cloak = true;
880         }
881         else
882         {
883             if (!quiet)
884                 mpr("Your cloak prevents you from wearing the armour.");
885             return false;
886         }
887     }
888
889     if ((slot == EQ_CLOAK
890            || slot == EQ_HELMET
891            || slot == EQ_GLOVES
892            || slot == EQ_BOOTS
893            || slot == EQ_SHIELD
894            || slot == EQ_BODY_ARMOUR)
895         && you.equip[slot] != -1)
896     {
897         if (!takeoff_armour(you.equip[slot]))
898             return false;
899     }
900
901     you.turn_is_over = true;
902
903     if (!_safe_to_remove_or_wear(invitem, false))
904         return false;
905
906     const int delay = armour_equip_delay(invitem);
907     if (delay)
908         start_delay(DELAY_ARMOUR_ON, delay, item);
909
910     if (removed_cloak)
911         start_delay(DELAY_ARMOUR_ON, 1, cloak);
912
913     return true;
914 }
915
916 bool takeoff_armour(int item)
917 {
918     const item_def& invitem = you.inv[item];
919
920     if (invitem.base_type != OBJ_ARMOUR)
921     {
922         mpr("You aren't wearing that!");
923         return false;
924     }
925
926     if (you.berserk())
927     {
928         canned_msg(MSG_TOO_BERSERK);
929         return false;
930     }
931
932     const equipment_type slot = get_armour_slot(invitem);
933     if (item == you.equip[slot] && you.melded[slot])
934     {
935         mprf("%s is melded into your body!",
936              invitem.name(DESC_YOUR).c_str());
937         return false;
938     }
939
940     if (!item_is_worn(item))
941     {
942         if (Options.equip_unequip)
943             return do_wear_armour(item, true);
944         else
945         {
946             mpr("You aren't wearing that object!");
947             return false;
948         }
949     }
950
951     // If we get here, we're wearing the item.
952     if (invitem.cursed())
953     {
954         mprf("%s is stuck to your body!", invitem.name(DESC_YOUR).c_str());
955         return false;
956     }
957
958     if (!_safe_to_remove_or_wear(invitem, true))
959         return false;
960
961     bool removed_cloak = false;
962     int cloak = -1;
963
964     if (slot == EQ_BODY_ARMOUR)
965     {
966         if (you.equip[EQ_CLOAK] != -1 && !cloak_is_being_removed())
967         {
968             if (!you.inv[you.equip[EQ_CLOAK]].cursed())
969             {
970                 cloak = you.equip[ EQ_CLOAK ];
971                 if (!takeoff_armour(you.equip[EQ_CLOAK]))
972                     return false;
973
974                 removed_cloak = true;
975             }
976             else
977             {
978                 mpr("Your cloak prevents you from removing the armour.");
979                 return false;
980             }
981         }
982     }
983     else
984     {
985         switch (slot)
986         {
987         case EQ_SHIELD:
988         case EQ_CLOAK:
989         case EQ_HELMET:
990         case EQ_GLOVES:
991         case EQ_BOOTS:
992             if (item != you.equip[slot])
993             {
994                 mpr("You aren't wearing that!");
995                 return false;
996             }
997             break;
998
999         default:
1000             break;
1001         }
1002     }
1003
1004     you.turn_is_over = true;
1005
1006     const int delay = armour_equip_delay(invitem);
1007     start_delay(DELAY_ARMOUR_OFF, delay, item);
1008
1009     if (removed_cloak)
1010         start_delay(DELAY_ARMOUR_ON, 1, cloak);
1011
1012     return true;
1013 }
1014
1015 static int _prompt_ring_to_remove(int new_ring)
1016 {
1017     const item_def *left  = you.slot_item(EQ_LEFT_RING, true);
1018     const item_def *right = you.slot_item(EQ_RIGHT_RING, true);
1019
1020     mesclr();
1021     mprf("Wearing %s.", you.inv[new_ring].name(DESC_A).c_str());
1022
1023     const char lslot = index_to_letter(left->link);
1024     const char rslot = index_to_letter(right->link);
1025
1026 #ifdef TOUCH_UI
1027     string prompt = "You're wearing two rings. Remove which one?";
1028     Popup *pop = new Popup(prompt);
1029     pop->push_entry(new MenuEntry(prompt, MEL_TITLE));
1030     InvEntry *me = new InvEntry(*left);
1031     pop->push_entry(me);
1032     me = new InvEntry(*right);
1033     pop->push_entry(me);
1034
1035     int c;
1036     do
1037         c = pop->pop();
1038     while (c != lslot && c != rslot && c != '<' && c != '>'
1039            && !key_is_escape(c) && c != ' ');
1040
1041 #else
1042     mprf(MSGCH_PROMPT,
1043          "You're wearing two rings. Remove which one? (%c/%c/<</>/Esc)",
1044          lslot, rslot);
1045
1046     mprf(" << or %s", left->name(DESC_INVENTORY).c_str());
1047     mprf(" > or %s", right->name(DESC_INVENTORY).c_str());
1048     flush_prev_message();
1049
1050     // Deactivate choice from tile inventory.
1051     // FIXME: We need to be able to get the choice (item letter)
1052     //        *without* the choice taking action by itself!
1053     mouse_control mc(MOUSE_MODE_PROMPT);
1054     int c;
1055     do
1056         c = getchm();
1057     while (c != lslot && c != rslot && c != '<' && c != '>'
1058            && !key_is_escape(c) && c != ' ');
1059 #endif
1060
1061     mesclr();
1062
1063     if (key_is_escape(c) || c == ' ')
1064         return -1;
1065
1066     const int eqslot = (c == lslot || c == '<') ? EQ_LEFT_RING
1067                                                 : EQ_RIGHT_RING;
1068     return you.equip[eqslot];
1069 }
1070
1071 static int _prompt_ring_to_remove_octopode(int new_ring)
1072 {
1073     const item_def *rings[8];
1074     char slots[8];
1075
1076     const int num_rings = (form_keeps_mutations() || you.form == TRAN_SPIDER
1077                            ? 8 : 2);
1078
1079     for (int i = 0; i < num_rings; i++)
1080     {
1081         rings[i] = you.slot_item((equipment_type)(EQ_RING_ONE + i), true);
1082         ASSERT(rings[i]);
1083         slots[i] = index_to_letter(rings[i]->link);
1084     }
1085
1086     mesclr();
1087 //    mprf("Wearing %s.", you.inv[new_ring].name(DESC_A).c_str());
1088
1089     mprf(MSGCH_PROMPT,
1090          "You're wearing all the rings you can. Remove which one?");
1091 //I think it looks better without the letters.
1092 // (%c/%c/%c/%c/%c/%c/%c/%c/Esc)",
1093 //         one_slot, two_slot, three_slot, four_slot, five_slot, six_slot, seven_slot, eight_slot);
1094     mprf(MSGCH_PROMPT, "(<w>?</w> for menu, <w>Esc</w> to cancel)");
1095
1096     for (int i = 0; i < num_rings; i++)
1097         mprf_nocap("%s", rings[i]->name(DESC_INVENTORY).c_str());
1098     flush_prev_message();
1099
1100     // Deactivate choice from tile inventory.
1101     // FIXME: We need to be able to get the choice (item letter)
1102     //        *without* the choice taking action by itself!
1103     int eqslot = EQ_NONE;
1104
1105     mouse_control mc(MOUSE_MODE_PROMPT);
1106     int c;
1107     do
1108     {
1109         c = getchm();
1110         for (int i = 0; i < num_rings; i++)
1111             if (c == slots[i])
1112             {
1113                 eqslot = EQ_RING_ONE + i;
1114                 c = ' ';
1115                 break;
1116             }
1117     } while (!key_is_escape(c) && c != ' ' && c != '?');
1118
1119     mesclr();
1120
1121     if (c == '?')
1122         return EQ_NONE;
1123     else if (key_is_escape(c) || eqslot == EQ_NONE)
1124         return -2;
1125
1126     return you.equip[eqslot];
1127 }
1128
1129 // Checks whether a to-be-worn or to-be-removed item affects
1130 // character stats and whether wearing/removing it could be fatal.
1131 // If so, warns the player, or just returns false if quiet is true.
1132 static bool _safe_to_remove_or_wear(const item_def &item, bool remove, bool quiet)
1133 {
1134     if (remove && !safe_to_remove(item, quiet))
1135         return false;
1136
1137     int prop_str = 0;
1138     int prop_dex = 0;
1139     int prop_int = 0;
1140     if (item.base_type == OBJ_JEWELLERY
1141         && item_ident(item, ISFLAG_KNOW_PLUSES))
1142     {
1143         switch (item.sub_type)
1144         {
1145         case RING_STRENGTH:
1146             if (item.plus != 0)
1147                 prop_str = item.plus;
1148             break;
1149         case RING_DEXTERITY:
1150             if (item.plus != 0)
1151                 prop_dex = item.plus;
1152             break;
1153         case RING_INTELLIGENCE:
1154             if (item.plus != 0)
1155                 prop_int = item.plus;
1156             break;
1157         default:
1158             break;
1159         }
1160     }
1161     else if (item.base_type == OBJ_ARMOUR && item_type_known(item))
1162     {
1163         switch (item.special)
1164         {
1165         case SPARM_STRENGTH:
1166             prop_str = 3;
1167             break;
1168         case SPARM_INTELLIGENCE:
1169             prop_int = 3;
1170             break;
1171         case SPARM_DEXTERITY:
1172             prop_dex = 3;
1173             break;
1174         default:
1175             break;
1176         }
1177     }
1178
1179     if (is_artefact(item))
1180     {
1181         prop_str += artefact_known_wpn_property(item, ARTP_STRENGTH);
1182         prop_int += artefact_known_wpn_property(item, ARTP_INTELLIGENCE);
1183         prop_dex += artefact_known_wpn_property(item, ARTP_DEXTERITY);
1184     }
1185
1186     if (!remove)
1187     {
1188         prop_str *= -1;
1189         prop_int *= -1;
1190         prop_dex *= -1;
1191     }
1192     stat_type red_stat = NUM_STATS;
1193     if (prop_str >= you.strength() && you.strength() > 0)
1194         red_stat = STAT_STR;
1195     else if (prop_int >= you.intel() && you.intel() > 0)
1196         red_stat = STAT_INT;
1197     else if (prop_dex >= you.dex() && you.dex() > 0)
1198         red_stat = STAT_DEX;
1199
1200     if (red_stat == NUM_STATS)
1201         return true;
1202
1203     if (quiet)
1204         return false;
1205
1206     string verb = "";
1207     if (remove)
1208     {
1209         if (item.base_type == OBJ_WEAPONS)
1210             verb = "Unwield";
1211         else
1212             verb = "Remov";
1213     }
1214     else
1215     {
1216         if (item.base_type == OBJ_WEAPONS)
1217             verb = "Wield";
1218         else
1219             verb = "Wear";
1220     }
1221
1222     string prompt = make_stringf("%sing this item will reduce your %s to zero "
1223                                  "or below. Continue?", verb.c_str(),
1224                                  stat_desc(red_stat, SD_NAME));
1225     if (!yesno(prompt.c_str(), true, 'n', true, false))
1226     {
1227         canned_msg(MSG_OK);
1228         return false;
1229     }
1230     return true;
1231 }
1232
1233 // Checks whether removing an item would cause flight to end and the
1234 // player to fall to their death.
1235 bool safe_to_remove(const item_def &item, bool quiet)
1236 {
1237     item_info inf = get_item_info(item);
1238
1239     const bool grants_flight =
1240          inf.base_type == OBJ_JEWELLERY && inf.sub_type == RING_FLIGHT
1241          || inf.base_type == OBJ_ARMOUR && inf.special == SPARM_FLYING
1242          || is_artefact(inf)
1243             && artefact_known_wpn_property(inf, ARTP_FLY);
1244
1245     // assumes item can't grant flight twice
1246     const bool removing_ends_flight =
1247         you.flight_mode()
1248         && !you.attribute[ATTR_FLIGHT_UNCANCELLABLE]
1249         && (you.evokable_flight() == 1);
1250
1251     const dungeon_feature_type feat = grd(you.pos());
1252
1253     if (grants_flight && removing_ends_flight
1254         && (feat == DNGN_LAVA
1255             || feat == DNGN_DEEP_WATER && !player_likes_water()))
1256     {
1257         if (quiet)
1258             return false;
1259         else
1260         {
1261             string fname = (feat == DNGN_LAVA ? "lava" : "deep water");
1262             string prompt = "Really remove this item over " + fname + "?";
1263             return yesno(prompt.c_str(), false, 'n');
1264         }
1265     }
1266
1267     return true;
1268 }
1269
1270 // Assumptions:
1271 // you.inv[ring_slot] is a valid ring.
1272 // EQ_LEFT_RING and EQ_RIGHT_RING are both occupied, and ring_slot is not
1273 // one of the worn rings.
1274 //
1275 // Does not do amulets.
1276 static bool _swap_rings(int ring_slot)
1277 {
1278     const item_def* lring = you.slot_item(EQ_LEFT_RING, true);
1279     const item_def* rring = you.slot_item(EQ_RIGHT_RING, true);
1280
1281     // If ring slots were melded, we should have been prevented from
1282     // putting on the ring at all.  If it becomes possible for just
1283     // one ring slot to be melded, the subsequent code will need to
1284     // be revisited, so prevent that, too.
1285     ASSERT(!you.melded[EQ_LEFT_RING]);
1286     ASSERT(!you.melded[EQ_RIGHT_RING]);
1287
1288     if (lring->cursed() && rring->cursed())
1289     {
1290         mprf("You're already wearing two cursed rings!");
1291         return false;
1292     }
1293
1294     int unwanted;
1295
1296     // Don't prompt if both rings are of the same type.
1297     if ((lring->sub_type == rring->sub_type
1298          && lring->plus == rring->plus
1299          && lring->plus2 == rring->plus2
1300          && !is_artefact(*lring) && !is_artefact(*rring)) ||
1301         lring->cursed() || rring->cursed())
1302     {
1303         if (lring->cursed())
1304             unwanted = you.equip[EQ_RIGHT_RING];
1305         else
1306             unwanted = you.equip[EQ_LEFT_RING];
1307     }
1308     else
1309     {
1310         // Ask the player which existing ring is persona non grata.
1311         unwanted = _prompt_ring_to_remove(ring_slot);
1312     }
1313
1314     if (unwanted == -1)
1315     {
1316         canned_msg(MSG_OK);
1317         return false;
1318     }
1319
1320     if (!remove_ring(unwanted, false))
1321         return false;
1322
1323     // Check for stat loss.
1324     if (!_safe_to_remove_or_wear(you.inv[ring_slot], false))
1325         return false;
1326
1327     // Put on the new ring.
1328     start_delay(DELAY_JEWELLERY_ON, 1, ring_slot);
1329
1330     return true;
1331 }
1332
1333 static bool _swap_rings_octopode(int ring_slot)
1334 {
1335     const item_def* ring[8];
1336     for (int i = 0; i < 8; i++)
1337         ring[i] = you.slot_item((equipment_type)(EQ_RING_ONE + i), true);
1338     int array = 0;
1339     int unwanted = 0;
1340     int cursed = 0;
1341     int melded = 0; // Both melded rings and unavailable slots.
1342     int available = 0;
1343
1344     for (int slots = EQ_RING_ONE;
1345          slots < NUM_EQUIP && array < 8;
1346          ++slots, ++array)
1347     {
1348         if (!you_tran_can_wear(slots) || you.melded[slots])
1349             melded++;
1350         else if (ring[array] != NULL)
1351         {
1352             if (ring[array]->cursed())
1353                 cursed++;
1354             else
1355             {
1356                 available++;
1357                 unwanted = you.equip[slots];
1358             }
1359         }
1360     }
1361
1362     // We can't put a ring on, because we're wearing 8 cursed ones.
1363     if (melded == 8)
1364     {
1365         // Shouldn't happen, because hogs and bats can't put on jewellery at
1366         // all and thus won't get this far.
1367         mpr("You can't wear that in your present form.");
1368         return false;
1369     }
1370     else if (available == 0)
1371     {
1372         mprf("You're already wearing %s cursed rings!%s",
1373              number_in_words(cursed).c_str(),
1374              (cursed == 8 ? " Isn't that enough for you?" : ""));
1375         return false;
1376     }
1377     // The simple case - only one available ring.
1378     else if (available == 1)
1379     {
1380         if (!remove_ring(unwanted, false))
1381             return false;
1382     }
1383     // We can't put a ring on without swapping - because we found
1384     // multiple available rings.
1385     else if (available > 1)
1386     {
1387         unwanted = _prompt_ring_to_remove_octopode(ring_slot);
1388
1389         // Cancelled:
1390         if (unwanted < -1)
1391         {
1392             canned_msg(MSG_OK);
1393             return false;
1394         }
1395
1396         if (!remove_ring(unwanted, false))
1397             return false;
1398     }
1399
1400 #if 0
1401     // In case something goes wrong.
1402     if (unwanted == -1)
1403     {
1404         canned_msg(MSG_OK);
1405         return false;
1406     }
1407 #endif
1408
1409     // Put on the new ring.
1410     start_delay(DELAY_JEWELLERY_ON, 1, ring_slot);
1411
1412     return true;
1413 }
1414
1415 static bool _puton_item(int item_slot)
1416 {
1417     item_def& item = you.inv[item_slot];
1418
1419     for (int eq = EQ_LEFT_RING; eq < NUM_EQUIP; eq++)
1420         if (item_slot == you.equip[eq])
1421         {
1422             // "Putting on" an equipped item means taking it off.
1423             if (Options.equip_unequip)
1424                 return !remove_ring(item_slot);
1425             else
1426             {
1427                 mpr("You're already wearing that object!");
1428                 return false;
1429             }
1430         }
1431
1432     if (item_slot == you.equip[EQ_WEAPON])
1433     {
1434         mpr("You are wielding that object.");
1435         return false;
1436     }
1437
1438     if (item.base_type != OBJ_JEWELLERY)
1439     {
1440         mpr("You can only put on jewellery.");
1441         return false;
1442     }
1443
1444     const bool lring = you.slot_item(EQ_LEFT_RING, true);
1445     const bool rring = you.slot_item(EQ_RIGHT_RING, true);
1446     const bool is_amulet = jewellery_is_amulet(item);
1447     bool blinged_octopode = false;
1448     if (you.species == SP_OCTOPODE)
1449     {
1450         blinged_octopode = true;
1451         for (int eq = EQ_RING_ONE; eq <= EQ_RING_EIGHT; eq++)
1452         {
1453             // Skip unavailable slots.
1454             if (!you_tran_can_wear(eq))
1455                 continue;
1456
1457             if (!you.slot_item((equipment_type)eq, true))
1458             {
1459                 blinged_octopode = false;
1460                 break;
1461             }
1462         }
1463     }
1464
1465     if (!is_amulet)     // i.e. it's a ring
1466     {
1467         if (!you_tran_can_wear(item))
1468         {
1469             mpr("You can't wear that in your present form.");
1470             return false;
1471         }
1472
1473         const item_def* gloves = you.slot_item(EQ_GLOVES, false);
1474         // Cursed gloves cannot be removed.
1475         if (gloves && gloves->cursed())
1476         {
1477             mpr("You can't take your gloves off to put on a ring!");
1478             return false;
1479         }
1480
1481         if (blinged_octopode)
1482             return _swap_rings_octopode(item_slot);
1483
1484         if (lring && rring)
1485             return _swap_rings(item_slot);
1486     }
1487     else if (item_def* amulet = you.slot_item(EQ_AMULET, true))
1488     {
1489         // Remove the previous one.
1490         if (!check_warning_inscriptions(*amulet, OPER_REMOVE)
1491             || !remove_ring(you.equip[EQ_AMULET], true))
1492         {
1493             return false;
1494         }
1495
1496         // Check for stat loss.
1497         if (!_safe_to_remove_or_wear(item, false))
1498             return false;
1499
1500         // Put on the new amulet.
1501         start_delay(DELAY_JEWELLERY_ON, 1, item_slot);
1502
1503         // Assume it's going to succeed.
1504         return true;
1505     }
1506
1507     // Check for stat loss.
1508     if (!_safe_to_remove_or_wear(item, false))
1509         return false;
1510
1511     equipment_type hand_used;
1512
1513     if (is_amulet)
1514         hand_used = EQ_AMULET;
1515     else if (you.species == SP_OCTOPODE)
1516     {
1517         for (hand_used = EQ_RING_ONE; hand_used <= EQ_RING_EIGHT;
1518              hand_used = (equipment_type)(hand_used + 1))
1519         {
1520             // Skip unavailble slots.
1521             if (!you_tran_can_wear(hand_used))
1522                 continue;
1523
1524             if (!you.slot_item(hand_used, true))
1525                 break;
1526         }
1527         ASSERT(hand_used <= EQ_RING_EIGHT);
1528     }
1529     else
1530     {
1531         // First ring always goes on left hand.
1532         hand_used = EQ_LEFT_RING;
1533
1534         // ... unless we're already wearing a ring on the left hand.
1535         if (lring && !rring)
1536             hand_used = EQ_RIGHT_RING;
1537     }
1538
1539     const unsigned int old_talents = your_talents(false).size();
1540
1541     // Actually equip the item.
1542     equip_item(hand_used, item_slot);
1543
1544     check_item_hint(you.inv[item_slot], old_talents);
1545 #ifdef USE_TILE_LOCAL
1546     if (your_talents(false).size() != old_talents)
1547     {
1548         tiles.layout_statcol();
1549         redraw_screen();
1550     }
1551 #endif
1552
1553     // Putting on jewellery is as fast as wielding weapons.
1554     you.time_taken /= 2;
1555     you.turn_is_over = true;
1556
1557     return true;
1558 }
1559
1560 bool puton_ring(int slot)
1561 {
1562     int item_slot;
1563
1564     if (inv_count() < 1)
1565     {
1566         canned_msg(MSG_NOTHING_CARRIED);
1567         return false;
1568     }
1569
1570     if (you.berserk())
1571     {
1572         canned_msg(MSG_TOO_BERSERK);
1573         return false;
1574     }
1575
1576     if (slot != -1)
1577         item_slot = slot;
1578     else
1579     {
1580         item_slot = prompt_invent_item("Put on which piece of jewellery?",
1581                                         MT_INVLIST, OBJ_JEWELLERY, true, true,
1582                                         true, 0, -1, NULL, OPER_PUTON);
1583     }
1584
1585     if (prompt_failed(item_slot))
1586         return false;
1587
1588     return _puton_item(item_slot);
1589 }
1590
1591 bool remove_ring(int slot, bool announce)
1592 {
1593     equipment_type hand_used = EQ_NONE;
1594     int ring_wear_2;
1595     bool has_jewellery = false;
1596     bool has_melded = false;
1597     const equipment_type first = you.species == SP_OCTOPODE ? EQ_AMULET
1598                                                             : EQ_LEFT_RING;
1599     const equipment_type last = you.species == SP_OCTOPODE ? EQ_RING_EIGHT
1600                                                            : EQ_AMULET;
1601
1602     for (int eq = first; eq <= last; eq++)
1603     {
1604         if (player_wearing_slot(eq))
1605         {
1606             if (has_jewellery)
1607             {
1608                 // At least one other piece, which means we'll have to ask
1609                 hand_used = EQ_NONE;
1610             }
1611             else
1612                 hand_used = (equipment_type) eq;
1613
1614             has_jewellery = true;
1615         }
1616         else if (you.melded[eq])
1617             has_melded = true;
1618     }
1619
1620     if (!has_jewellery)
1621     {
1622         if (has_melded)
1623             mpr("You aren't wearing any unmelded rings or amulets.");
1624         else
1625             mpr("You aren't wearing any rings or amulets.");
1626
1627         return false;
1628     }
1629
1630     if (you.berserk())
1631     {
1632         canned_msg(MSG_TOO_BERSERK);
1633         return false;
1634     }
1635
1636     const item_def* gloves = you.slot_item(EQ_GLOVES);
1637     const bool gloves_cursed = gloves && gloves->cursed();
1638     if (gloves_cursed && !player_wearing_slot(EQ_AMULET))
1639     {
1640         mpr("You can't take your gloves off to remove any rings!");
1641         return false;
1642     }
1643
1644     if (hand_used == EQ_NONE)
1645     {
1646         const int equipn =
1647             (slot == -1)? prompt_invent_item("Remove which piece of jewellery?",
1648                                              MT_INVLIST,
1649                                              OBJ_JEWELLERY, true, true, true,
1650                                              0, -1, NULL, OPER_REMOVE)
1651                         : slot;
1652
1653         if (prompt_failed(equipn))
1654             return false;
1655
1656         hand_used = item_equip_slot(you.inv[equipn]);
1657         if (hand_used == EQ_NONE)
1658         {
1659             mpr("You aren't wearing that.");
1660             return false;
1661         }
1662         else if (you.inv[equipn].base_type != OBJ_JEWELLERY)
1663         {
1664             mpr("That isn't a piece of jewellery.");
1665             return false;
1666         }
1667     }
1668
1669     if (you.equip[hand_used] == -1)
1670     {
1671         mpr("I don't think you really meant that.");
1672         return false;
1673     }
1674     else if (you.melded[hand_used])
1675     {
1676         mpr("You can't take that off while it's melded.");
1677         return false;
1678     }
1679     else if (gloves_cursed
1680              && (hand_used == EQ_LEFT_RING || hand_used == EQ_RIGHT_RING))
1681     {
1682         mpr("You can't take your gloves off to remove any rings!");
1683         return false;
1684     }
1685
1686     if (!check_warning_inscriptions(you.inv[you.equip[hand_used]],
1687                                     OPER_REMOVE))
1688     {
1689         canned_msg(MSG_OK);
1690         return false;
1691     }
1692
1693     if (you.inv[you.equip[hand_used]].cursed())
1694     {
1695         if (announce)
1696         {
1697             mprf("%s is stuck to you!",
1698                  you.inv[you.equip[hand_used]].name(DESC_YOUR).c_str());
1699         }
1700         else
1701             mpr("It's stuck to you!");
1702
1703         set_ident_flags(you.inv[you.equip[hand_used]], ISFLAG_KNOW_CURSE);
1704         return false;
1705     }
1706
1707     ring_wear_2 = you.equip[hand_used];
1708
1709     // Remove the ring.
1710     if (!_safe_to_remove_or_wear(you.inv[ring_wear_2], true))
1711         return false;
1712
1713     mprf("You remove %s.", you.inv[ring_wear_2].name(DESC_YOUR).c_str());
1714 #ifdef USE_TILE_LOCAL
1715     const unsigned int old_talents = your_talents(false).size();
1716 #endif
1717     unequip_item(hand_used);
1718 #ifdef USE_TILE_LOCAL
1719     if (your_talents(false).size() != old_talents)
1720     {
1721         tiles.layout_statcol();
1722         redraw_screen();
1723     }
1724 #endif
1725
1726     you.time_taken /= 2;
1727     you.turn_is_over = true;
1728
1729     return true;
1730 }
1731
1732 static int _wand_range(zap_type ztype)
1733 {
1734     // FIXME: Eventually we should have sensible values here.
1735     return LOS_RADIUS;
1736 }
1737
1738 static int _max_wand_range()
1739 {
1740     return LOS_RADIUS;
1741 }
1742
1743 static bool _dont_use_invis()
1744 {
1745     if (!you.backlit())
1746         return false;
1747
1748     if (you.haloed() || you.glows_naturally())
1749     {
1750         mpr("You can't turn invisible.");
1751         return true;
1752     }
1753     else if (get_contamination_level() > 1
1754              && !yesno("Invisibility will do you no good right now; "
1755                        "use anyway?", false, 'n'))
1756     {
1757         canned_msg(MSG_OK);
1758         return true;
1759     }
1760
1761     return false;
1762 }
1763
1764 static targetter *_wand_targetter(const item_def *wand)
1765 {
1766     int range = _wand_range(wand->zap());
1767     const int power = 15 + you.skill(SK_EVOCATIONS, 5) / 2;
1768
1769     switch (wand->sub_type)
1770     {
1771     case WAND_FIREBALL:
1772         return new targetter_beam(&you, range, ZAP_FIREBALL, power, 1, 1);
1773     case WAND_LIGHTNING:
1774         return new targetter_beam(&you, range, ZAP_LIGHTNING_BOLT, power, 0, 0);
1775     case WAND_FLAME:
1776         return new targetter_beam(&you, range, ZAP_THROW_FLAME, power, 0, 0);
1777     case WAND_FIRE:
1778         return new targetter_beam(&you, range, ZAP_BOLT_OF_FIRE, power, 0, 0);
1779     case WAND_FROST:
1780         return new targetter_beam(&you, range, ZAP_THROW_FROST, power, 0, 0);
1781     case WAND_COLD:
1782         return new targetter_beam(&you, range, ZAP_BOLT_OF_COLD, power, 0, 0);
1783     default:
1784         return 0;
1785     }
1786 }
1787
1788 void zap_wand(int slot)
1789 {
1790     if (you.species == SP_FELID || !form_can_use_wand())
1791     {
1792         mpr("You have no means to grasp a wand firmly enough.");
1793         return;
1794     }
1795
1796     bolt beam;
1797     dist zap_wand;
1798     int item_slot;
1799
1800     // Unless the character knows the type of the wand, the targetting
1801     // system will default to enemies. -- [ds]
1802     targ_mode_type targ_mode = TARG_HOSTILE;
1803
1804     beam.obvious_effect = false;
1805     beam.beam_source = MHITYOU;
1806
1807     if (inv_count() < 1)
1808     {
1809         canned_msg(MSG_NOTHING_CARRIED);
1810         return;
1811     }
1812
1813     if (you.berserk())
1814     {
1815         canned_msg(MSG_TOO_BERSERK);
1816         return;
1817     }
1818
1819     if (slot != -1)
1820         item_slot = slot;
1821     else
1822     {
1823         item_slot = prompt_invent_item("Zap which item?",
1824                                        MT_INVLIST,
1825                                        OBJ_WANDS,
1826                                        true, true, true, 0, -1, NULL,
1827                                        OPER_ZAP);
1828     }
1829
1830     if (prompt_failed(item_slot))
1831         return;
1832
1833     item_def& wand = you.inv[item_slot];
1834     if (wand.base_type != OBJ_WANDS)
1835     {
1836         canned_msg(MSG_NOTHING_HAPPENS);
1837         return;
1838     }
1839
1840     // If you happen to be wielding the wand, its display might change.
1841     if (you.equip[EQ_WEAPON] == item_slot)
1842         you.wield_change = true;
1843
1844     const zap_type type_zapped = wand.zap();
1845
1846     bool has_charges = true;
1847     if (wand.plus < 1)
1848     {
1849         if (wand.plus2 == ZAPCOUNT_EMPTY)
1850         {
1851             mpr("This wand has no charges.");
1852             return;
1853         }
1854         has_charges = false;
1855     }
1856
1857     const bool alreadyknown = item_type_known(wand);
1858     const bool alreadytried = item_type_tried(wand);
1859           bool invis_enemy  = false;
1860     const bool dangerous    = player_in_a_dangerous_place(&invis_enemy);
1861     targetter *hitfunc      = 0;
1862
1863     if (!alreadyknown)
1864         beam.effect_known = false;
1865     else
1866     {
1867         switch (wand.sub_type)
1868         {
1869         case WAND_DIGGING:
1870         case WAND_TELEPORTATION:
1871             targ_mode = TARG_ANY;
1872             break;
1873
1874         case WAND_HEAL_WOUNDS:
1875             if (you.religion == GOD_ELYVILON)
1876             {
1877                 targ_mode = TARG_ANY;
1878                 break;
1879             }
1880             // else intentional fall-through
1881         case WAND_HASTING:
1882         case WAND_INVISIBILITY:
1883             targ_mode = TARG_FRIEND;
1884             break;
1885
1886         default:
1887             targ_mode = TARG_HOSTILE;
1888             break;
1889         }
1890
1891         hitfunc = _wand_targetter(&wand);
1892     }
1893
1894     const int tracer_range =
1895         (alreadyknown && wand.sub_type != WAND_RANDOM_EFFECTS) ?
1896         _wand_range(type_zapped) : _max_wand_range();
1897     const string zap_title =
1898         "Zapping: " + get_menu_colour_prefix_tags(wand, DESC_INVENTORY);
1899     direction_chooser_args args;
1900     args.mode = targ_mode;
1901     args.range = tracer_range;
1902     args.top_prompt = zap_title;
1903     args.hitfunc = hitfunc;
1904     direction(zap_wand, args);
1905
1906     if (hitfunc)
1907         delete hitfunc;
1908
1909     if (!zap_wand.isValid)
1910     {
1911         if (zap_wand.isCancel)
1912             canned_msg(MSG_OK);
1913         return;
1914     }
1915
1916     if (alreadyknown && zap_wand.target == you.pos())
1917     {
1918         if (wand.sub_type == WAND_TELEPORTATION
1919             && you.no_tele(false, false))
1920         {
1921             mpr("You cannot teleport right now.");
1922             return;
1923         }
1924         else if (wand.sub_type == WAND_INVISIBILITY
1925                  && _dont_use_invis())
1926         {
1927             return;
1928         }
1929     }
1930
1931     if (!has_charges)
1932     {
1933         canned_msg(MSG_NOTHING_HAPPENS);
1934         // It's an empty wand; inscribe it that way.
1935         wand.plus2 = ZAPCOUNT_EMPTY;
1936         you.turn_is_over = true;
1937         return;
1938     }
1939
1940     if (you.confused())
1941         zap_wand.confusion_fuzz();
1942
1943     if (wand.sub_type == WAND_RANDOM_EFFECTS)
1944         beam.effect_known = false;
1945
1946     beam.source   = you.pos();
1947     beam.attitude = ATT_FRIENDLY;
1948     beam.set_target(zap_wand);
1949
1950     const bool aimed_at_self = (beam.target == you.pos());
1951     const int power = 15 + you.skill(SK_EVOCATIONS, 5) / 2;
1952
1953     // Check whether we may hit friends, use "safe" values for random effects
1954     // and unknown wands (highest possible range, and unresistable beam
1955     // flavour). Don't use the tracer if firing at self.
1956     if (!aimed_at_self)
1957     {
1958         beam.range = tracer_range;
1959         if (!player_tracer(beam.effect_known ? type_zapped
1960                                              : ZAP_DEBUGGING_RAY,
1961                            power, beam, beam.effect_known ? 0 : 17))
1962         {
1963             return;
1964         }
1965     }
1966
1967     // Zapping the wand isn't risky if you aim it away from all monsters
1968     // and yourself, unless there's a nearby invisible enemy and you're
1969     // trying to hit it at random.
1970     const bool risky = dangerous && (beam.friend_info.count
1971                                      || beam.foe_info.count
1972                                      || invis_enemy
1973                                      || aimed_at_self);
1974
1975     if (risky && alreadyknown && wand.sub_type == WAND_RANDOM_EFFECTS)
1976     {
1977         // Xom loves it when you use a Wand of Random Effects and
1978         // there is a dangerous monster nearby...
1979         xom_is_stimulated(200);
1980     }
1981
1982     // Reset range.
1983     beam.range = _wand_range(type_zapped);
1984
1985 #ifdef WIZARD
1986     if (you.wizard)
1987     {
1988         string str = wand.inscription;
1989         int wiz_range = strip_number_tag(str, "range:");
1990         if (wiz_range != TAG_UNFOUND)
1991             beam.range = wiz_range;
1992     }
1993 #endif
1994
1995     // zapping() updates beam.
1996     zapping(type_zapped, power, beam);
1997
1998     // Take off a charge.
1999     wand.plus--;
2000
2001     // Zap counts count from the last recharge.
2002     if (wand.plus2 == ZAPCOUNT_RECHARGED)
2003         wand.plus2 = 0;
2004     // Increment zap count.
2005     if (wand.plus2 >= 0)
2006         wand.plus2++;
2007
2008     // Identify if necessary.
2009     if (!alreadyknown && (beam.obvious_effect || type_zapped == ZAP_FIREBALL))
2010     {
2011         set_ident_type(wand, ID_KNOWN_TYPE);
2012         if (wand.sub_type == WAND_RANDOM_EFFECTS)
2013             mpr("You feel that this wand is rather unreliable.");
2014
2015         mpr_nocap(wand.name(DESC_INVENTORY_EQUIP).c_str());
2016     }
2017     else
2018         set_ident_type(wand, ID_TRIED_TYPE);
2019
2020     if (item_type_known(wand)
2021         && (item_ident(wand, ISFLAG_KNOW_PLUSES)
2022             || you.skill(SK_EVOCATIONS, 10) > 50 + random2(141)))
2023     {
2024         if (!item_ident(wand, ISFLAG_KNOW_PLUSES))
2025         {
2026             mpr("Your skill with magical items lets you calculate "
2027                 "the power of this device...");
2028         }
2029
2030         mprf("This wand has %d charge%s left.",
2031              wand.plus, wand.plus == 1 ? "" : "s");
2032
2033         set_ident_flags(wand, ISFLAG_KNOW_PLUSES);
2034     }
2035     // Mark as empty if necessary.
2036     if (wand.plus == 0 && wand.flags & ISFLAG_KNOW_PLUSES)
2037         wand.plus2 = ZAPCOUNT_EMPTY;
2038
2039     practise(EX_DID_ZAP_WAND);
2040     count_action(CACT_EVOKE, EVOC_WAND);
2041     alert_nearby_monsters();
2042
2043     if (!alreadyknown && !alreadytried && risky)
2044     {
2045         // Xom loves it when you use an unknown wand and there is a
2046         // dangerous monster nearby...
2047         xom_is_stimulated(200);
2048     }
2049
2050     you.turn_is_over = true;
2051 }
2052
2053 void prompt_inscribe_item()
2054 {
2055     if (inv_count() < 1)
2056     {
2057         mpr("You don't have anything to inscribe.");
2058         return;
2059     }
2060
2061     int item_slot = prompt_invent_item("Inscribe which item?",
2062                                        MT_INVLIST, OSEL_ANY);
2063
2064     if (prompt_failed(item_slot))
2065         return;
2066
2067     inscribe_item(you.inv[item_slot], true);
2068 }
2069
2070 static void _vampire_corpse_help()
2071 {
2072     if (you.species != SP_VAMPIRE)
2073         return;
2074
2075     if (check_blood_corpses_on_ground() || count_corpses_in_pack(true) > 0)
2076         mpr("If it's blood you're after, try <w>e</w>.");
2077 }
2078
2079 void drink(int slot)
2080 {
2081     if (you_foodless(true))
2082     {
2083         if (you.form == TRAN_TREE)
2084             mpr("It'd take too long for a potion to reach your roots.");
2085         else
2086             mpr("You can't drink.");
2087         return;
2088     }
2089
2090     if (slot == -1)
2091     {
2092         const dungeon_feature_type feat = grd(you.pos());
2093         if (feat >= DNGN_FOUNTAIN_BLUE && feat <= DNGN_FOUNTAIN_BLOOD)
2094             if (_drink_fountain())
2095                 return;
2096     }
2097
2098     if (inv_count() == 0)
2099     {
2100         canned_msg(MSG_NOTHING_CARRIED);
2101         _vampire_corpse_help();
2102         return;
2103     }
2104
2105     if (you.berserk())
2106     {
2107         canned_msg(MSG_TOO_BERSERK);
2108         return;
2109     }
2110
2111     if (you.form == TRAN_BAT)
2112     {
2113         canned_msg(MSG_PRESENT_FORM);
2114         _vampire_corpse_help();
2115         return;
2116     }
2117
2118     if (you.duration[DUR_RETCHING])
2119     {
2120         mpr("You can't gag anything down in your present state!");
2121         return;
2122     }
2123
2124     if (slot == -1)
2125     {
2126         slot = prompt_invent_item("Drink which item?",
2127                                   MT_INVLIST, OBJ_POTIONS,
2128                                   true, true, true, 0, -1, NULL,
2129                                   OPER_QUAFF);
2130         if (prompt_failed(slot))
2131         {
2132             _vampire_corpse_help();
2133             return;
2134         }
2135     }
2136
2137     item_def& potion = you.inv[slot];
2138
2139     if (potion.base_type != OBJ_POTIONS)
2140     {
2141         if (you.species == SP_VAMPIRE && potion.base_type == OBJ_CORPSES)
2142             eat_food(slot);
2143         else
2144             mpr("You can't drink that!");
2145         return;
2146     }
2147
2148     const bool alreadyknown = item_type_known(potion);
2149
2150     if (you.duration[DUR_FREEZING]
2151         && coinflip()
2152         && !(you.conservation() && !one_chance_in(10))
2153         && !(you.mutation[MUT_CONSERVE_POTIONS] && !one_chance_in(10)))
2154     {
2155         const string item_name = quant_name(you.inv[slot], 1, DESC_THE);
2156         mprf("%s freezes and shatters!",
2157             item_name.c_str());
2158         dec_inv_item_quantity(slot, 1);
2159         count_action(CACT_USE, OBJ_POTIONS);
2160         you.turn_is_over = true;
2161         return;
2162     }
2163
2164     if (alreadyknown && you.hunger_state == HS_ENGORGED
2165         && (is_blood_potion(potion) || potion.sub_type == POT_PORRIDGE))
2166     {
2167         mpr("You are much too full right now.");
2168         return;
2169     }
2170
2171     if (alreadyknown && potion.sub_type == POT_INVISIBILITY
2172         && _dont_use_invis())
2173     {
2174         return;
2175     }
2176
2177     if (alreadyknown && potion.sub_type == POT_BERSERK_RAGE
2178         && (!berserk_check_wielded_weapon()
2179             || !you.can_go_berserk(true, true)))
2180     {
2181         return;
2182     }
2183
2184     // The "> 1" part is to reduce the amount of times that Xom is
2185     // stimulated when you are a low-level 1 trying your first unknown
2186     // potions on monsters.
2187     const bool dangerous = (player_in_a_dangerous_place()
2188                             && you.experience_level > 1);
2189     potion_type pot_type = (potion_type)potion.sub_type;
2190
2191     // Identify item and type.
2192     if (potion_effect(static_cast<potion_type>(potion.sub_type),
2193                       40, true, alreadyknown))
2194     {
2195         set_ident_flags(potion, ISFLAG_IDENT_MASK);
2196         set_ident_type(potion, ID_KNOWN_TYPE);
2197         mpr("It was a " + potion.name(DESC_QUALNAME) + ".");
2198     }
2199     else if (!alreadyknown)
2200     {
2201         // Because all potions are identified upon quaffing we never come here.
2202         set_ident_type(potion, ID_TRIED_TYPE);
2203     }
2204
2205     if (!alreadyknown && dangerous)
2206     {
2207         // Xom loves it when you drink an unknown potion and there is
2208         // a dangerous monster nearby...
2209         xom_is_stimulated(200);
2210     }
2211
2212     if (is_blood_potion(potion))
2213     {
2214         // Always drink oldest potion.
2215         remove_oldest_blood_potion(potion);
2216     }
2217
2218     dec_inv_item_quantity(slot, 1);
2219     count_action(CACT_USE, OBJ_POTIONS);
2220     you.turn_is_over = true;
2221
2222     if (you.species != SP_VAMPIRE)
2223         lessen_hunger(40, true);
2224
2225     // This got deferred from the it_use2 switch to prevent SIGHUP abuse.
2226     if (pot_type == POT_EXPERIENCE)
2227         level_change();
2228 }
2229
2230 static bool _drink_fountain()
2231 {
2232     const dungeon_feature_type feat = grd(you.pos());
2233
2234     if (feat < DNGN_FOUNTAIN_BLUE || feat > DNGN_FOUNTAIN_BLOOD)
2235         return false;
2236
2237     if (you.berserk())
2238     {
2239         canned_msg(MSG_TOO_BERSERK);
2240         return true;
2241     }
2242
2243     potion_type fountain_effect = NUM_POTIONS;
2244     if (feat == DNGN_FOUNTAIN_BLUE)
2245     {
2246         if (!yesno("Drink from the fountain?", true, 'n'))
2247             return false;
2248
2249         mpr("You drink the pure, clear water.");
2250     }
2251     else if (feat == DNGN_FOUNTAIN_BLOOD)
2252     {
2253         if (!yesno("Drink from the fountain of blood?", true, 'n'))
2254             return false;
2255
2256         mpr("You drink the blood.");
2257         fountain_effect = POT_BLOOD;
2258     }
2259     else
2260     {
2261         if (!yesno("Drink from the sparkling fountain?", true, 'n'))
2262             return false;
2263
2264         mpr("You drink the sparkling water.");
2265
2266         fountain_effect =
2267             random_choose_weighted(467, NUM_POTIONS,
2268                                    48,  POT_DECAY,
2269                                    40,  POT_MUTATION,
2270                                    40,  POT_CURING,
2271                                    40,  POT_HEAL_WOUNDS,
2272                                    40,  POT_SPEED,
2273                                    40,  POT_MIGHT,
2274                                    40,  POT_AGILITY,
2275                                    40,  POT_BRILLIANCE,
2276                                    32,  POT_DEGENERATION,
2277                                    27,  POT_FLIGHT,
2278                                    27,  POT_POISON,
2279                                    27,  POT_SLOWING,
2280                                    27,  POT_PARALYSIS,
2281                                    27,  POT_CONFUSION,
2282                                    27,  POT_INVISIBILITY,
2283                                    20,  POT_MAGIC,
2284                                    20,  POT_RESTORE_ABILITIES,
2285                                    20,  POT_RESISTANCE,
2286                                    20,  POT_STRONG_POISON,
2287                                    20,  POT_BERSERK_RAGE,
2288                                    12,  POT_BENEFICIAL_MUTATION,
2289                                    0);
2290     }
2291
2292     if (fountain_effect != NUM_POTIONS && fountain_effect != POT_BLOOD)
2293         xom_is_stimulated(50);
2294
2295     // Good gods do not punish for bad random effects. However, they do
2296     // punish drinking from a fountain of blood.
2297     potion_effect(fountain_effect, 100, true, feat != DNGN_FOUNTAIN_SPARKLING, true);
2298
2299     bool gone_dry = false;
2300     if (feat == DNGN_FOUNTAIN_BLUE)
2301     {
2302         if (one_chance_in(20))
2303             gone_dry = true;
2304     }
2305     else if (feat == DNGN_FOUNTAIN_BLOOD)
2306     {
2307         // High chance of drying up, to prevent abuse.
2308         if (one_chance_in(3))
2309             gone_dry = true;
2310     }
2311     else   // sparkling fountain
2312     {
2313         if (one_chance_in(10))
2314             gone_dry = true;
2315         else if (random2(50) > 40)
2316         {
2317             // Turn fountain into a normal fountain without any message
2318             // but the glyph colour gives it away (lightblue vs. blue).
2319             grd(you.pos()) = DNGN_FOUNTAIN_BLUE;
2320             set_terrain_changed(you.pos());
2321         }
2322     }
2323
2324     if (gone_dry)
2325     {
2326         mpr("The fountain dries up!");
2327
2328         grd(you.pos()) = static_cast<dungeon_feature_type>(feat
2329                          + DNGN_DRY_FOUNTAIN_BLUE - DNGN_FOUNTAIN_BLUE);
2330
2331         set_terrain_changed(you.pos());
2332
2333         crawl_state.cancel_cmd_repeat();
2334     }
2335
2336     you.turn_is_over = true;
2337     return true;
2338 }
2339
2340 static void _explosion(coord_def where, actor *agent, beam_type flavour,
2341                        string name, string cause)
2342 {
2343     bolt beam;
2344     beam.is_explosion = true;
2345     beam.aux_source = cause;
2346     beam.source = where;
2347     beam.target = where;
2348     beam.set_agent(agent);
2349     beam.range = 0;
2350     beam.damage = dice_def(5, 8);
2351     beam.ex_size = 5;
2352     beam.flavour = flavour;
2353     beam.hit = AUTOMATIC_HIT;
2354     beam.name = name;
2355     beam.loudness = 10;
2356     beam.explode(true, false);
2357 }
2358
2359 // Returns true if a message has already been printed (which will identify
2360 // the scroll).
2361 static bool _vorpalise_weapon(bool already_known)
2362 {
2363     if (!you.weapon())
2364         return false;
2365
2366     // Check if you're wielding a brandable weapon.
2367     item_def& wpn = *you.weapon();
2368     if (wpn.base_type != OBJ_WEAPONS || wpn.sub_type == WPN_BLOWGUN
2369         || is_artefact(wpn))
2370     {
2371         return false;
2372     }
2373
2374     you.wield_change = true;
2375
2376     // If there's no brand, make it vorpal.
2377     if (get_weapon_brand(wpn) == SPWPN_NORMAL)
2378     {
2379         alert_nearby_monsters();
2380         mprf("%s emits a brilliant flash of light!",
2381              wpn.name(DESC_YOUR).c_str());
2382         set_item_ego_type(wpn, OBJ_WEAPONS, SPWPN_VORPAL);
2383         return true;
2384     }
2385
2386     // If there's a permanent brand, fail.
2387     if (you.duration[DUR_WEAPON_BRAND] == 0)
2388         return false;
2389
2390     // There's a temporary brand, attempt to make it permanent.
2391     const string itname = wpn.name(DESC_YOUR);
2392     bool success = true;
2393     bool msg = true;
2394
2395     switch (get_weapon_brand(wpn))
2396     {
2397     case SPWPN_VORPAL:
2398         if (get_vorpal_type(wpn) != DVORP_CRUSHING)
2399             mprf("%s's sharpness seems more permanent.", itname.c_str());
2400         else
2401             mprf("%s's heaviness feels very stable.", itname.c_str());
2402         break;
2403
2404     case SPWPN_FLAME:
2405     case SPWPN_FLAMING:
2406         mprf("%s is engulfed in an explosion of flames!", itname.c_str());
2407         immolation(10, IMMOLATION_AFFIX, you.pos(), already_known, &you);
2408         break;
2409
2410     case SPWPN_FROST:
2411     case SPWPN_FREEZING:
2412         if (cast_los_attack_spell(SPELL_OZOCUBUS_REFRIGERATION, 60,
2413                                   (already_known) ? &you : NULL, true)
2414             != SPRET_SUCCESS)
2415         {
2416             canned_msg(MSG_OK);
2417             success = false;
2418         }
2419         else
2420             mprf("%s is covered with a thick layer of frost!", itname.c_str());
2421         break;
2422
2423     case SPWPN_DRAINING:
2424         mprf("%s thirsts for the lives of mortals!", itname.c_str());
2425         drain_exp(true, NON_MONSTER, "draining affixation");
2426         break;
2427
2428     case SPWPN_VENOM:
2429         if (cast_los_attack_spell(SPELL_OLGREBS_TOXIC_RADIANCE, 60,
2430                                   (already_known) ? &you : NULL, true)
2431             != SPRET_SUCCESS)
2432         {
2433             canned_msg(MSG_OK);
2434             success = false;
2435         }
2436         else
2437             mprf("%s seems more permanently poisoned.", itname.c_str());
2438         break;
2439
2440     case SPWPN_ELECTROCUTION:
2441         mprf("%s releases a massive orb of lightning.", itname.c_str());
2442         _explosion(you.pos(), &you, BEAM_ELECTRICITY, "electricity",
2443                    "electrocution affixation");
2444         break;
2445
2446     case SPWPN_CHAOS:
2447         mprf("%s erupts in a glittering mayhem of all colours.", itname.c_str());
2448         // need to affix it immediately, otherwise transformation will break it
2449         you.duration[DUR_WEAPON_BRAND] = 0;
2450         xom_is_stimulated(200);
2451         // but the eruption _is_ guaranteed.  What it will do is not.
2452         _explosion(you.pos(), &you, BEAM_CHAOS, "chaos eruption", "chaos affixation");
2453         switch (random2(coinflip() ? 2 : 4))
2454         {
2455         case 3:
2456             if (transform(50, coinflip() ? TRAN_PIG :
2457                               coinflip() ? TRAN_DRAGON :
2458                                            TRAN_BAT))
2459             {
2460                 // after getting possibly banished, we don't want you to just
2461                 // say "end transformation" immediately
2462                 you.transform_uncancellable = true;
2463                 break;
2464             }
2465         case 2:
2466             if (you.can_safely_mutate())
2467             {
2468                 // not funny on the undead
2469                 mutate(RANDOM_MUTATION, "chaos affixation");
2470                 break;
2471             }
2472         case 1:
2473             xom_acts(coinflip(), HALF_MAX_PIETY, 0); // ignore tension
2474         default:
2475             break;
2476         }
2477         break;
2478
2479     case SPWPN_PAIN:
2480         // Can't fix pain brand (balance)...you just get tormented.
2481         mprf("%s shrieks out in agony!", itname.c_str());
2482
2483         torment_monsters(you.pos(), &you, TORMENT_GENERIC);
2484         success = false;
2485
2486         // This is only naughty if you know you're doing it.
2487         // XXX: assumes this can only happen from Vorpalise Weapon scroll.
2488         did_god_conduct(DID_NECROMANCY, 10,
2489                         get_ident_type(OBJ_SCROLLS, SCR_VORPALISE_WEAPON)
2490                         == ID_KNOWN_TYPE);
2491         break;
2492
2493     case SPWPN_DISTORTION:
2494         // [dshaligram] Attempting to fix a distortion brand gets you a free
2495         // distortion effect, and no permabranding. Sorry, them's the breaks.
2496         mprf("%s twongs alarmingly.", itname.c_str());
2497
2498         // from unwield_item
2499         MiscastEffect(&you, NON_MONSTER, SPTYP_TRANSLOCATION, 9, 90,
2500                       "distortion affixation");
2501         success = false;
2502         break;
2503
2504     case SPWPN_ANTIMAGIC:
2505         mprf("%s repels your magic.", itname.c_str());
2506         drain_mp(you.species == SP_DJINNI ? 100 : you.magic_points);
2507         success = false;
2508         break;
2509
2510     case SPWPN_HOLY_WRATH:
2511         mprf("%s emits a blast of cleansing flame.", itname.c_str());
2512         _explosion(you.pos(), &you, BEAM_HOLY, "cleansing flame",
2513                    "holy wrath affixation");
2514         success = false;
2515         break;
2516
2517     default:
2518         success = false;
2519         msg = false;
2520         break;
2521     }
2522
2523     if (success)
2524     {
2525         you.duration[DUR_WEAPON_BRAND] = 0;
2526         item_set_appearance(wpn);
2527     }
2528     return msg;
2529 }
2530
2531 bool enchant_weapon(item_def &wpn, int acc, int dam, const char *colour)
2532 {
2533     bool success = false;
2534
2535     // Get item name now before changing enchantment.
2536     string iname = wpn.name(DESC_YOUR);
2537     const char *s = wpn.quantity == 1 ? "s" : "";
2538
2539     // Blowguns only have one stat.
2540     if (wpn.base_type == OBJ_WEAPONS && wpn.sub_type == WPN_BLOWGUN)
2541     {
2542         acc = acc + dam;
2543         dam = 0;
2544     }
2545
2546     if (is_weapon(wpn))
2547     {
2548         if (!is_artefact(wpn) && wpn.base_type == OBJ_WEAPONS)
2549         {
2550             while (acc--)
2551             {
2552                 if (wpn.plus < 4 || !x_chance_in_y(wpn.plus, MAX_WPN_ENCHANT))
2553                     wpn.plus++, success = true;
2554             }
2555             while (dam--)
2556             {
2557                 if (wpn.plus2 < 4 || !x_chance_in_y(wpn.plus2, MAX_WPN_ENCHANT))
2558                     wpn.plus2++, success = true;
2559             }
2560             if (success && colour)
2561                 mprf("%s glow%s %s for a moment.", iname.c_str(), s, colour);
2562         }
2563         if (wpn.cursed())
2564         {
2565             if (!success && colour)
2566             {
2567                 if (const char *space = strchr(colour, ' '))
2568                     colour = space + 1;
2569                 mprf("%s glow%s silvery %s for a moment.", iname.c_str(), s, colour);
2570             }
2571             do_uncurse_item(wpn, true, true);
2572             success = true;
2573         }
2574     }
2575
2576     if (!success && colour)
2577     {
2578         if (!wpn.defined())
2579             iname = "Your " + you.hand_name(true);
2580         mprf("%s very briefly gain%s a %s sheen.", iname.c_str(), s, colour);
2581     }
2582
2583     if (success)
2584         you.wield_change = true;
2585
2586     return success;
2587 }
2588
2589 static void _handle_enchant_weapon(int acc, int dam, const char *colour)
2590 {
2591     item_def nothing, *weapon = you.weapon();
2592     if (!weapon)
2593         weapon = &nothing;
2594     enchant_weapon(*weapon, acc, dam, colour);
2595 }
2596
2597 bool enchant_armour(int &ac_change, bool quiet, item_def &arm)
2598 {
2599     ASSERT(arm.defined() && arm.base_type == OBJ_ARMOUR);
2600
2601     ac_change = 0;
2602
2603     // Cannot be enchanted nor uncursed.
2604     if (!is_enchantable_armour(arm, true))
2605     {
2606         if (!quiet)
2607             canned_msg(MSG_NOTHING_HAPPENS);
2608
2609         return false;
2610     }
2611
2612     const bool is_cursed = arm.cursed();
2613
2614     // Turn hides into mails where applicable.
2615     // NOTE: It is assumed that armour which changes in this way does
2616     // not change into a form of armour with a different evasion modifier.
2617     if (armour_is_hide(arm, false))
2618     {
2619         if (!quiet)
2620         {
2621             mprf("%s glows purple and changes!",
2622                  arm.name(DESC_YOUR).c_str());
2623         }
2624
2625         ac_change = property(arm, PARM_AC);
2626         hide2armour(arm);
2627         ac_change = property(arm, PARM_AC) - ac_change;
2628
2629         do_uncurse_item(arm, true, true);
2630
2631         // No additional enchantment.
2632         return true;
2633     }
2634
2635     // Even if not affected, it may be uncursed.
2636     if (!is_enchantable_armour(arm, false))
2637     {
2638         if (is_cursed)
2639         {
2640             if (!quiet)
2641             {
2642                 mprf("%s glows silver for a moment.",
2643                      arm.name(DESC_YOUR).c_str());
2644             }
2645
2646             do_uncurse_item(arm, true, true);
2647             return true;
2648         }
2649         else
2650         {
2651             if (!quiet)
2652                 canned_msg(MSG_NOTHING_HAPPENS);
2653
2654             return false;
2655         }
2656     }
2657
2658     // Output message before changing enchantment and curse status.
2659     if (!quiet)
2660     {
2661         mprf("%s glows green for a moment.",
2662              arm.name(DESC_YOUR).c_str());
2663     }
2664
2665     arm.plus++;
2666     ac_change++;
2667     do_uncurse_item(arm, true, true);
2668
2669     return true;
2670 }
2671
2672 static int _handle_enchant_armour(int item_slot, string *pre_msg)
2673 {
2674     do
2675     {
2676         if (item_slot == -1)
2677         {
2678             item_slot = prompt_invent_item("Enchant which item?", MT_INVLIST,
2679                                            OSEL_ENCH_ARM, true, true, false);
2680         }
2681         if (prompt_failed(item_slot))
2682             return -1;
2683
2684         item_def& arm(you.inv[item_slot]);
2685
2686         if (!is_enchantable_armour(arm, true, true))
2687         {
2688             mpr("Choose some type of armour to enchant, or Esc to abort.");
2689             if (Options.auto_list)
2690                 more();
2691
2692             item_slot = -1;
2693             continue;
2694         }
2695
2696         // Okay, we may actually (attempt to) enchant something.
2697         if (pre_msg)
2698             mpr(pre_msg->c_str());
2699
2700         int ac_change;
2701         bool result = enchant_armour(ac_change, false, arm);
2702
2703         if (ac_change)
2704             you.redraw_armour_class = true;
2705
2706         return result ? 1 : 0;
2707     }
2708     while (true);
2709
2710     return 0;
2711 }
2712
2713 static void _handle_read_book(int item_slot)
2714 {
2715     if (you.berserk())
2716     {
2717         canned_msg(MSG_TOO_BERSERK);
2718         return;
2719     }
2720
2721     if (you.stat_zero[STAT_INT])
2722     {
2723         mpr("Reading books requires mental cohesion, which you lack.");
2724         return;
2725     }
2726
2727     item_def& book(you.inv[item_slot]);
2728     ASSERT(book.sub_type != BOOK_MANUAL);
2729
2730     if (book.sub_type == BOOK_DESTRUCTION)
2731     {
2732         if (silenced(you.pos()))
2733             mpr("This book does not work if you cannot read it aloud!");
2734         else
2735             tome_of_power(item_slot);
2736         return;
2737     }
2738
2739     while (true)
2740     {
2741         // Spellbook
2742         const int ltr = read_book(book, RBOOK_READ_SPELL);
2743
2744         if (ltr < 'a' || ltr > 'h')     //jmf: was 'g', but 8=h
2745         {
2746             mesclr();
2747             return;
2748         }
2749
2750         const spell_type spell = which_spell_in_book(book,
2751                                                      letter_to_index(ltr));
2752         if (spell == SPELL_NO_SPELL)
2753         {
2754             mesclr();
2755             return;
2756         }
2757
2758         describe_spell(spell, &book);
2759
2760         // Player memorised spell which was being looked at.
2761         if (you.turn_is_over)
2762             return;
2763     }
2764 }
2765
2766 // For unidentified scrolls of recharging, identify and enchant armour
2767 // offer full choice of inventory and only identify the scroll if you chose
2768 // something that is affected by the scroll. Once they're identified, you'll
2769 // get the limited inventory listing.
2770 // Returns true if the scroll had an obvious effect and should be identified.
2771 static bool _scroll_modify_item(item_def scroll)
2772 {
2773     ASSERT(scroll.base_type == OBJ_SCROLLS);
2774
2775     int item_slot;
2776
2777 retry:
2778     do
2779     {
2780         // Get the slot of the item the scroll is to be used on.
2781         // Ban the scroll's own slot from the prompt to avoid the stupid situation
2782         // where you use identify on itself.
2783         item_slot = prompt_invent_item("Use on which item? (\\ to view known items)",
2784                                        MT_INVLIST, OSEL_SCROLL_TARGET, true, true, false, 0,
2785                                        scroll.link, NULL, OPER_ANY, true);
2786
2787         if (item_slot == PROMPT_NOTHING)
2788             return false;
2789
2790         if (item_slot == PROMPT_ABORT
2791             && yesno("Really abort (and waste the scroll)?"))
2792         {
2793             canned_msg(MSG_OK);
2794             return false;
2795         }
2796     }
2797     while (item_slot < 0);
2798
2799     item_def &item = you.inv[item_slot];
2800
2801     if (item_is_melded(you.inv[item_slot]))
2802     {
2803         mpr("This item is melded into your body!");
2804         if (Options.auto_list)
2805             more();
2806         goto retry;
2807     }
2808
2809     bool show_msg = true;
2810     const char* id_prop = nullptr;
2811
2812     switch (scroll.sub_type)
2813     {
2814     case SCR_IDENTIFY:
2815         if (!fully_identified(item) || is_deck(item) && !top_card_is_known(item))
2816         {
2817             identify(-1, item_slot);
2818             return true;
2819         }
2820         else
2821             id_prop = "SCR_ID";
2822         break;
2823
2824     case SCR_RECHARGING:
2825         if (item_is_rechargeable(item) && recharge_wand(item_slot, false))
2826             return true;
2827         id_prop = "SCR_RC";
2828         break;
2829
2830     case SCR_ENCHANT_ARMOUR:
2831         if (is_enchantable_armour(item, true))
2832         {
2833             // Might still fail because of already high enchantment.
2834             // (If so, already prints the "Nothing happens" message.)
2835             if (_handle_enchant_armour(item_slot) > 0)
2836                 return true;
2837             show_msg = false;
2838         }
2839
2840         id_prop = "SCR_EA";
2841         break;
2842
2843     default:
2844         mprf("Buggy scroll %d can't modify item!", scroll.sub_type);
2845         break;
2846     }
2847
2848     if (id_prop)
2849         you.type_id_props[id_prop] = item.name(DESC_PLAIN, false, false, false);
2850
2851     // Oops, wrong item...
2852     if (show_msg)
2853         canned_msg(MSG_NOTHING_HAPPENS);
2854     return false;
2855 }
2856
2857 static void _vulnerability_scroll()
2858 {
2859     // First cast antimagic on yourself.
2860     antimagic();
2861
2862     mon_enchant lowered_mr(ENCH_LOWERED_MR, 1, &you, 40);
2863
2864     // Go over all creatures in LOS.
2865     for (radius_iterator ri(you.pos(), LOS_RADIUS); ri; ++ri)
2866     {
2867         if (monster* mon = monster_at(*ri))
2868         {
2869             debuff_monster(mon);
2870
2871             // If relevant, monsters have their MR halved.
2872             if (!mons_immune_magic(mon))
2873                 mon->add_ench(lowered_mr);
2874
2875             // Annoying but not enough to turn friendlies against you.
2876             if (!mon->wont_attack())
2877                 behaviour_event(mon, ME_ANNOY, &you);
2878         }
2879     }
2880
2881     you.set_duration(DUR_LOWERED_MR, 40, 0,
2882                      "Magic dampens, then quickly surges around you.");
2883 }
2884
2885 bool _is_cancellable_scroll(scroll_type scroll)
2886 {
2887     return (scroll == SCR_IDENTIFY
2888             || scroll == SCR_BLINKING
2889             || scroll == SCR_RECHARGING
2890             || scroll == SCR_ENCHANT_ARMOUR
2891             || scroll == SCR_AMNESIA
2892             || scroll == SCR_REMOVE_CURSE
2893             || scroll == SCR_CURSE_ARMOUR
2894             || scroll == SCR_CURSE_JEWELLERY
2895             || scroll == SCR_VORPALISE_WEAPON);
2896 }
2897
2898 void read_scroll(int slot)
2899 {
2900     if (you.berserk())
2901     {
2902         canned_msg(MSG_TOO_BERSERK);
2903         return;
2904     }
2905
2906     if (you.confused())
2907     {
2908         canned_msg(MSG_TOO_CONFUSED);
2909         return;
2910     }
2911
2912     if (you.duration[DUR_WATER_HOLD] && !you.res_water_drowning())
2913     {
2914         mpr("You cannot read scrolls while unable to breathe!");
2915         return;
2916     }
2917
2918     if (inv_count() < 1)
2919     {
2920         canned_msg(MSG_NOTHING_CARRIED);
2921         return;
2922     }
2923
2924     int item_slot = (slot != -1) ? slot
2925                                  : prompt_invent_item("Read which item?",
2926                                                        MT_INVLIST,
2927                                                        OBJ_SCROLLS,
2928                                                        true, true, true, 0, -1,
2929                                                        NULL, OPER_READ);
2930
2931     if (prompt_failed(item_slot))
2932         return;
2933
2934     item_def& scroll = you.inv[item_slot];
2935
2936     if ((scroll.base_type != OBJ_BOOKS || scroll.sub_type == BOOK_MANUAL)
2937         && scroll.base_type != OBJ_SCROLLS)
2938     {
2939         mpr("You can't read that!");
2940         crawl_state.zero_turns_taken();
2941         return;
2942     }
2943
2944     // Here we try to read a book {dlb}:
2945     if (scroll.base_type == OBJ_BOOKS)
2946     {
2947         _handle_read_book(item_slot);
2948         return;
2949     }
2950
2951     if (you.form == TRAN_WISP)
2952     {
2953         crawl_state.zero_turns_taken();
2954         return mpr("You have no means to unroll scrolls.");
2955     }
2956
2957     if (silenced(you.pos()))
2958     {
2959         mpr("Magic scrolls do not work when you're silenced!");
2960         crawl_state.zero_turns_taken();
2961         return;
2962     }
2963
2964     // Prevent hot lava orcs reading scrolls
2965     if (you.species == SP_LAVA_ORC && temperature_effect(LORC_NO_SCROLLS))
2966     {
2967         crawl_state.zero_turns_taken();
2968         return mpr("You'd burn any scroll you tried to read!");
2969     }
2970
2971     if (you.duration[DUR_SMOLDERING]
2972             && coinflip()
2973             && !(you.conservation() && !one_chance_in(10))
2974             && !(you.mutation[MUT_CONSERVE_SCROLLS] && !one_chance_in(10)))
2975     {
2976         const string item_name = quant_name(you.inv[item_slot], 1, DESC_THE);
2977         mprf("%s burns to ash!",
2978             item_name.c_str());
2979         dec_inv_item_quantity(item_slot, 1);
2980         count_action(CACT_USE, OBJ_POTIONS);
2981         you.turn_is_over = true;
2982         return;
2983     }
2984
2985     const scroll_type which_scroll = static_cast<scroll_type>(scroll.sub_type);
2986     const bool alreadyknown = item_type_known(scroll);
2987
2988     if (alreadyknown)
2989     {
2990         switch (which_scroll)
2991         {
2992         case SCR_BLINKING:
2993         case SCR_TELEPORTATION:
2994             if (you.no_tele(false, false, which_scroll == SCR_BLINKING))
2995