Source:Do wear.c

Below is the full text to src/do_wear.c from NetHack 3.4.3. To link to a particular line, write [[do_wear.c#line123]], for example.

Top of file

1.    /*	SCCS Id: @(#)do_wear.c	3.4	2003/11/14	*/
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    

The NetHack General Public License applies to screenshots, source code and other content from NetHack.

5.    #include "hack.h"
6.    
7.    #ifndef OVLB
8.    
9.    STATIC_DCL long takeoff_mask, taking_off;
10.   
11.   #else /* OVLB */
12.   
13.   STATIC_OVL NEARDATA long takeoff_mask = 0L;
14.   static NEARDATA long taking_off = 0L;
15.   
16.   static NEARDATA int todelay;
17.   static boolean cancelled_don = FALSE;
18.   
19.   static NEARDATA const char see_yourself[] = "see yourself";
20.   static NEARDATA const char unknown_type[] = "Unknown type of %s (%d)";
21.   static NEARDATA const char c_armor[]  = "armor",
22.   			   c_suit[]   = "suit",
23.   #ifdef TOURIST
24.   			   c_shirt[]  = "shirt",
25.   #endif
26.   			   c_cloak[]  = "cloak",
27.   			   c_gloves[] = "gloves",
28.   			   c_boots[]  = "boots",
29.   			   c_helmet[] = "helmet",
30.   			   c_shield[] = "shield",
31.   			   c_weapon[] = "weapon",
32.   			   c_sword[]  = "sword",
33.   			   c_axe[]    = "axe",
34.   			   c_that_[]  = "that";
35.   
36.   static NEARDATA const long takeoff_order[] = { WORN_BLINDF, W_WEP,
37.   	WORN_SHIELD, WORN_GLOVES, LEFT_RING, RIGHT_RING, WORN_CLOAK,
38.   	WORN_HELMET, WORN_AMUL, WORN_ARMOR,
39.   #ifdef TOURIST
40.   	WORN_SHIRT,
41.   #endif
42.   	WORN_BOOTS, W_SWAPWEP, W_QUIVER, 0L };
43.   
44.   STATIC_DCL void FDECL(on_msg, (struct obj *));
45.   STATIC_PTR int NDECL(Armor_on);
46.   STATIC_PTR int NDECL(Boots_on);
47.   STATIC_DCL int NDECL(Cloak_on);
48.   STATIC_PTR int NDECL(Helmet_on);
49.   STATIC_PTR int NDECL(Gloves_on);
50.   STATIC_PTR int NDECL(Shield_on);
51.   #ifdef TOURIST
52.   STATIC_PTR int NDECL(Shirt_on);
53.   #endif
54.   STATIC_DCL void NDECL(Amulet_on);
55.   STATIC_DCL void FDECL(Ring_off_or_gone, (struct obj *, BOOLEAN_P));
56.   STATIC_PTR int FDECL(select_off, (struct obj *));
57.   STATIC_DCL struct obj *NDECL(do_takeoff);
58.   STATIC_PTR int NDECL(take_off);
59.   STATIC_DCL int FDECL(menu_remarm, (int));
60.   STATIC_DCL void FDECL(already_wearing, (const char*));
61.   STATIC_DCL void FDECL(already_wearing2, (const char*, const char*));
62.   

off_msg

63.   void
64.   off_msg(otmp)
65.   register struct obj *otmp;
66.   {
67.   	if(flags.verbose)
68.   	    You("were wearing %s.", doname(otmp));
69.   }
70.   

on_msg

71.   /* for items that involve no delay */
72.   STATIC_OVL void
73.   on_msg(otmp)
74.   register struct obj *otmp;
75.   {
76.   	if (flags.verbose) {
77.   	    char how[BUFSZ];
78.   
79.   	    how[0] = '\0';
80.   	    if (otmp->otyp == TOWEL)
81.   		Sprintf(how, " around your %s", body_part(HEAD));
82.   	    You("are now wearing %s%s.",
83.   		obj_is_pname(otmp) ? the(xname(otmp)) : an(xname(otmp)),
84.   		how);
85.   	}
86.   }
87.   

Type_on/Type_off

88.   /*
89.    * The Type_on() functions should be called *after* setworn().
90.    * The Type_off() functions call setworn() themselves.
91.    */
92.   

Boots_on

93.   STATIC_PTR
94.   int
95.   Boots_on()
96.   {
97.       long oldprop =
98.   	u.uprops[objects[uarmf->otyp].oc_oprop].extrinsic & ~WORN_BOOTS;
99.   
100.      switch(uarmf->otyp) {
101.  	case LOW_BOOTS:
102.  	case IRON_SHOES:
103.  	case HIGH_BOOTS:
104.  	case JUMPING_BOOTS:
105.  	case KICKING_BOOTS:
106.  		break;
107.  	case WATER_WALKING_BOOTS:
108.  		if (u.uinwater) spoteffects(TRUE);
109.  		break;
110.  	case SPEED_BOOTS:
111.  		/* Speed boots are still better than intrinsic speed, */
112.  		/* though not better than potion speed */
113.  		if (!oldprop && !(HFast & TIMEOUT)) {
114.  			makeknown(uarmf->otyp);
115.  			You_feel("yourself speed up%s.",
116.  				(oldprop || HFast) ? " a bit more" : "");
117.  		}
118.  		break;
119.  	case ELVEN_BOOTS:
120.  		if (!oldprop && !HStealth && !BStealth) {
121.  			makeknown(uarmf->otyp);
122.  			You("walk very quietly.");
123.  		}
124.  		break;
125.  	case FUMBLE_BOOTS:
126.  		if (!oldprop && !(HFumbling & ~TIMEOUT))
127.  			incr_itimeout(&HFumbling, rnd(20));
128.  		break;
129.  	case LEVITATION_BOOTS:
130.  		if (!oldprop && !HLevitation) {
131.  			makeknown(uarmf->otyp);
132.  			float_up();
133.  			spoteffects(FALSE);
134.  		}
135.  		break;
136.  	default: impossible(unknown_type, c_boots, uarmf->otyp);
137.      }
138.      return 0;
139.  }
140.  

Boots_off

141.  int
142.  Boots_off()
143.  {
144.      int otyp = uarmf->otyp;
145.      long oldprop = u.uprops[objects[otyp].oc_oprop].extrinsic & ~WORN_BOOTS;
146.  
147.      takeoff_mask &= ~W_ARMF;
148.  	/* For levitation, float_down() returns if Levitation, so we
149.  	 * must do a setworn() _before_ the levitation case.
150.  	 */
151.      setworn((struct obj *)0, W_ARMF);
152.      switch (otyp) {
153.  	case SPEED_BOOTS:
154.  		if (!Very_fast && !cancelled_don) {
155.  			makeknown(otyp);
156.  			You_feel("yourself slow down%s.",
157.  				Fast ? " a bit" : "");
158.  		}
159.  		break;
160.  	case WATER_WALKING_BOOTS:
161.  		if (is_pool(u.ux,u.uy) && !Levitation && !Flying &&
162.  		    !is_clinger(youmonst.data) && !cancelled_don) {
163.  			makeknown(otyp);
164.  			/* make boots known in case you survive the drowning */
165.  			spoteffects(TRUE);
166.  		}
167.  		break;
168.  	case ELVEN_BOOTS:
169.  		if (!oldprop && !HStealth && !BStealth && !cancelled_don) {
170.  			makeknown(otyp);
171.  			You("sure are noisy.");
172.  		}
173.  		break;
174.  	case FUMBLE_BOOTS:
175.  		if (!oldprop && !(HFumbling & ~TIMEOUT))
176.  			HFumbling = EFumbling = 0;
177.  		break;
178.  	case LEVITATION_BOOTS:
179.  		if (!oldprop && !HLevitation && !cancelled_don) {
180.  			(void) float_down(0L, 0L);
181.  			makeknown(otyp);
182.  		}
183.  		break;
184.  	case LOW_BOOTS:
185.  	case IRON_SHOES:
186.  	case HIGH_BOOTS:
187.  	case JUMPING_BOOTS:
188.  	case KICKING_BOOTS:
189.  		break;
190.  	default: impossible(unknown_type, c_boots, otyp);
191.      }
192.      cancelled_don = FALSE;
193.      return 0;
194.  }
195.  

Cloak_on

196.  STATIC_OVL int
197.  Cloak_on()
198.  {
199.      long oldprop =
200.  	u.uprops[objects[uarmc->otyp].oc_oprop].extrinsic & ~WORN_CLOAK;
201.  
202.      switch(uarmc->otyp) {
203.  	case ELVEN_CLOAK:
204.  	case CLOAK_OF_PROTECTION:
205.  	case CLOAK_OF_DISPLACEMENT:
206.  		makeknown(uarmc->otyp);
207.  		break;
208.  	case ORCISH_CLOAK:
209.  	case DWARVISH_CLOAK:
210.  	case CLOAK_OF_MAGIC_RESISTANCE:
211.  	case ROBE:
212.  	case LEATHER_CLOAK:
213.  		break;
214.  	case MUMMY_WRAPPING:
215.  		/* Note: it's already being worn, so we have to cheat here. */
216.  		if ((HInvis || EInvis || pm_invisible(youmonst.data)) && !Blind) {
217.  		    newsym(u.ux,u.uy);
218.  		    You("can %s!",
219.  			See_invisible ? "no longer see through yourself"
220.  			: see_yourself);
221.  		}
222.  		break;
223.  	case CLOAK_OF_INVISIBILITY:
224.  		/* since cloak of invisibility was worn, we know mummy wrapping
225.  		   wasn't, so no need to check `oldprop' against blocked */
226.  		if (!oldprop && !HInvis && !Blind) {
227.  		    makeknown(uarmc->otyp);
228.  		    newsym(u.ux,u.uy);
229.  		    pline("Suddenly you can%s yourself.",
230.  			See_invisible ? " see through" : "not see");
231.  		}
232.  		break;
233.  	case OILSKIN_CLOAK:
234.  		pline("%s very tightly.", Tobjnam(uarmc, "fit"));
235.  		break;
236.  	/* Alchemy smock gives poison _and_ acid resistance */
237.  	case ALCHEMY_SMOCK:
238.  		EAcid_resistance |= WORN_CLOAK;
239.    		break;
240.  	default: impossible(unknown_type, c_cloak, uarmc->otyp);
241.      }
242.      return 0;
243.  }
244.  

Cloak_off

245.  int
246.  Cloak_off()
247.  {
248.      int otyp = uarmc->otyp;
249.      long oldprop = u.uprops[objects[otyp].oc_oprop].extrinsic & ~WORN_CLOAK;
250.  
251.      takeoff_mask &= ~W_ARMC;
252.  	/* For mummy wrapping, taking it off first resets `Invisible'. */
253.      setworn((struct obj *)0, W_ARMC);
254.      switch (otyp) {
255.  	case ELVEN_CLOAK:
256.  	case ORCISH_CLOAK:
257.  	case DWARVISH_CLOAK:
258.  	case CLOAK_OF_PROTECTION:
259.  	case CLOAK_OF_MAGIC_RESISTANCE:
260.  	case CLOAK_OF_DISPLACEMENT:
261.  	case OILSKIN_CLOAK:
262.  	case ROBE:
263.  	case LEATHER_CLOAK:
264.  		break;
265.  	case MUMMY_WRAPPING:
266.  		if (Invis && !Blind) {
267.  		    newsym(u.ux,u.uy);
268.  		    You("can %s.",
269.  			See_invisible ? "see through yourself"
270.  			: "no longer see yourself");
271.  		}
272.  		break;
273.  	case CLOAK_OF_INVISIBILITY:
274.  		if (!oldprop && !HInvis && !Blind) {
275.  		    makeknown(CLOAK_OF_INVISIBILITY);
276.  		    newsym(u.ux,u.uy);
277.  		    pline("Suddenly you can %s.",
278.  			See_invisible ? "no longer see through yourself"
279.  			: see_yourself);
280.  		}
281.  		break;
282.  	/* Alchemy smock gives poison _and_ acid resistance */
283.  	case ALCHEMY_SMOCK:
284.  		EAcid_resistance &= ~WORN_CLOAK;
285.    		break;
286.  	default: impossible(unknown_type, c_cloak, otyp);
287.      }
288.      return 0;
289.  }
290.  

Helmet_on

291.  STATIC_PTR
292.  int
293.  Helmet_on()
294.  {
295.      switch(uarmh->otyp) {
296.  	case FEDORA:
297.  	case HELMET:
298.  	case DENTED_POT:
299.  	case ELVEN_LEATHER_HELM:
300.  	case DWARVISH_IRON_HELM:
301.  	case ORCISH_HELM:
302.  	case HELM_OF_TELEPATHY:
303.  		break;
304.  	case HELM_OF_BRILLIANCE:
305.  		adj_abon(uarmh, uarmh->spe);
306.  		break;
307.  	case CORNUTHAUM:
308.  		/* people think marked wizards know what they're talking
309.  		 * about, but it takes trained arrogance to pull it off,
310.  		 * and the actual enchantment of the hat is irrelevant.
311.  		 */
312.  		ABON(A_CHA) += (Role_if(PM_WIZARD) ? 1 : -1);
313.  		flags.botl = 1;
314.  		makeknown(uarmh->otyp);
315.  		break;
316.  	case HELM_OF_OPPOSITE_ALIGNMENT:
317.  		if (u.ualign.type == A_NEUTRAL)
318.  		    u.ualign.type = rn2(2) ? A_CHAOTIC : A_LAWFUL;
319.  		else u.ualign.type = -(u.ualign.type);
320.  		u.ublessed = 0; /* lose your god's protection */
321.  	     /* makeknown(uarmh->otyp);   -- moved below, after xname() */
322.  		/*FALLTHRU*/
323.  	case DUNCE_CAP:
324.  		if (!uarmh->cursed) {
325.  		    if (Blind)
326.  			pline("%s for a moment.", Tobjnam(uarmh, "vibrate"));
327.  		    else
328.  			pline("%s %s for a moment.",
329.  			      Tobjnam(uarmh, "glow"), hcolor(NH_BLACK));
330.  		    curse(uarmh);
331.  		}
332.  		flags.botl = 1;		/* reveal new alignment or INT & WIS */
333.  		if (Hallucination) {
334.  		    pline("My brain hurts!"); /* Monty Python's Flying Circus */
335.  		} else if (uarmh->otyp == DUNCE_CAP) {
336.  		    You_feel("%s.",	/* track INT change; ignore WIS */
337.  		  ACURR(A_INT) <= (ABASE(A_INT) + ABON(A_INT) + ATEMP(A_INT)) ?
338.  			     "like sitting in a corner" : "giddy");
339.  		} else {
340.  		    Your("mind oscillates briefly.");
341.  		    makeknown(HELM_OF_OPPOSITE_ALIGNMENT);
342.  		}
343.  		break;
344.  	default: impossible(unknown_type, c_helmet, uarmh->otyp);
345.      }
346.      return 0;
347.  }
348.  

Helmet_off

349.  int
350.  Helmet_off()
351.  {
352.      takeoff_mask &= ~W_ARMH;
353.  
354.      switch(uarmh->otyp) {
355.  	case FEDORA:
356.  	case HELMET:
357.  	case DENTED_POT:
358.  	case ELVEN_LEATHER_HELM:
359.  	case DWARVISH_IRON_HELM:
360.  	case ORCISH_HELM:
361.  	    break;
362.  	case DUNCE_CAP:
363.  	    flags.botl = 1;
364.  	    break;
365.  	case CORNUTHAUM:
366.  	    if (!cancelled_don) {
367.  		ABON(A_CHA) += (Role_if(PM_WIZARD) ? -1 : 1);
368.  		flags.botl = 1;
369.  	    }
370.  	    break;
371.  	case HELM_OF_TELEPATHY:
372.  	    /* need to update ability before calling see_monsters() */
373.  	    setworn((struct obj *)0, W_ARMH);
374.  	    see_monsters();
375.  	    return 0;
376.  	case HELM_OF_BRILLIANCE:
377.  	    if (!cancelled_don) adj_abon(uarmh, -uarmh->spe);
378.  	    break;
379.  	case HELM_OF_OPPOSITE_ALIGNMENT:
380.  	    u.ualign.type = u.ualignbase[A_CURRENT];
381.  	    u.ublessed = 0; /* lose the other god's protection */
382.  	    flags.botl = 1;
383.  	    break;
384.  	default: impossible(unknown_type, c_helmet, uarmh->otyp);
385.      }
386.      setworn((struct obj *)0, W_ARMH);
387.      cancelled_don = FALSE;
388.      return 0;
389.  }
390.  

Gloves_on

391.  STATIC_PTR
392.  int
393.  Gloves_on()
394.  {
395.      long oldprop =
396.  	u.uprops[objects[uarmg->otyp].oc_oprop].extrinsic & ~WORN_GLOVES;
397.  
398.      switch(uarmg->otyp) {
399.  	case LEATHER_GLOVES:
400.  		break;
401.  	case GAUNTLETS_OF_FUMBLING:
402.  		if (!oldprop && !(HFumbling & ~TIMEOUT))
403.  			incr_itimeout(&HFumbling, rnd(20));
404.  		break;
405.  	case GAUNTLETS_OF_POWER:
406.  		makeknown(uarmg->otyp);
407.  		flags.botl = 1; /* taken care of in attrib.c */
408.  		break;
409.  	case GAUNTLETS_OF_DEXTERITY:
410.  		adj_abon(uarmg, uarmg->spe);
411.  		break;
412.  	default: impossible(unknown_type, c_gloves, uarmg->otyp);
413.      }
414.      return 0;
415.  }
416.  

Gloves_off

417.  int
418.  Gloves_off()
419.  {
420.      long oldprop =
421.  	u.uprops[objects[uarmg->otyp].oc_oprop].extrinsic & ~WORN_GLOVES;
422.  
423.      takeoff_mask &= ~W_ARMG;
424.  
425.      switch(uarmg->otyp) {
426.  	case LEATHER_GLOVES:
427.  	    break;
428.  	case GAUNTLETS_OF_FUMBLING:
429.  	    if (!oldprop && !(HFumbling & ~TIMEOUT))
430.  		HFumbling = EFumbling = 0;
431.  	    break;
432.  	case GAUNTLETS_OF_POWER:
433.  	    makeknown(uarmg->otyp);
434.  	    flags.botl = 1; /* taken care of in attrib.c */
435.  	    break;
436.  	case GAUNTLETS_OF_DEXTERITY:
437.  	    if (!cancelled_don) adj_abon(uarmg, -uarmg->spe);
438.  	    break;
439.  	default: impossible(unknown_type, c_gloves, uarmg->otyp);
440.      }
441.      setworn((struct obj *)0, W_ARMG);
442.      cancelled_don = FALSE;
443.      (void) encumber_msg();		/* immediate feedback for GoP */
444.  
445.      /* Prevent wielding cockatrice when not wearing gloves */
446.      if (uwep && uwep->otyp == CORPSE &&
447.  		touch_petrifies(&mons[uwep->corpsenm])) {
448.  	char kbuf[BUFSZ];
449.  
450.  	You("wield the %s in your bare %s.",
451.  	    corpse_xname(uwep, TRUE), makeplural(body_part(HAND)));
452.  	Strcpy(kbuf, an(corpse_xname(uwep, TRUE)));
453.  	instapetrify(kbuf);
454.  	uwepgone();  /* life-saved still doesn't allow touching cockatrice */
455.      }
456.  
457.      /* KMH -- ...or your secondary weapon when you're wielding it */
458.      if (u.twoweap && uswapwep && uswapwep->otyp == CORPSE &&
459.  	touch_petrifies(&mons[uswapwep->corpsenm])) {
460.  	char kbuf[BUFSZ];
461.  
462.  	You("wield the %s in your bare %s.",
463.  	    corpse_xname(uswapwep, TRUE), body_part(HAND));
464.  
465.  	Strcpy(kbuf, an(corpse_xname(uswapwep, TRUE)));
466.  	instapetrify(kbuf);
467.  	uswapwepgone();	/* lifesaved still doesn't allow touching cockatrice */
468.      }
469.  
470.      return 0;
471.  }
472.  

Shield_on

473.  STATIC_OVL int
474.  Shield_on()
475.  {
476.  /*
477.      switch (uarms->otyp) {
478.  	case SMALL_SHIELD:
479.  	case ELVEN_SHIELD:
480.  	case URUK_HAI_SHIELD:
481.  	case ORCISH_SHIELD:
482.  	case DWARVISH_ROUNDSHIELD:
483.  	case LARGE_SHIELD:
484.  	case SHIELD_OF_REFLECTION:
485.  		break;
486.  	default: impossible(unknown_type, c_shield, uarms->otyp);
487.      }
488.  */
489.      return 0;
490.  }
491.  

Shield_off

492.  int
493.  Shield_off()
494.  {
495.      takeoff_mask &= ~W_ARMS;
496.  /*
497.      switch (uarms->otyp) {
498.  	case SMALL_SHIELD:
499.  	case ELVEN_SHIELD:
500.  	case URUK_HAI_SHIELD:
501.  	case ORCISH_SHIELD:
502.  	case DWARVISH_ROUNDSHIELD:
503.  	case LARGE_SHIELD:
504.  	case SHIELD_OF_REFLECTION:
505.  		break;
506.  	default: impossible(unknown_type, c_shield, uarms->otyp);
507.      }
508.  */
509.      setworn((struct obj *)0, W_ARMS);
510.      return 0;
511.  }
512.  

Shirt_on

513.  #ifdef TOURIST
514.  STATIC_OVL int
515.  Shirt_on()
516.  {
517.  /*
518.      switch (uarmu->otyp) {
519.  	case HAWAIIAN_SHIRT:
520.  	case T_SHIRT:
521.  		break;
522.  	default: impossible(unknown_type, c_shirt, uarmu->otyp);
523.      }
524.  */
525.      return 0;
526.  }
527.  

Shirt_off

528.  int
529.  Shirt_off()
530.  {
531.      takeoff_mask &= ~W_ARMU;
532.  /*
533.      switch (uarmu->otyp) {
534.  	case HAWAIIAN_SHIRT:
535.  	case T_SHIRT:
536.  		break;
537.  	default: impossible(unknown_type, c_shirt, uarmu->otyp);
538.      }
539.  */
540.      setworn((struct obj *)0, W_ARMU);
541.      return 0;
542.  }
543.  #endif	/*TOURIST*/
544.  

Armor_on

545.  /* This must be done in worn.c, because one of the possible intrinsics conferred
546.   * is fire resistance, and we have to immediately set HFire_resistance in worn.c
547.   * since worn.c will check it before returning.
548.   */
549.  STATIC_PTR
550.  int
551.  Armor_on()
552.  {
553.      return 0;
554.  }
555.  

Armor_off

556.  int
557.  Armor_off()
558.  {
559.      takeoff_mask &= ~W_ARM;
560.      setworn((struct obj *)0, W_ARM);
561.      cancelled_don = FALSE;
562.      return 0;
563.  }
564.  

Armor_gone

565.  /* The gone functions differ from the off functions in that if you die from
566.   * taking it off and have life saving, you still die.
567.   */
568.  int
569.  Armor_gone()
570.  {
571.      takeoff_mask &= ~W_ARM;
572.      setnotworn(uarm);
573.      cancelled_don = FALSE;
574.      return 0;
575.  }
576.  

Amulet_on

577.  STATIC_OVL void
578.  Amulet_on()
579.  {
580.      switch(uamul->otyp) {
581.  	case AMULET_OF_ESP:
582.  	case AMULET_OF_LIFE_SAVING:
583.  	case AMULET_VERSUS_POISON:
584.  	case AMULET_OF_REFLECTION:
585.  	case AMULET_OF_MAGICAL_BREATHING:
586.  	case FAKE_AMULET_OF_YENDOR:
587.  		break;
588.  	case AMULET_OF_UNCHANGING:
589.  		if (Slimed) {
590.  		    Slimed = 0;
591.  		    flags.botl = 1;
592.  		}
593.  		break;
594.  	case AMULET_OF_CHANGE:
595.  	    {
596.  		int orig_sex = poly_gender();
597.  
598.  		if (Unchanging) break;
599.  		change_sex();
600.  		/* Don't use same message as polymorph */
601.  		if (orig_sex != poly_gender()) {
602.  		    makeknown(AMULET_OF_CHANGE);
603.  		    You("are suddenly very %s!", flags.female ? "feminine"
604.  			: "masculine");
605.  		    flags.botl = 1;
606.  		} else
607.  		    /* already polymorphed into single-gender monster; only
608.  		       changed the character's base sex */
609.  		    You("don't feel like yourself.");
610.  		pline_The("amulet disintegrates!");
611.  		if (orig_sex == poly_gender() && uamul->dknown &&
612.  			!objects[AMULET_OF_CHANGE].oc_name_known &&
613.  			!objects[AMULET_OF_CHANGE].oc_uname)
614.  		    docall(uamul);
615.  		useup(uamul);
616.  		break;
617.  	    }
618.  	case AMULET_OF_STRANGULATION:
619.  		makeknown(AMULET_OF_STRANGULATION);
620.  		pline("It constricts your throat!");
621.  		Strangled = 6;
622.  		break;
623.  	case AMULET_OF_RESTFUL_SLEEP:
624.  		HSleeping = rnd(100);
625.  		break;
626.  	case AMULET_OF_YENDOR:
627.  		break;
628.      }
629.  }
630.  

Amulet_off

631.  void
632.  Amulet_off()
633.  {
634.      takeoff_mask &= ~W_AMUL;
635.  
636.      switch(uamul->otyp) {
637.  	case AMULET_OF_ESP:
638.  		/* need to update ability before calling see_monsters() */
639.  		setworn((struct obj *)0, W_AMUL);
640.  		see_monsters();
641.  		return;
642.  	case AMULET_OF_LIFE_SAVING:
643.  	case AMULET_VERSUS_POISON:
644.  	case AMULET_OF_REFLECTION:
645.  	case AMULET_OF_CHANGE:
646.  	case AMULET_OF_UNCHANGING:
647.  	case FAKE_AMULET_OF_YENDOR:
648.  		break;
649.  	case AMULET_OF_MAGICAL_BREATHING:
650.  		if (Underwater) {
651.  		    /* HMagical_breathing must be set off
652.  			before calling drown() */
653.  		    setworn((struct obj *)0, W_AMUL);
654.  		    if (!breathless(youmonst.data) && !amphibious(youmonst.data)
655.  						&& !Swimming) {
656.  			You("suddenly inhale an unhealthy amount of water!");
657.  		    	(void) drown();
658.  		    }
659.  		    return;
660.  		}
661.  		break;
662.  	case AMULET_OF_STRANGULATION:
663.  		if (Strangled) {
664.  			You("can breathe more easily!");
665.  			Strangled = 0;
666.  		}
667.  		break;
668.  	case AMULET_OF_RESTFUL_SLEEP:
669.  		setworn((struct obj *)0, W_AMUL);
670.  		if (!ESleeping)
671.  			HSleeping = 0;
672.  		return;
673.  	case AMULET_OF_YENDOR:
674.  		break;
675.      }
676.      setworn((struct obj *)0, W_AMUL);
677.      return;
678.  }
679.  

Ring_on

680.  void
681.  Ring_on(obj)
682.  register struct obj *obj;
683.  {
684.      long oldprop = u.uprops[objects[obj->otyp].oc_oprop].extrinsic;
685.      int old_attrib, which;
686.  
687.      if (obj == uwep) setuwep((struct obj *) 0);
688.      if (obj == uswapwep) setuswapwep((struct obj *) 0);
689.      if (obj == uquiver) setuqwep((struct obj *) 0);
690.  
691.      /* only mask out W_RING when we don't have both
692.         left and right rings of the same type */
693.      if ((oldprop & W_RING) != W_RING) oldprop &= ~W_RING;
694.  
695.      switch(obj->otyp){
696.  	case RIN_TELEPORTATION:
697.  	case RIN_REGENERATION:
698.  	case RIN_SEARCHING:
699.  	case RIN_STEALTH:
700.  	case RIN_HUNGER:
701.  	case RIN_AGGRAVATE_MONSTER:
702.  	case RIN_POISON_RESISTANCE:
703.  	case RIN_FIRE_RESISTANCE:
704.  	case RIN_COLD_RESISTANCE:
705.  	case RIN_SHOCK_RESISTANCE:
706.  	case RIN_CONFLICT:
707.  	case RIN_TELEPORT_CONTROL:
708.  	case RIN_POLYMORPH:
709.  	case RIN_POLYMORPH_CONTROL:
710.  	case RIN_FREE_ACTION:                
711.  	case RIN_SLOW_DIGESTION:
712.  	case RIN_SUSTAIN_ABILITY:
713.  	case MEAT_RING:
714.  		break;
715.  	case RIN_WARNING:
716.  		see_monsters();
717.  		break;
718.  	case RIN_SEE_INVISIBLE:
719.  		/* can now see invisible monsters */
720.  		set_mimic_blocking(); /* do special mimic handling */
721.  		see_monsters();
722.  #ifdef INVISIBLE_OBJECTS
723.  		see_objects();
724.  #endif
725.  
726.  		if (Invis && !oldprop && !HSee_invisible &&
727.  				!perceives(youmonst.data) && !Blind) {
728.  		    newsym(u.ux,u.uy);
729.  		    pline("Suddenly you are transparent, but there!");
730.  		    makeknown(RIN_SEE_INVISIBLE);
731.  		}
732.  		break;
733.  	case RIN_INVISIBILITY:
734.  		if (!oldprop && !HInvis && !BInvis && !Blind) {
735.  		    makeknown(RIN_INVISIBILITY);
736.  		    newsym(u.ux,u.uy);
737.  		    self_invis_message();
738.  		}
739.  		break;
740.  	case RIN_LEVITATION:
741.  		if (!oldprop && !HLevitation) {
742.  		    float_up();
743.  		    makeknown(RIN_LEVITATION);
744.  		    spoteffects(FALSE);	/* for sinks */
745.  		}
746.  		break;
747.  	case RIN_GAIN_STRENGTH:
748.  		which = A_STR;
749.  		goto adjust_attrib;
750.  	case RIN_GAIN_CONSTITUTION:
751.  		which = A_CON;
752.  		goto adjust_attrib;
753.  	case RIN_ADORNMENT:
754.  		which = A_CHA;
755.   adjust_attrib:
756.  		old_attrib = ACURR(which);
757.  		ABON(which) += obj->spe;
758.  		if (ACURR(which) != old_attrib ||
759.  			(objects[obj->otyp].oc_name_known &&
760.  			    old_attrib != 25 && old_attrib != 3)) {
761.  		    flags.botl = 1;
762.  		    makeknown(obj->otyp);
763.  		    obj->known = 1;
764.  		    update_inventory();
765.  		}
766.  		break;
767.  	case RIN_INCREASE_ACCURACY:	/* KMH */
768.  		u.uhitinc += obj->spe;
769.  		break;
770.  	case RIN_INCREASE_DAMAGE:
771.  		u.udaminc += obj->spe;
772.  		break;
773.  	case RIN_PROTECTION_FROM_SHAPE_CHAN:
774.  		rescham();
775.  		break;
776.  	case RIN_PROTECTION:
777.  		if (obj->spe || objects[RIN_PROTECTION].oc_name_known) {
778.  		    flags.botl = 1;
779.  		    makeknown(RIN_PROTECTION);
780.  		    obj->known = 1;
781.  		    update_inventory();
782.  		}
783.  		break;
784.      }
785.  }
786.  

Ring_off_or_gone

787.  STATIC_OVL void
788.  Ring_off_or_gone(obj,gone)
789.  register struct obj *obj;
790.  boolean gone;
791.  {
792.      long mask = (obj->owornmask & W_RING);
793.      int old_attrib, which;
794.  
795.      takeoff_mask &= ~mask;
796.      if(!(u.uprops[objects[obj->otyp].oc_oprop].extrinsic & mask))
797.  	impossible("Strange... I didn't know you had that ring.");
798.      if(gone) setnotworn(obj);
799.      else setworn((struct obj *)0, obj->owornmask);
800.  
801.      switch(obj->otyp) {
802.  	case RIN_TELEPORTATION:
803.  	case RIN_REGENERATION:
804.  	case RIN_SEARCHING:
805.  	case RIN_STEALTH:
806.  	case RIN_HUNGER:
807.  	case RIN_AGGRAVATE_MONSTER:
808.  	case RIN_POISON_RESISTANCE:
809.  	case RIN_FIRE_RESISTANCE:
810.  	case RIN_COLD_RESISTANCE:
811.  	case RIN_SHOCK_RESISTANCE:
812.  	case RIN_CONFLICT:
813.  	case RIN_TELEPORT_CONTROL:
814.  	case RIN_POLYMORPH:
815.  	case RIN_POLYMORPH_CONTROL:
816.  	case RIN_FREE_ACTION:                
817.  	case RIN_SLOW_DIGESTION:
818.  	case RIN_SUSTAIN_ABILITY:
819.  	case MEAT_RING:
820.  		break;
821.  	case RIN_WARNING:
822.  		see_monsters();
823.  		break;
824.  	case RIN_SEE_INVISIBLE:
825.  		/* Make invisible monsters go away */
826.  		if (!See_invisible) {
827.  		    set_mimic_blocking(); /* do special mimic handling */
828.  		    see_monsters();
829.  #ifdef INVISIBLE_OBJECTS                
830.  		    see_objects();
831.  #endif
832.  		}
833.  
834.  		if (Invisible && !Blind) {
835.  		    newsym(u.ux,u.uy);
836.  		    pline("Suddenly you cannot see yourself.");
837.  		    makeknown(RIN_SEE_INVISIBLE);
838.  		}
839.  		break;
840.  	case RIN_INVISIBILITY:
841.  		if (!Invis && !BInvis && !Blind) {
842.  		    newsym(u.ux,u.uy);
843.  		    Your("body seems to unfade%s.",
844.  			 See_invisible ? " completely" : "..");
845.  		    makeknown(RIN_INVISIBILITY);
846.  		}
847.  		break;
848.  	case RIN_LEVITATION:
849.  		(void) float_down(0L, 0L);
850.  		if (!Levitation) makeknown(RIN_LEVITATION);
851.  		break;
852.  	case RIN_GAIN_STRENGTH:
853.  		which = A_STR;
854.  		goto adjust_attrib;
855.  	case RIN_GAIN_CONSTITUTION:
856.  		which = A_CON;
857.  		goto adjust_attrib;
858.  	case RIN_ADORNMENT:
859.  		which = A_CHA;
860.   adjust_attrib:
861.  		old_attrib = ACURR(which);
862.  		ABON(which) -= obj->spe;
863.  		if (ACURR(which) != old_attrib) {
864.  		    flags.botl = 1;
865.  		    makeknown(obj->otyp);
866.  		    obj->known = 1;
867.  		    update_inventory();
868.  		}
869.  		break;
870.  	case RIN_INCREASE_ACCURACY:	/* KMH */
871.  		u.uhitinc -= obj->spe;
872.  		break;
873.  	case RIN_INCREASE_DAMAGE:
874.  		u.udaminc -= obj->spe;
875.  		break;
876.  	case RIN_PROTECTION:
877.  		/* might have forgotten it due to amnesia */
878.  		if (obj->spe) {
879.  		    flags.botl = 1;
880.  		    makeknown(RIN_PROTECTION);
881.  		    obj->known = 1;
882.  		    update_inventory();
883.  		}
884.  	case RIN_PROTECTION_FROM_SHAPE_CHAN:
885.  		/* If you're no longer protected, let the chameleons
886.  		 * change shape again -dgk
887.  		 */
888.  		restartcham();
889.  		break;
890.      }
891.  }
892.  

Ring_off

893.  void
894.  Ring_off(obj)
895.  struct obj *obj;
896.  {
897.  	Ring_off_or_gone(obj,FALSE);
898.  }
899.  

Ring_gone

900.  void
901.  Ring_gone(obj)
902.  struct obj *obj;
903.  {
904.  	Ring_off_or_gone(obj,TRUE);
905.  }
906.  

Blindf_on

907.  void
908.  Blindf_on(otmp)
909.  register struct obj *otmp;
910.  {
911.  	boolean already_blind = Blind, changed = FALSE;
912.  
913.  	if (otmp == uwep)
914.  	    setuwep((struct obj *) 0);
915.  	if (otmp == uswapwep)
916.  	    setuswapwep((struct obj *) 0);
917.  	if (otmp == uquiver)
918.  	    setuqwep((struct obj *) 0);
919.  	setworn(otmp, W_TOOL);
920.  	on_msg(otmp);
921.  
922.  	if (Blind && !already_blind) {
923.  	    changed = TRUE;
924.  	    if (flags.verbose) You_cant("see any more.");
925.  	    /* set ball&chain variables before the hero goes blind */
926.  	    if (Punished) set_bc(0);
927.  	} else if (already_blind && !Blind) {
928.  	    changed = TRUE;
929.  	    /* "You are now wearing the Eyes of the Overworld." */
930.  	    You("can see!");
931.  	}
932.  	if (changed) {
933.  	    /* blindness has just been toggled */
934.  	    if (Blind_telepat || Infravision) see_monsters();
935.  	    vision_full_recalc = 1;	/* recalc vision limits */
936.  	    flags.botl = 1;
937.  	}
938.  }
939.  

Blindf_off

940.  void
941.  Blindf_off(otmp)
942.  register struct obj *otmp;
943.  {
944.  	boolean was_blind = Blind, changed = FALSE;
945.  
946.  	takeoff_mask &= ~W_TOOL;
947.  	setworn((struct obj *)0, otmp->owornmask);
948.  	off_msg(otmp);
949.  
950.  	if (Blind) {
951.  	    if (was_blind) {
952.  		/* "still cannot see" makes no sense when removing lenses
953.  		   since they can't have been the cause of your blindness */
954.  		if (otmp->otyp != LENSES)
955.  		    You("still cannot see.");
956.  	    } else {
957.  		changed = TRUE;	/* !was_blind */
958.  		/* "You were wearing the Eyes of the Overworld." */
959.  		You_cant("see anything now!");
960.  		/* set ball&chain variables before the hero goes blind */
961.  		if (Punished) set_bc(0);
962.  	    }
963.  	} else if (was_blind) {
964.  	    changed = TRUE;	/* !Blind */
965.  	    You("can see again.");
966.  	}
967.  	if (changed) {
968.  	    /* blindness has just been toggled */
969.  	    if (Blind_telepat || Infravision) see_monsters();
970.  	    vision_full_recalc = 1;	/* recalc vision limits */
971.  	    flags.botl = 1;
972.  	}
973.  }
974.  

set_wear

975.  /* called in main to set intrinsics of worn start-up items */
976.  void
977.  set_wear()
978.  {
979.  #ifdef TOURIST
980.  	if (uarmu) (void) Shirt_on();
981.  #endif
982.  	if (uarm)  (void) Armor_on();
983.  	if (uarmc) (void) Cloak_on();
984.  	if (uarmf) (void) Boots_on();
985.  	if (uarmg) (void) Gloves_on();
986.  	if (uarmh) (void) Helmet_on();
987.  	if (uarms) (void) Shield_on();
988.  }
989.  

donning

990.  /* check whether the target object is currently being put on (or taken off) */
991.  boolean
992.  donning(otmp)		/* also checks for doffing */
993.  register struct obj *otmp;
994.  {
995.   /* long what = (occupation == take_off) ? taking_off : 0L; */
996.      long what = taking_off;	/* if nonzero, occupation is implied */
997.      boolean result = FALSE;
998.  
999.      if (otmp == uarm)
1000. 	result = (afternmv == Armor_on || afternmv == Armor_off ||
1001. 		  what == WORN_ARMOR);
1002. #ifdef TOURIST
1003.     else if (otmp == uarmu)
1004. 	result = (afternmv == Shirt_on || afternmv == Shirt_off ||
1005. 		  what == WORN_SHIRT);
1006. #endif
1007.     else if (otmp == uarmc)
1008. 	result = (afternmv == Cloak_on || afternmv == Cloak_off ||
1009. 		  what == WORN_CLOAK);
1010.     else if (otmp == uarmf)
1011. 	result = (afternmv == Boots_on || afternmv == Boots_off ||
1012. 		  what == WORN_BOOTS);
1013.     else if (otmp == uarmh)
1014. 	result = (afternmv == Helmet_on || afternmv == Helmet_off ||
1015. 		  what == WORN_HELMET);
1016.     else if (otmp == uarmg)
1017. 	result = (afternmv == Gloves_on || afternmv == Gloves_off ||
1018. 		  what == WORN_GLOVES);
1019.     else if (otmp == uarms)
1020. 	result = (afternmv == Shield_on || afternmv == Shield_off ||
1021. 		  what == WORN_SHIELD);
1022. 
1023.     return result;
1024. }
1025. 

cancel_don

1026. void
1027. cancel_don()
1028. {
1029. 	/* the piece of armor we were donning/doffing has vanished, so stop
1030. 	 * wasting time on it (and don't dereference it when donning would
1031. 	 * otherwise finish)
1032. 	 */
1033. 	cancelled_don = (afternmv == Boots_on || afternmv == Helmet_on ||
1034. 			 afternmv == Gloves_on || afternmv == Armor_on);
1035. 	afternmv = 0;
1036. 	nomovemsg = (char *)0;
1037. 	multi = 0;
1038. 	todelay = 0;
1039. 	taking_off = 0L;
1040. }
1041. 

dotakeoff

1042. static NEARDATA const char clothes[] = {ARMOR_CLASS, 0};
1043. static NEARDATA const char accessories[] = {RING_CLASS, AMULET_CLASS, TOOL_CLASS, FOOD_CLASS, 0};
1044. 
1045. /* the 'T' command */
1046. int
1047. dotakeoff()
1048. {
1049. 	register struct obj *otmp = (struct obj *)0;
1050. 	int armorpieces = 0;
1051. 
1052. #define MOREARM(x) if (x) { armorpieces++; otmp = x; }
1053. 	MOREARM(uarmh);
1054. 	MOREARM(uarms);
1055. 	MOREARM(uarmg);
1056. 	MOREARM(uarmf);
1057. 	if (uarmc) {
1058. 		armorpieces++;
1059. 		otmp = uarmc;
1060. 	} else if (uarm) {
1061. 		armorpieces++;
1062. 		otmp = uarm;
1063. #ifdef TOURIST
1064. 	} else if (uarmu) {
1065. 		armorpieces++;
1066. 		otmp = uarmu;
1067. #endif
1068. 	}
1069. 	if (!armorpieces) {
1070. 	     /* assert( GRAY_DRAGON_SCALES > YELLOW_DRAGON_SCALE_MAIL ); */
1071. 		if (uskin)
1072. 		    pline_The("%s merged with your skin!",
1073. 			      uskin->otyp >= GRAY_DRAGON_SCALES ?
1074. 				"dragon scales are" : "dragon scale mail is");
1075. 		else
1076. 		    pline("Not wearing any armor.%s", (iflags.cmdassist && 
1077. 				(uleft || uright || uamul || ublindf)) ?
1078. 			  "  Use 'R' command to remove accessories." : "");
1079. 		return 0;
1080. 	}
1081. 	if (armorpieces > 1)
1082. 		otmp = getobj(clothes, "take off");
1083. 	if (otmp == 0) return(0);
1084. 	if (!(otmp->owornmask & W_ARMOR)) {
1085. 		You("are not wearing that.");
1086. 		return(0);
1087. 	}
1088. 	/* note: the `uskin' case shouldn't be able to happen here; dragons
1089. 	   can't wear any armor so will end up with `armorpieces == 0' above */
1090. 	if (otmp == uskin || ((otmp == uarm) && uarmc)
1091. #ifdef TOURIST
1092. 			  || ((otmp == uarmu) && (uarmc || uarm))
1093. #endif
1094. 		) {
1095. 	    You_cant("take that off.");
1096. 	    return 0;
1097. 	}
1098. 
1099. 	reset_remarm();		/* clear takeoff_mask and taking_off */
1100. 	(void) select_off(otmp);
1101. 	if (!takeoff_mask) return 0;
1102. 	reset_remarm();		/* armoroff() doesn't use takeoff_mask */
1103. 
1104. 	(void) armoroff(otmp);
1105. 	return(1);
1106. }
1107. 

doremring

1108. /* the 'R' command */
1109. int
1110. doremring()
1111. {
1112. 	register struct obj *otmp = 0;
1113. 	int Accessories = 0;
1114. 
1115. #define MOREACC(x) if (x) { Accessories++; otmp = x; }
1116. 	MOREACC(uleft);
1117. 	MOREACC(uright);
1118. 	MOREACC(uamul);
1119. 	MOREACC(ublindf);
1120. 
1121. 	if(!Accessories) {
1122. 		pline("Not wearing any accessories.%s", (iflags.cmdassist &&
1123. 			    (uarm || uarmc ||
1124. #ifdef TOURIST
1125. 			     uarmu ||
1126. #endif
1127. 			     uarms || uarmh || uarmg || uarmf)) ?
1128. 		      "  Use 'T' command to take off armor." : "");
1129. 		return(0);
1130. 	}
1131. 	if (Accessories != 1) otmp = getobj(accessories, "remove");
1132. 	if(!otmp) return(0);
1133. 	if(!(otmp->owornmask & (W_RING | W_AMUL | W_TOOL))) {
1134. 		You("are not wearing that.");
1135. 		return(0);
1136. 	}
1137. 
1138. 	reset_remarm();		/* clear takeoff_mask and taking_off */
1139. 	(void) select_off(otmp);
1140. 	if (!takeoff_mask) return 0;
1141. 	reset_remarm();		/* not used by Ring_/Amulet_/Blindf_off() */
1142. 
1143. 	if (otmp == uright || otmp == uleft) {
1144. 		/* Sometimes we want to give the off_msg before removing and
1145. 		 * sometimes after; for instance, "you were wearing a moonstone
1146. 		 * ring (on right hand)" is desired but "you were wearing a
1147. 		 * square amulet (being worn)" is not because of the redundant
1148. 		 * "being worn".
1149. 		 */
1150. 		off_msg(otmp);
1151. 		Ring_off(otmp);
1152. 	} else if (otmp == uamul) {
1153. 		Amulet_off();
1154. 		off_msg(otmp);
1155. 	} else if (otmp == ublindf) {
1156. 		Blindf_off(otmp);	/* does its own off_msg */
1157. 	} else {
1158. 		impossible("removing strange accessory?");
1159. 	}
1160. 	return(1);
1161. }
1162. 

cursed

1163. /* Check if something worn is cursed _and_ unremovable. */
1164. int
1165. cursed(otmp)
1166. register struct obj *otmp;
1167. {
1168. 	/* Curses, like chickens, come home to roost. */
1169. 	if((otmp == uwep) ? welded(otmp) : (int)otmp->cursed) {
1170. 		You("can't.  %s cursed.",
1171. 			(is_boots(otmp) || is_gloves(otmp) || otmp->quan > 1L)
1172. 			? "They are" : "It is");
1173. 		otmp->bknown = TRUE;
1174. 		return(1);
1175. 	}
1176. 	return(0);
1177. }
1178. 

armoroff

1179. int
1180. armoroff(otmp)
1181. register struct obj *otmp;
1182. {
1183. 	register int delay = -objects[otmp->otyp].oc_delay;
1184. 
1185. 	if(cursed(otmp)) return(0);
1186. 	if(delay) {
1187. 		nomul(delay);
1188. 		if (is_helmet(otmp)) {
1189. 			nomovemsg = "You finish taking off your helmet.";
1190. 			afternmv = Helmet_off;
1191. 		     }
1192. 		else if (is_gloves(otmp)) {
1193. 			nomovemsg = "You finish taking off your gloves.";
1194. 			afternmv = Gloves_off;
1195. 		     }
1196. 		else if (is_boots(otmp)) {
1197. 			nomovemsg = "You finish taking off your boots.";
1198. 			afternmv = Boots_off;
1199. 		     }
1200. 		else {
1201. 			nomovemsg = "You finish taking off your suit.";
1202. 			afternmv = Armor_off;
1203. 		}
1204. 	} else {
1205. 		/* Be warned!  We want off_msg after removing the item to
1206. 		 * avoid "You were wearing ____ (being worn)."  However, an
1207. 		 * item which grants fire resistance might cause some trouble
1208. 		 * if removed in Hell and lifesaving puts it back on; in this
1209. 		 * case the message will be printed at the wrong time (after
1210. 		 * the messages saying you died and were lifesaved).  Luckily,
1211. 		 * no cloak, shield, or fast-removable armor grants fire
1212. 		 * resistance, so we can safely do the off_msg afterwards.
1213. 		 * Rings do grant fire resistance, but for rings we want the
1214. 		 * off_msg before removal anyway so there's no problem.  Take
1215. 		 * care in adding armors granting fire resistance; this code
1216. 		 * might need modification.
1217. 		 * 3.2 (actually 3.1 even): this comment is obsolete since
1218. 		 * fire resistance is not needed for Gehennom.
1219. 		 */
1220. 		if(is_cloak(otmp))
1221. 			(void) Cloak_off();
1222. 		else if(is_shield(otmp))
1223. 			(void) Shield_off();
1224. 		else setworn((struct obj *)0, otmp->owornmask & W_ARMOR);
1225. 		off_msg(otmp);
1226. 	}
1227. 	takeoff_mask = taking_off = 0L;
1228. 	return(1);
1229. }
1230. 

already_wearing

1231. STATIC_OVL void
1232. already_wearing(cc)
1233. const char *cc;
1234. {
1235. 	You("are already wearing %s%c", cc, (cc == c_that_) ? '!' : '.');
1236. }
1237. 

already_wearing2

1238. STATIC_OVL void
1239. already_wearing2(cc1, cc2)
1240. const char *cc1, *cc2;
1241. {
1242. 	You_cant("wear %s because you're wearing %s there already.", cc1, cc2);
1243. }
1244. 

canwearobj

1245. /*
1246.  * canwearobj checks to see whether the player can wear a piece of armor
1247.  *
1248.  * inputs: otmp (the piece of armor)
1249.  *         noisy (if TRUE give error messages, otherwise be quiet about it)
1250.  * output: mask (otmp's armor type)
1251.  */
1252. int
1253. canwearobj(otmp,mask,noisy)
1254. struct obj *otmp;
1255. long *mask;
1256. boolean noisy;
1257. {
1258.     int err = 0;
1259.     const char *which;
1260. 
1261.     which = is_cloak(otmp) ? c_cloak :
1262. #ifdef TOURIST
1263. 	    is_shirt(otmp) ? c_shirt :
1264. #endif
1265. 	    is_suit(otmp) ? c_suit : 0;
1266.     if (which && cantweararm(youmonst.data) &&
1267. 	    /* same exception for cloaks as used in m_dowear() */
1268. 	    (which != c_cloak || youmonst.data->msize != MZ_SMALL) &&
1269. 	    (racial_exception(&youmonst, otmp) < 1)) {
1270. 	if (noisy) pline_The("%s will not fit on your body.", which);
1271. 	return 0;
1272.     } else if (otmp->owornmask & W_ARMOR) {
1273. 	if (noisy) already_wearing(c_that_);
1274. 	return 0;
1275.     }
1276. 
1277.     if (welded(uwep) && bimanual(uwep) &&
1278. 	    (is_suit(otmp)
1279. #ifdef TOURIST
1280. 			|| is_shirt(otmp)
1281. #endif
1282. 	    )) {
1283. 	if (noisy)
1284. 	    You("cannot do that while holding your %s.",
1285. 		is_sword(uwep) ? c_sword : c_weapon);
1286. 	return 0;
1287.     }
1288. 
1289.     if (is_helmet(otmp)) {
1290. 	if (uarmh) {
1291. 	    if (noisy) already_wearing(an(c_helmet));
1292. 	    err++;
1293. 	} else if (Upolyd && has_horns(youmonst.data) && !is_flimsy(otmp)) {
1294. 	    /* (flimsy exception matches polyself handling) */
1295. 	    if (noisy)
1296. 		pline_The("%s won't fit over your horn%s.",
1297. 			  c_helmet, plur(num_horns(youmonst.data)));
1298. 	    err++;
1299. 	} else
1300. 	    *mask = W_ARMH;
1301.     } else if (is_shield(otmp)) {
1302. 	if (uarms) {
1303. 	    if (noisy) already_wearing(an(c_shield));
1304. 	    err++;
1305. 	} else if (uwep && bimanual(uwep)) {
1306. 	    if (noisy) 
1307. 		You("cannot wear a shield while wielding a two-handed %s.",
1308. 		    is_sword(uwep) ? c_sword :
1309. 		    (uwep->otyp == BATTLE_AXE) ? c_axe : c_weapon);
1310. 	    err++;
1311. 	} else if (u.twoweap) {
1312. 	    if (noisy)
1313. 		You("cannot wear a shield while wielding two weapons.");
1314. 	    err++;
1315. 	} else
1316. 	    *mask = W_ARMS;
1317.     } else if (is_boots(otmp)) {
1318. 	if (uarmf) {
1319. 	    if (noisy) already_wearing(c_boots);
1320. 	    err++;
1321. 	} else if (Upolyd && slithy(youmonst.data)) {
1322. 	    if (noisy) You("have no feet...");	/* not body_part(FOOT) */
1323. 	    err++;
1324. 	} else if (Upolyd && youmonst.data->mlet == S_CENTAUR) {
1325. 	    /* break_armor() pushes boots off for centaurs,
1326. 	       so don't let dowear() put them back on... */
1327. 	    if (noisy) pline("You have too many hooves to wear %s.",
1328. 			     c_boots);	/* makeplural(body_part(FOOT)) yields
1329. 					   "rear hooves" which sounds odd */
1330. 	    err++;
1331. 	} else if (u.utrap && (u.utraptype == TT_BEARTRAP ||
1332. 				u.utraptype == TT_INFLOOR)) {
1333. 	    if (u.utraptype == TT_BEARTRAP) {
1334. 		if (noisy) Your("%s is trapped!", body_part(FOOT));
1335. 	    } else {
1336. 		if (noisy) Your("%s are stuck in the %s!",
1337. 				makeplural(body_part(FOOT)),
1338. 				surface(u.ux, u.uy));
1339. 	    }
1340. 	    err++;
1341. 	} else
1342. 	    *mask = W_ARMF;
1343.     } else if (is_gloves(otmp)) {
1344. 	if (uarmg) {
1345. 	    if (noisy) already_wearing(c_gloves);
1346. 	    err++;
1347. 	} else if (welded(uwep)) {
1348. 	    if (noisy) You("cannot wear gloves over your %s.",
1349. 			   is_sword(uwep) ? c_sword : c_weapon);
1350. 	    err++;
1351. 	} else
1352. 	    *mask = W_ARMG;
1353. #ifdef TOURIST
1354.     } else if (is_shirt(otmp)) {
1355. 	if (uarm || uarmc || uarmu) {
1356. 	    if (uarmu) {
1357. 		if (noisy) already_wearing(an(c_shirt));
1358. 	    } else {
1359. 		if (noisy) You_cant("wear that over your %s.",
1360. 			           (uarm && !uarmc) ? c_armor : cloak_simple_name(uarmc));
1361. 	    }
1362. 	    err++;
1363. 	} else
1364. 	    *mask = W_ARMU;
1365. #endif
1366.     } else if (is_cloak(otmp)) {
1367. 	if (uarmc) {
1368. 	    if (noisy) already_wearing(an(cloak_simple_name(uarmc)));
1369. 	    err++;
1370. 	} else
1371. 	    *mask = W_ARMC;
1372.     } else if (is_suit(otmp)) {
1373. 	if (uarmc) {
1374. 	    if (noisy) You("cannot wear armor over a %s.", cloak_simple_name(uarmc));
1375. 	    err++;
1376. 	} else if (uarm) {
1377. 	    if (noisy) already_wearing("some armor");
1378. 	    err++;
1379. 	} else
1380. 	    *mask = W_ARM;
1381.     } else {
1382. 	/* getobj can't do this after setting its allow_all flag; that
1383. 	   happens if you have armor for slots that are covered up or
1384. 	   extra armor for slots that are filled */
1385. 	if (noisy) silly_thing("wear", otmp);
1386. 	err++;
1387.     }
1388. /* Unnecessary since now only weapons and special items like pick-axes get
1389.  * welded to your hand, not armor
1390.     if (welded(otmp)) {
1391. 	if (!err++) {
1392. 	    if (noisy) weldmsg(otmp);
1393. 	}
1394.     }
1395.  */
1396.     return !err;
1397. }
1398. 

dowear

1399. /* the 'W' command */
1400. int
1401. dowear()
1402. {
1403. 	struct obj *otmp;
1404. 	int delay;
1405. 	long mask = 0;
1406. 
1407. 	/* cantweararm checks for suits of armor */
1408. 	/* verysmall or nohands checks for shields, gloves, etc... */
1409. 	if ((verysmall(youmonst.data) || nohands(youmonst.data))) {
1410. 		pline("Don't even bother.");
1411. 		return(0);
1412. 	}
1413. 
1414. 	otmp = getobj(clothes, "wear");
1415. 	if(!otmp) return(0);
1416. 
1417. 	if (!canwearobj(otmp,&mask,TRUE)) return(0);
1418. 
1419. 	if (otmp->oartifact && !touch_artifact(otmp, &youmonst))
1420. 	    return 1;	/* costs a turn even though it didn't get worn */
1421. 
1422. 	if (otmp->otyp == HELM_OF_OPPOSITE_ALIGNMENT &&
1423. 			qstart_level.dnum == u.uz.dnum) {	/* in quest */
1424. 		if (u.ualignbase[A_CURRENT] == u.ualignbase[A_ORIGINAL])
1425. 			You("narrowly avoid losing all chance at your goal.");
1426. 		else	/* converted */
1427. 			You("are suddenly overcome with shame and change your mind.");
1428. 		u.ublessed = 0; /* lose your god's protection */
1429. 		makeknown(otmp->otyp);
1430. 		flags.botl = 1;
1431. 		return 1;
1432. 	}
1433. 
1434. 	otmp->known = TRUE;
1435. 	if(otmp == uwep)
1436. 		setuwep((struct obj *)0);
1437. 	if (otmp == uswapwep)
1438. 		setuswapwep((struct obj *) 0);
1439. 	if (otmp == uquiver)
1440. 		setuqwep((struct obj *) 0);
1441. 	setworn(otmp, mask);
1442. 	delay = -objects[otmp->otyp].oc_delay;
1443. 	if(delay){
1444. 		nomul(delay);
1445. 		if(is_boots(otmp)) afternmv = Boots_on;
1446. 		if(is_helmet(otmp)) afternmv = Helmet_on;
1447. 		if(is_gloves(otmp)) afternmv = Gloves_on;
1448. 		if(otmp == uarm) afternmv = Armor_on;
1449. 		nomovemsg = "You finish your dressing maneuver.";
1450. 	} else {
1451. 		if(is_cloak(otmp)) (void) Cloak_on();
1452. 		if (is_shield(otmp)) (void) Shield_on();
1453. #ifdef TOURIST
1454. 		if (is_shirt(otmp)) (void) Shirt_on();
1455. #endif
1456. 		on_msg(otmp);
1457. 	}
1458. 	takeoff_mask = taking_off = 0L;
1459. 	return(1);
1460. }
1461. 

doputon

1462. int
1463. doputon()
1464. {
1465. 	register struct obj *otmp;
1466. 	long mask = 0L;
1467. 
1468. 	if(uleft && uright && uamul && ublindf) {
1469. 		Your("%s%s are full, and you're already wearing an amulet and %s.",
1470. 			humanoid(youmonst.data) ? "ring-" : "",
1471. 			makeplural(body_part(FINGER)),
1472. 			ublindf->otyp==LENSES ? "some lenses" : "a blindfold");
1473. 		return(0);
1474. 	}
1475. 	otmp = getobj(accessories, "put on");
1476. 	if(!otmp) return(0);
1477. 	if(otmp->owornmask & (W_RING | W_AMUL | W_TOOL)) {
1478. 		already_wearing(c_that_);
1479. 		return(0);
1480. 	}
1481. 	if(welded(otmp)) {
1482. 		weldmsg(otmp);
1483. 		return(0);
1484. 	}
1485. 	if(otmp == uwep)
1486. 		setuwep((struct obj *)0);
1487. 	if(otmp == uswapwep)
1488. 		setuswapwep((struct obj *) 0);
1489. 	if(otmp == uquiver)
1490. 		setuqwep((struct obj *) 0);
1491. 	if(otmp->oclass == RING_CLASS || otmp->otyp == MEAT_RING) {
1492. 		if(nolimbs(youmonst.data)) {
1493. 			You("cannot make the ring stick to your body.");
1494. 			return(0);
1495. 		}
1496. 		if(uleft && uright){
1497. 			There("are no more %s%s to fill.",
1498. 				humanoid(youmonst.data) ? "ring-" : "",
1499. 				makeplural(body_part(FINGER)));
1500. 			return(0);
1501. 		}
1502. 		if(uleft) mask = RIGHT_RING;
1503. 		else if(uright) mask = LEFT_RING;
1504. 		else do {
1505. 			char qbuf[QBUFSZ];
1506. 			char answer;
1507. 
1508. 			Sprintf(qbuf, "Which %s%s, Right or Left?",
1509. 				humanoid(youmonst.data) ? "ring-" : "",
1510. 				body_part(FINGER));
1511. 			if(!(answer = yn_function(qbuf, "rl", '\0')))
1512. 				return(0);
1513. 			switch(answer){
1514. 			case 'l':
1515. 			case 'L':
1516. 				mask = LEFT_RING;
1517. 				break;
1518. 			case 'r':
1519. 			case 'R':
1520. 				mask = RIGHT_RING;
1521. 				break;
1522. 			}
1523. 		} while(!mask);
1524. 		if (uarmg && uarmg->cursed) {
1525. 			uarmg->bknown = TRUE;
1526. 		    You("cannot remove your gloves to put on the ring.");
1527. 			return(0);
1528. 		}
1529. 		if (welded(uwep) && bimanual(uwep)) {
1530. 			/* welded will set bknown */
1531. 	    You("cannot free your weapon hands to put on the ring.");
1532. 			return(0);
1533. 		}
1534. 		if (welded(uwep) && mask==RIGHT_RING) {
1535. 			/* welded will set bknown */
1536. 	    You("cannot free your weapon hand to put on the ring.");
1537. 			return(0);
1538. 		}
1539. 		if (otmp->oartifact && !touch_artifact(otmp, &youmonst))
1540. 		    return 1; /* costs a turn even though it didn't get worn */
1541. 		setworn(otmp, mask);
1542. 		Ring_on(otmp);
1543. 	} else if (otmp->oclass == AMULET_CLASS) {
1544. 		if(uamul) {
1545. 			already_wearing("an amulet");
1546. 			return(0);
1547. 		}
1548. 		if (otmp->oartifact && !touch_artifact(otmp, &youmonst))
1549. 		    return 1;
1550. 		setworn(otmp, W_AMUL);
1551. 		if (otmp->otyp == AMULET_OF_CHANGE) {
1552. 			Amulet_on();
1553. 			/* Don't do a prinv() since the amulet is now gone */
1554. 			return(1);
1555. 		}
1556. 		Amulet_on();
1557. 	} else {	/* it's a blindfold, towel, or lenses */
1558. 		if (ublindf) {
1559. 			if (ublindf->otyp == TOWEL)
1560. 				Your("%s is already covered by a towel.",
1561. 					body_part(FACE));
1562. 			else if (ublindf->otyp == BLINDFOLD) {
1563. 				if (otmp->otyp == LENSES)
1564. 					already_wearing2("lenses", "a blindfold");
1565. 				else
1566. 					already_wearing("a blindfold");
1567. 			} else if (ublindf->otyp == LENSES) {
1568. 				if (otmp->otyp == BLINDFOLD)
1569. 					already_wearing2("a blindfold", "some lenses");
1570. 				else
1571. 					already_wearing("some lenses");
1572. 			} else
1573. 				already_wearing(something); /* ??? */
1574. 			return(0);
1575. 		}
1576. 		if (otmp->otyp != BLINDFOLD && otmp->otyp != TOWEL && otmp->otyp != LENSES) {
1577. 			You_cant("wear that!");
1578. 			return(0);
1579. 		}
1580. 		if (otmp->oartifact && !touch_artifact(otmp, &youmonst))
1581. 		    return 1;
1582. 		Blindf_on(otmp);
1583. 		return(1);
1584. 	}
1585. 	if (is_worn(otmp))
1586. 	    prinv((char *)0, otmp, 0L);
1587. 	return(1);
1588. }
1589. 
1590. #endif /* OVLB */
1591. 

find_ac

1592. #ifdef OVL0
1593. 
1594. void
1595. find_ac()
1596. {
1597. 	int uac = mons[u.umonnum].ac;
1598. 
1599. 	if(uarm) uac -= ARM_BONUS(uarm);
1600. 	if(uarmc) uac -= ARM_BONUS(uarmc);
1601. 	if(uarmh) uac -= ARM_BONUS(uarmh);
1602. 	if(uarmf) uac -= ARM_BONUS(uarmf);
1603. 	if(uarms) uac -= ARM_BONUS(uarms);
1604. 	if(uarmg) uac -= ARM_BONUS(uarmg);
1605. #ifdef TOURIST
1606. 	if(uarmu) uac -= ARM_BONUS(uarmu);
1607. #endif
1608. 	if(uleft && uleft->otyp == RIN_PROTECTION) uac -= uleft->spe;
1609. 	if(uright && uright->otyp == RIN_PROTECTION) uac -= uright->spe;
1610. 	if (HProtection & INTRINSIC) uac -= u.ublessed;
1611. 	uac -= u.uspellprot;
1612. 	if (uac < -128) uac = -128;	/* u.uac is an schar */
1613. 	if(uac != u.uac){
1614. 		u.uac = uac;
1615. 		flags.botl = 1;
1616. 	}
1617. }
1618. 
1619. #endif /* OVL0 */

glibr

1620. #ifdef OVLB
1621. 
1622. void
1623. glibr()
1624. {
1625. 	register struct obj *otmp;
1626. 	int xfl = 0;
1627. 	boolean leftfall, rightfall;
1628. 	const char *otherwep = 0;
1629. 
1630. 	leftfall = (uleft && !uleft->cursed &&
1631. 		    (!uwep || !welded(uwep) || !bimanual(uwep)));
1632. 	rightfall = (uright && !uright->cursed && (!welded(uwep)));
1633. 	if (!uarmg && (leftfall || rightfall) && !nolimbs(youmonst.data)) {
1634. 		/* changed so cursed rings don't fall off, GAN 10/30/86 */
1635. 		Your("%s off your %s.",
1636. 			(leftfall && rightfall) ? "rings slip" : "ring slips",
1637. 			(leftfall && rightfall) ? makeplural(body_part(FINGER)) :
1638. 			body_part(FINGER));
1639. 		xfl++;
1640. 		if (leftfall) {
1641. 			otmp = uleft;
1642. 			Ring_off(uleft);
1643. 			dropx(otmp);
1644. 		}
1645. 		if (rightfall) {
1646. 			otmp = uright;
1647. 			Ring_off(uright);
1648. 			dropx(otmp);
1649. 		}
1650. 	}
1651. 
1652. 	otmp = uswapwep;
1653. 	if (u.twoweap && otmp) {
1654. 		otherwep = is_sword(otmp) ? c_sword :
1655. 		    makesingular(oclass_names[(int)otmp->oclass]);
1656. 		Your("%s %sslips from your %s.",
1657. 			otherwep,
1658. 			xfl ? "also " : "",
1659. 			makeplural(body_part(HAND)));
1660. 		setuswapwep((struct obj *)0);
1661. 		xfl++;
1662. 		if (otmp->otyp != LOADSTONE || !otmp->cursed)
1663. 			dropx(otmp);
1664. 	}
1665. 	otmp = uwep;
1666. 	if (otmp && !welded(otmp)) {
1667. 		const char *thiswep;
1668. 
1669. 		/* nice wording if both weapons are the same type */
1670. 		thiswep = is_sword(otmp) ? c_sword :
1671. 		    makesingular(oclass_names[(int)otmp->oclass]);
1672. 		if (otherwep && strcmp(thiswep, otherwep)) otherwep = 0;
1673. 
1674. 		/* changed so cursed weapons don't fall, GAN 10/30/86 */
1675. 		Your("%s%s %sslips from your %s.",
1676. 			otherwep ? "other " : "", thiswep,
1677. 			xfl ? "also " : "",
1678. 			makeplural(body_part(HAND)));
1679. 		setuwep((struct obj *)0);
1680. 		if (otmp->otyp != LOADSTONE || !otmp->cursed)
1681. 			dropx(otmp);
1682. 	}
1683. }
1684. 

some_armor

1685. struct obj *
1686. some_armor(victim)
1687. struct monst *victim;
1688. {
1689. 	register struct obj *otmph, *otmp;
1690. 
1691. 	otmph = (victim == &youmonst) ? uarmc : which_armor(victim, W_ARMC);
1692. 	if (!otmph)
1693. 	    otmph = (victim == &youmonst) ? uarm : which_armor(victim, W_ARM);
1694. #ifdef TOURIST
1695. 	if (!otmph)
1696. 	    otmph = (victim == &youmonst) ? uarmu : which_armor(victim, W_ARMU);
1697. #endif
1698. 	
1699. 	otmp = (victim == &youmonst) ? uarmh : which_armor(victim, W_ARMH);
1700. 	if(otmp && (!otmph || !rn2(4))) otmph = otmp;
1701. 	otmp = (victim == &youmonst) ? uarmg : which_armor(victim, W_ARMG);
1702. 	if(otmp && (!otmph || !rn2(4))) otmph = otmp;
1703. 	otmp = (victim == &youmonst) ? uarmf : which_armor(victim, W_ARMF);
1704. 	if(otmp && (!otmph || !rn2(4))) otmph = otmp;
1705. 	otmp = (victim == &youmonst) ? uarms : which_armor(victim, W_ARMS);
1706. 	if(otmp && (!otmph || !rn2(4))) otmph = otmp;
1707. 	return(otmph);
1708. }
1709. 

erode_armor

1710. /* erode some arbitrary armor worn by the victim */
1711. void
1712. erode_armor(victim, acid_dmg)
1713. struct monst *victim;
1714. boolean acid_dmg;
1715. {
1716. 	struct obj *otmph = some_armor(victim);
1717. 
1718. 	if (otmph && (otmph != uarmf)) {
1719. 	    erode_obj(otmph, acid_dmg, FALSE);
1720. 	    if (carried(otmph)) update_inventory();
1721. 	}
1722. }
1723. 

stuck_ring

1724. /* used for praying to check and fix levitation trouble */
1725. struct obj *
1726. stuck_ring(ring, otyp)
1727. struct obj *ring;
1728. int otyp;
1729. {
1730.     if (ring != uleft && ring != uright) {
1731. 	impossible("stuck_ring: neither left nor right?");
1732. 	return (struct obj *)0;
1733.     }
1734. 
1735.     if (ring && ring->otyp == otyp) {
1736. 	/* reasons ring can't be removed match those checked by select_off();
1737. 	   limbless case has extra checks because ordinarily it's temporary */
1738. 	if (nolimbs(youmonst.data) &&
1739. 		uamul && uamul->otyp == AMULET_OF_UNCHANGING && uamul->cursed)
1740. 	    return uamul;
1741. 	if (welded(uwep) && (ring == uright || bimanual(uwep))) return uwep;
1742. 	if (uarmg && uarmg->cursed) return uarmg;
1743. 	if (ring->cursed) return ring;
1744.     }
1745.     /* either no ring or not right type or nothing prevents its removal */
1746.     return (struct obj *)0;
1747. }
1748. 

unchanger

1749. /* also for praying; find worn item that confers "Unchanging" attribute */
1750. struct obj *
1751. unchanger()
1752. {
1753.     if (uamul && uamul->otyp == AMULET_OF_UNCHANGING) return uamul;
1754.     return 0;
1755. }
1756. 

select_off

1757. /* occupation callback for 'A' */
1758. STATIC_PTR
1759. int
1760. select_off(otmp)
1761. register struct obj *otmp;
1762. {
1763. 	struct obj *why;
1764. 	char buf[BUFSZ];
1765. 
1766. 	if (!otmp) return 0;
1767. 	*buf = '\0';			/* lint suppresion */
1768. 
1769. 	/* special ring checks */
1770. 	if (otmp == uright || otmp == uleft) {
1771. 	    if (nolimbs(youmonst.data)) {
1772. 		pline_The("ring is stuck.");
1773. 		return 0;
1774. 	    }
1775. 	    why = 0;	/* the item which prevents ring removal */
1776. 	    if (welded(uwep) && (otmp == uright || bimanual(uwep))) {
1777. 		Sprintf(buf, "free a weapon %s", body_part(HAND));
1778. 		why = uwep;
1779. 	    } else if (uarmg && uarmg->cursed) {
1780. 		Sprintf(buf, "take off your %s", c_gloves);
1781. 		why = uarmg;
1782. 	    }
1783. 	    if (why) {
1784. 		You("cannot %s to remove the ring.", buf);
1785. 		why->bknown = TRUE;
1786. 		return 0;
1787. 	    }
1788. 	}
1789. 	/* special glove checks */
1790. 	if (otmp == uarmg) {
1791. 	    if (welded(uwep)) {
1792. 		You("are unable to take off your %s while wielding that %s.",
1793. 		    c_gloves, is_sword(uwep) ? c_sword : c_weapon);
1794. 		uwep->bknown = TRUE;
1795. 		return 0;
1796. 	    } else if (Glib) {
1797. 		You_cant("take off the slippery %s with your slippery %s.",
1798. 			 c_gloves, makeplural(body_part(FINGER)));
1799. 		return 0;
1800. 	    }
1801. 	}
1802. 	/* special boot checks */
1803. 	if (otmp == uarmf) {
1804. 	    if (u.utrap && u.utraptype == TT_BEARTRAP) {
1805. 		pline_The("bear trap prevents you from pulling your %s out.",
1806. 			  body_part(FOOT));
1807. 		return 0;
1808. 	    } else if (u.utrap && u.utraptype == TT_INFLOOR) {
1809. 		You("are stuck in the %s, and cannot pull your %s out.",
1810. 		    surface(u.ux, u.uy), makeplural(body_part(FOOT)));
1811. 		return 0;
1812. 	    }
1813. 	}
1814. 	/* special suit and shirt checks */
1815. 	if (otmp == uarm
1816. #ifdef TOURIST
1817. 			|| otmp == uarmu
1818. #endif
1819. 		) {
1820. 	    why = 0;	/* the item which prevents disrobing */
1821. 	    if (uarmc && uarmc->cursed) {
1822. 		Sprintf(buf, "remove your %s", cloak_simple_name(uarmc));
1823. 		why = uarmc;
1824. #ifdef TOURIST
1825. 	    } else if (otmp == uarmu && uarm && uarm->cursed) {
1826. 		Sprintf(buf, "remove your %s", c_suit);
1827. 		why = uarm;
1828. #endif
1829. 	    } else if (welded(uwep) && bimanual(uwep)) {
1830. 		Sprintf(buf, "release your %s",
1831. 			is_sword(uwep) ? c_sword :
1832. 			(uwep->otyp == BATTLE_AXE) ? c_axe : c_weapon);
1833. 		why = uwep;
1834. 	    }
1835. 	    if (why) {
1836. 		You("cannot %s to take off %s.", buf, the(xname(otmp)));
1837. 		why->bknown = TRUE;
1838. 		return 0;
1839. 	    }
1840. 	}
1841. 	/* basic curse check */
1842. 	if (otmp == uquiver || (otmp == uswapwep && !u.twoweap)) {
1843. 	    ;	/* some items can be removed even when cursed */
1844. 	} else {
1845. 	    /* otherwise, this is fundamental */
1846. 	    if (cursed(otmp)) return 0;
1847. 	}
1848. 
1849. 	if(otmp == uarm) takeoff_mask |= WORN_ARMOR;
1850. 	else if(otmp == uarmc) takeoff_mask |= WORN_CLOAK;
1851. 	else if(otmp == uarmf) takeoff_mask |= WORN_BOOTS;
1852. 	else if(otmp == uarmg) takeoff_mask |= WORN_GLOVES;
1853. 	else if(otmp == uarmh) takeoff_mask |= WORN_HELMET;
1854. 	else if(otmp == uarms) takeoff_mask |= WORN_SHIELD;
1855. #ifdef TOURIST
1856. 	else if(otmp == uarmu) takeoff_mask |= WORN_SHIRT;
1857. #endif
1858. 	else if(otmp == uleft) takeoff_mask |= LEFT_RING;
1859. 	else if(otmp == uright) takeoff_mask |= RIGHT_RING;
1860. 	else if(otmp == uamul) takeoff_mask |= WORN_AMUL;
1861. 	else if(otmp == ublindf) takeoff_mask |= WORN_BLINDF;
1862. 	else if(otmp == uwep) takeoff_mask |= W_WEP;
1863. 	else if(otmp == uswapwep) takeoff_mask |= W_SWAPWEP;
1864. 	else if(otmp == uquiver) takeoff_mask |= W_QUIVER;
1865. 
1866. 	else impossible("select_off: %s???", doname(otmp));
1867. 
1868. 	return(0);
1869. }
1870. 

do_takeoff

1871. STATIC_OVL struct obj *
1872. do_takeoff()
1873. {
1874. 	register struct obj *otmp = (struct obj *)0;
1875. 
1876. 	if (taking_off == W_WEP) {
1877. 	  if(!cursed(uwep)) {
1878. 	    setuwep((struct obj *) 0);
1879. 	    You("are empty %s.", body_part(HANDED));
1880. 	    u.twoweap = FALSE;
1881. 	  }
1882. 	} else if (taking_off == W_SWAPWEP) {
1883. 	  setuswapwep((struct obj *) 0);
1884. 	  You("no longer have a second weapon readied.");
1885. 	  u.twoweap = FALSE;
1886. 	} else if (taking_off == W_QUIVER) {
1887. 	  setuqwep((struct obj *) 0);
1888. 	  You("no longer have ammunition readied.");
1889. 	} else if (taking_off == WORN_ARMOR) {
1890. 	  otmp = uarm;
1891. 	  if(!cursed(otmp)) (void) Armor_off();
1892. 	} else if (taking_off == WORN_CLOAK) {
1893. 	  otmp = uarmc;
1894. 	  if(!cursed(otmp)) (void) Cloak_off();
1895. 	} else if (taking_off == WORN_BOOTS) {
1896. 	  otmp = uarmf;
1897. 	  if(!cursed(otmp)) (void) Boots_off();
1898. 	} else if (taking_off == WORN_GLOVES) {
1899. 	  otmp = uarmg;
1900. 	  if(!cursed(otmp)) (void) Gloves_off();
1901. 	} else if (taking_off == WORN_HELMET) {
1902. 	  otmp = uarmh;
1903. 	  if(!cursed(otmp)) (void) Helmet_off();
1904. 	} else if (taking_off == WORN_SHIELD) {
1905. 	  otmp = uarms;
1906. 	  if(!cursed(otmp)) (void) Shield_off();
1907. #ifdef TOURIST
1908. 	} else if (taking_off == WORN_SHIRT) {
1909. 	  otmp = uarmu;
1910. 	  if (!cursed(otmp)) (void) Shirt_off();
1911. #endif
1912. 	} else if (taking_off == WORN_AMUL) {
1913. 	  otmp = uamul;
1914. 	  if(!cursed(otmp)) Amulet_off();
1915. 	} else if (taking_off == LEFT_RING) {
1916. 	  otmp = uleft;
1917. 	  if(!cursed(otmp)) Ring_off(uleft);
1918. 	} else if (taking_off == RIGHT_RING) {
1919. 	  otmp = uright;
1920. 	  if(!cursed(otmp)) Ring_off(uright);
1921. 	} else if (taking_off == WORN_BLINDF) {
1922. 	  if (!cursed(ublindf)) Blindf_off(ublindf);
1923. 	} else impossible("do_takeoff: taking off %lx", taking_off);
1924. 
1925. 	return(otmp);
1926. }
1927. 

take_off

1928. static const char *disrobing = "";
1929. 
1930. STATIC_PTR
1931. int
1932. take_off()
1933. {
1934. 	register int i;
1935. 	register struct obj *otmp;
1936. 
1937. 	if (taking_off) {
1938. 	    if (todelay > 0) {
1939. 		todelay--;
1940. 		return(1);	/* still busy */
1941. 	    } else {
1942. 		if ((otmp = do_takeoff())) off_msg(otmp);
1943. 	    }
1944. 	    takeoff_mask &= ~taking_off;
1945. 	    taking_off = 0L;
1946. 	}
1947. 
1948. 	for(i = 0; takeoff_order[i]; i++)
1949. 	    if(takeoff_mask & takeoff_order[i]) {
1950. 		taking_off = takeoff_order[i];
1951. 		break;
1952. 	    }
1953. 
1954. 	otmp = (struct obj *) 0;
1955. 	todelay = 0;
1956. 
1957. 	if (taking_off == 0L) {
1958. 	  You("finish %s.", disrobing);
1959. 	  return 0;
1960. 	} else if (taking_off == W_WEP) {
1961. 	  todelay = 1;
1962. 	} else if (taking_off == W_SWAPWEP) {
1963. 	  todelay = 1;
1964. 	} else if (taking_off == W_QUIVER) {
1965. 	  todelay = 1;
1966. 	} else if (taking_off == WORN_ARMOR) {
1967. 	  otmp = uarm;
1968. 	  /* If a cloak is being worn, add the time to take it off and put
1969. 	   * it back on again.  Kludge alert! since that time is 0 for all
1970. 	   * known cloaks, add 1 so that it actually matters...
1971. 	   */
1972. 	  if (uarmc) todelay += 2 * objects[uarmc->otyp].oc_delay + 1;
1973. 	} else if (taking_off == WORN_CLOAK) {
1974. 	  otmp = uarmc;
1975. 	} else if (taking_off == WORN_BOOTS) {
1976. 	  otmp = uarmf;
1977. 	} else if (taking_off == WORN_GLOVES) {
1978. 	  otmp = uarmg;
1979. 	} else if (taking_off == WORN_HELMET) {
1980. 	  otmp = uarmh;
1981. 	} else if (taking_off == WORN_SHIELD) {
1982. 	  otmp = uarms;
1983. #ifdef TOURIST
1984. 	} else if (taking_off == WORN_SHIRT) {
1985. 	  otmp = uarmu;
1986. 	  /* add the time to take off and put back on armor and/or cloak */
1987. 	  if (uarm)  todelay += 2 * objects[uarm->otyp].oc_delay;
1988. 	  if (uarmc) todelay += 2 * objects[uarmc->otyp].oc_delay + 1;
1989. #endif
1990. 	} else if (taking_off == WORN_AMUL) {
1991. 	  todelay = 1;
1992. 	} else if (taking_off == LEFT_RING) {
1993. 	  todelay = 1;
1994. 	} else if (taking_off == RIGHT_RING) {
1995. 	  todelay = 1;
1996. 	} else if (taking_off == WORN_BLINDF) {
1997. 	  todelay = 2;
1998. 	} else {
1999. 	  impossible("take_off: taking off %lx", taking_off);
2000. 	  return 0;	/* force done */
2001. 	}
2002. 
2003. 	if (otmp) todelay += objects[otmp->otyp].oc_delay;
2004. 
2005. 	/* Since setting the occupation now starts the counter next move, that
2006. 	 * would always produce a delay 1 too big per item unless we subtract
2007. 	 * 1 here to account for it.
2008. 	 */
2009. 	if (todelay > 0) todelay--;
2010. 
2011. 	set_occupation(take_off, disrobing, 0);
2012. 	return(1);		/* get busy */
2013. }
2014. 

reset_remarm

2015. /* clear saved context to avoid inappropriate resumption of interrupted 'A' */
2016. void
2017. reset_remarm()
2018. {
2019. 	taking_off = takeoff_mask = 0L;
2020. 	disrobing = nul;
2021. }
2022. 

doddoremarm

2023. /* the 'A' command -- remove multiple worn items */
2024. int
2025. doddoremarm()
2026. {
2027.     int result = 0;
2028. 
2029.     if (taking_off || takeoff_mask) {
2030. 	You("continue %s.", disrobing);
2031. 	set_occupation(take_off, disrobing, 0);
2032. 	return 0;
2033.     } else if (!uwep && !uswapwep && !uquiver && !uamul && !ublindf &&
2034. 		!uleft && !uright && !wearing_armor()) {
2035. 	You("are not wearing anything.");
2036. 	return 0;
2037.     }
2038. 
2039.     add_valid_menu_class(0); /* reset */
2040.     if (flags.menu_style != MENU_TRADITIONAL ||
2041. 	    (result = ggetobj("take off", select_off, 0, FALSE, (unsigned *)0)) < -1)
2042. 	result = menu_remarm(result);
2043. 
2044.     if (takeoff_mask) {
2045. 	/* default activity for armor and/or accessories,
2046. 	   possibly combined with weapons */
2047. 	disrobing = "disrobing";
2048. 	/* specific activity when handling weapons only */
2049. 	if (!(takeoff_mask & ~(W_WEP|W_SWAPWEP|W_QUIVER)))
2050. 	    disrobing = "disarming";
2051. 	(void) take_off();
2052.     }
2053.     /* The time to perform the command is already completely accounted for
2054.      * in take_off(); if we return 1, that would add an extra turn to each
2055.      * disrobe.
2056.      */
2057.     return 0;
2058. }
2059. 

= menu_remarm

2060. STATIC_OVL int
2061. menu_remarm(retry)
2062. int retry;
2063. {
2064.     int n, i = 0;
2065.     menu_item *pick_list;
2066.     boolean all_worn_categories = TRUE;
2067. 
2068.     if (retry) {
2069. 	all_worn_categories = (retry == -2);
2070.     } else if (flags.menu_style == MENU_FULL) {
2071. 	all_worn_categories = FALSE;
2072. 	n = query_category("What type of things do you want to take off?",
2073. 			   invent, WORN_TYPES|ALL_TYPES, &pick_list, PICK_ANY);
2074. 	if (!n) return 0;
2075. 	for (i = 0; i < n; i++) {
2076. 	    if (pick_list[i].item.a_int == ALL_TYPES_SELECTED)
2077. 		all_worn_categories = TRUE;
2078. 	    else
2079. 		add_valid_menu_class(pick_list[i].item.a_int);
2080. 	}
2081. 	free((genericptr_t) pick_list);
2082.     } else if (flags.menu_style == MENU_COMBINATION) {
2083. 	all_worn_categories = FALSE;
2084. 	if (ggetobj("take off", select_off, 0, TRUE, (unsigned *)0) == -2)
2085. 	    all_worn_categories = TRUE;
2086.     }
2087. 
2088.     n = query_objlist("What do you want to take off?", invent,
2089. 			SIGNAL_NOMENU|USE_INVLET|INVORDER_SORT,
2090. 			&pick_list, PICK_ANY,
2091. 			all_worn_categories ? is_worn : is_worn_by_type);
2092.     if (n > 0) {
2093. 	for (i = 0; i < n; i++)
2094. 	    (void) select_off(pick_list[i].item.a_obj);
2095. 	free((genericptr_t) pick_list);
2096.     } else if (n < 0 && flags.menu_style != MENU_COMBINATION) {
2097. 	There("is nothing else you can remove or unwield.");
2098.     }
2099.     return 0;
2100. }
2101. 

destroy_arm

2102. /* hit by destroy armor scroll/black dragon breath/monster spell */
2103. int
2104. destroy_arm(atmp)
2105. register struct obj *atmp;
2106. {
2107. 	register struct obj *otmp;
2108. #define DESTROY_ARM(o) ((otmp = (o)) != 0 && \
2109. 			(!atmp || atmp == otmp) && \
2110. 			(!obj_resists(otmp, 0, 90)))
2111. 
2112. 	if (DESTROY_ARM(uarmc)) {
2113. 		if (donning(otmp)) cancel_don();
2114. 		Your("%s crumbles and turns to dust!",
2115. 		     cloak_simple_name(uarmc));
2116. 		(void) Cloak_off();
2117. 		useup(otmp);
2118. 	} else if (DESTROY_ARM(uarm)) {
2119. 		if (donning(otmp)) cancel_don();
2120. 		Your("armor turns to dust and falls to the %s!",
2121. 			surface(u.ux,u.uy));
2122. 		(void) Armor_gone();
2123. 		useup(otmp);
2124. #ifdef TOURIST
2125. 	} else if (DESTROY_ARM(uarmu)) {
2126. 		if (donning(otmp)) cancel_don();
2127. 		Your("shirt crumbles into tiny threads and falls apart!");
2128. 		(void) Shirt_off();
2129. 		useup(otmp);
2130. #endif
2131. 	} else if (DESTROY_ARM(uarmh)) {
2132. 		if (donning(otmp)) cancel_don();
2133. 		Your("helmet turns to dust and is blown away!");
2134. 		(void) Helmet_off();
2135. 		useup(otmp);
2136. 	} else if (DESTROY_ARM(uarmg)) {
2137. 		if (donning(otmp)) cancel_don();
2138. 		Your("gloves vanish!");
2139. 		(void) Gloves_off();
2140. 		useup(otmp);
2141. 		selftouch("You");
2142. 	} else if (DESTROY_ARM(uarmf)) {
2143. 		if (donning(otmp)) cancel_don();
2144. 		Your("boots disintegrate!");
2145. 		(void) Boots_off();
2146. 		useup(otmp);
2147. 	} else if (DESTROY_ARM(uarms)) {
2148. 		if (donning(otmp)) cancel_don();
2149. 		Your("shield crumbles away!");
2150. 		(void) Shield_off();
2151. 		useup(otmp);
2152. 	} else {
2153. 		return 0;		/* could not destroy anything */
2154. 	}
2155. 
2156. #undef DESTROY_ARM
2157. 	stop_occupation();
2158. 	return(1);
2159. }
2160. 

adj_abon

2161. void
2162. adj_abon(otmp, delta)
2163. register struct obj *otmp;
2164. register schar delta;
2165. {
2166. 	if (uarmg && uarmg == otmp && otmp->otyp == GAUNTLETS_OF_DEXTERITY) {
2167. 		if (delta) {
2168. 			makeknown(uarmg->otyp);
2169. 			ABON(A_DEX) += (delta);
2170. 		}
2171. 		flags.botl = 1;
2172. 	}
2173. 	if (uarmh && uarmh == otmp && otmp->otyp == HELM_OF_BRILLIANCE) {
2174. 		if (delta) {
2175. 			makeknown(uarmh->otyp);
2176. 			ABON(A_INT) += (delta);
2177. 			ABON(A_WIS) += (delta);
2178. 		}
2179. 		flags.botl = 1;
2180. 	}
2181. }
2182. 
2183. #endif /* OVLB */
2184. 
2185. /*do_wear.c*/