home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / nethack-3.1 / src / apply.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-01-19  |  51.4 KB  |  2,111 lines
  1. /*    SCCS Id: @(#)apply.c    3.1    92/12/10          */
  2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  3. /* NetHack may be freely redistributed.  See license for details. */
  4.  
  5. #include "hack.h"
  6. #include "edog.h"
  7.  
  8. #ifdef OVLB
  9.  
  10. static const char NEARDATA tools[] = { TOOL_CLASS, 0 };
  11.  
  12. static boolean NEARDATA did_dig_msg;
  13.  
  14. #ifdef TOURIST
  15. static int FDECL(use_camera, (struct obj *));
  16. #endif
  17. static int FDECL(use_towel, (struct obj *));
  18. static void FDECL(use_stethoscope, (struct obj *));
  19. static void FDECL(use_whistle, (struct obj *));
  20. static void FDECL(use_magic_whistle, (struct obj *));
  21. #ifdef WALKIES
  22. static void FDECL(use_leash, (struct obj *));
  23. #endif
  24. STATIC_DCL int NDECL(dig);
  25. #ifdef OVLB
  26. STATIC_DCL schar FDECL(fillholetyp, (int, int));
  27. #endif
  28. static boolean FDECL(wield_tool, (struct obj *));
  29. static int FDECL(use_pick_axe, (struct obj *));
  30. static int FDECL(use_mirror, (struct obj *));
  31. static void FDECL(use_bell, (struct obj *));
  32. static void FDECL(use_candelabrum, (struct obj *));
  33. static void FDECL(use_candle, (struct obj *));
  34. static void FDECL(use_lamp, (struct obj *));
  35. static void FDECL(use_tinning_kit, (struct obj *));
  36. static void FDECL(use_figurine, (struct obj *));
  37. static void FDECL(use_grease, (struct obj *));
  38. static boolean NDECL(rm_waslit);
  39. static void FDECL(mkcavepos, (XCHAR_P,XCHAR_P,int,BOOLEAN_P,BOOLEAN_P));
  40. static void FDECL(mkcavearea, (BOOLEAN_P));
  41.  
  42. #ifdef TOURIST
  43. static int
  44. use_camera(obj)
  45.     struct obj *obj;
  46. {
  47.     register struct monst *mtmp;
  48.  
  49.     if(Underwater) {
  50.         pline("Using your camera underwater voids the warranty.");
  51.         return(0);
  52.     }
  53.     if(!getdir(NULL)) return(0);
  54.     if(u.uswallow) {
  55.         You("take a picture of %s's %s.", mon_nam(u.ustuck),
  56.             is_animal(u.ustuck->data) ? "stomach" : "interior");
  57.     } else if(obj->cursed && !rn2(2)) goto blindu;
  58.     else if(u.dz) {
  59.         You("take a picture of the %s.",
  60.             (u.dz > 0) ? "floor" : "ceiling");
  61.     } else if(!u.dx && !u.dy) {
  62. blindu:
  63.         if(!Blind) {
  64.             You("are blinded by the flash!");
  65.             make_blinded((long)rnd(25),FALSE);
  66.         }
  67.     } else if(mtmp = bhit(u.dx,u.dy,COLNO,FLASHED_LIGHT,
  68.                         (int(*)())0,(int(*)())0,obj)) {
  69.         if(mtmp->msleep) {
  70.             mtmp->msleep = 0;
  71.             if(cansee(mtmp->mx,mtmp->my))
  72.             pline("The flash awakens %s.", mon_nam(mtmp)); /* a3 */
  73.         } else if (mtmp->data->mlet != S_LIGHT)
  74.             if((mtmp->mcansee && haseyes(mtmp->data))
  75.                || mtmp->mblinded) {
  76.             register int tmp = distu(mtmp->mx,mtmp->my);
  77.             register int tmp2;
  78.  
  79.             if(cansee(mtmp->mx,mtmp->my))
  80.                 pline("%s is blinded by the flash!", Monnam(mtmp));
  81.             if(mtmp->data == &mons[PM_GREMLIN]) {
  82.                 /* Rule #1: Keep them out of the light. */
  83.                 pline("%s cries out in pain!", Monnam(mtmp));
  84.                 if (mtmp->mhp > 1) mtmp->mhp--;
  85.             }
  86.             setmangry(mtmp);
  87.             if(tmp < 9 && !mtmp->isshk && rn2(4)) {
  88.                 mtmp->mflee = 1;
  89.                 if(rn2(4)) mtmp->mfleetim = rnd(100);
  90.             }
  91.             mtmp->mcansee = 0;
  92.             if(tmp < 3) {
  93.                 mtmp->mblinded = 0;
  94.             } else {
  95.                 tmp2 = mtmp->mblinded;
  96.                 tmp2 += rnd(1 + 50/tmp);
  97.                 if(tmp2 > 127) tmp2 = 127;
  98.                 mtmp->mblinded = tmp2;
  99.             }
  100.             }
  101.     }
  102.     return 1;
  103. }
  104. #endif
  105.  
  106. static int
  107. use_towel(obj)
  108.     struct obj *obj;
  109. {
  110.     if(!freehand()) {
  111.         You("have no free %s!", body_part(HAND));
  112.         return 0;
  113.     } else if (obj->owornmask) {
  114.         You("can't use it while you're wearing it!");
  115.         return 0;
  116.     } else if (obj->cursed) {
  117.         long old;
  118.         switch (rn2(3)) {
  119.         case 2:
  120.             old = Glib;
  121.             Glib += rn1(10, 3);
  122.             Your("%s are %s!", makeplural(body_part(HAND)),
  123.             (old ? "filthier than ever" : "now slimy"));
  124.             return 1;
  125.         case 1:
  126.             if (!Blindfolded) {
  127.             old = u.ucreamed;
  128.             u.ucreamed += rn1(10, 3);
  129.             pline("Yecch! Your %s %s gunk on it!", body_part(FACE),
  130.                   (old ? "has more" : "now has"));
  131.             make_blinded(Blinded + (long)u.ucreamed - old, TRUE);
  132.             } else {
  133.             if (ublindf->cursed) {
  134.                 You("pushed your blindfold %s.",
  135.                 rn2(2) ? "cock-eyed" : "crooked");
  136.             } else {
  137.                 You("pushed your blindfold off.");
  138.                 Blindf_off(ublindf);
  139.                 dropx(ublindf);
  140.             }
  141.             }
  142.             return 1;
  143.         case 0:
  144.             break;
  145.         }
  146.     }
  147.  
  148.     if (Glib) {
  149.         Glib = 0;
  150.         You("wipe off your %s.", makeplural(body_part(HAND)));
  151.         return 1;
  152.     } else if(u.ucreamed) {
  153.         Blinded -= u.ucreamed;
  154.         u.ucreamed = 0;
  155.  
  156.         if (!Blinded) {
  157.             pline("You've got the glop off.");
  158.             Blinded = 1;
  159.             make_blinded(0L,TRUE);
  160.         } else {
  161.             Your("%s feels clean now.", body_part(FACE));
  162.         }
  163.         return 1;
  164.     }
  165.  
  166.     Your("%s and %s are already clean.", 
  167.         body_part(FACE), makeplural(body_part(HAND)));
  168.  
  169.     return 0;
  170. }
  171.  
  172. static char hollow_str[] = "hear a hollow sound!  This must be a secret %s!";
  173.  
  174. /* Strictly speaking it makes no sense for usage of a stethoscope to
  175.    not take any time; however, unless it did, the stethoscope would be
  176.    almost useless. */
  177. static void
  178. use_stethoscope(obj)
  179.     register struct obj *obj;
  180. {
  181.     register struct monst *mtmp;
  182.     register struct rm *lev;
  183.     register int rx, ry;
  184.  
  185.     if(!freehand()) {
  186.         You("have no free %s!", body_part(HAND));
  187.         return;
  188.     }
  189.     if (!getdir(NULL)) return;
  190.     if (u.uswallow && (u.dx || u.dy || u.dz)) {
  191.         mstatusline(u.ustuck);
  192.         return;
  193.     } else if (u.dz) {
  194.         if (Underwater)
  195.             You("hear faint splashing.");
  196.         else if (u.dz < 0 || Levitation)
  197.             You("can't reach the %s!", u.dz<0 ? "ceiling" : "floor");
  198.         else if (Is_stronghold(&u.uz))
  199.             You("hear the crackling of hellfire.");
  200.         else
  201.             pline("The floor seems healthy enough.");
  202.         return;
  203.     } else if (obj->cursed && !rn2(2)) {
  204.         You("hear your heart beat.");
  205.         return;
  206.     }
  207.     if (Stunned || (Confusion && !rn2(5))) confdir();
  208.     if (!u.dx && !u.dy) {
  209.         ustatusline();
  210.         return;
  211.     }
  212.     rx = u.ux + u.dx; ry = u.uy + u.dy;
  213.     if (!isok(rx,ry)) {
  214.         You("hear a faint typing noise.");
  215.         return;
  216.     }
  217.     if(mtmp = m_at(rx,ry)) {
  218.         mstatusline(mtmp);
  219.         if (mtmp->mundetected) {
  220.             mtmp->mundetected = 0;
  221.             if (cansee(rx,ry)) newsym(mtmp->my,mtmp->my);
  222.         }
  223.         return;
  224.     }
  225.     lev = &levl[rx][ry];
  226.     switch(lev->typ) {
  227.     case SDOOR:
  228.         You(hollow_str, "door");
  229.         lev->typ = DOOR;
  230.         newsym(rx,ry);
  231.         return;
  232.     case SCORR:
  233.         You(hollow_str, "passage");
  234.         lev->typ = CORR;
  235.         newsym(rx,ry);
  236.         return;
  237.     }
  238.     You("hear nothing special.");
  239. }
  240.  
  241. static char whistle_str[] = "produce a %s whistling sound.";
  242.  
  243. /*ARGSUSED*/
  244. static void
  245. use_whistle(obj)
  246. struct obj *obj;
  247. {
  248.     You(whistle_str, "high");
  249.     wake_nearby();
  250. }
  251.  
  252. static void
  253. use_magic_whistle(obj)
  254. struct obj *obj;
  255. {
  256.     register struct monst *mtmp;
  257.  
  258.     if(obj->cursed && !rn2(2)) {
  259.         You("produce a high-pitched humming noise.");
  260.         wake_nearby();
  261.     } else {
  262.         makeknown(MAGIC_WHISTLE);
  263.         You(whistle_str, Hallucination ? "normal" : "strange");
  264.         for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
  265.             if(mtmp->mtame) mnexto(mtmp);
  266.     }
  267. }
  268.  
  269. boolean
  270. um_dist(x,y,n)
  271. register xchar x, y, n;
  272. {
  273.     return(abs(u.ux - x) > n  || abs(u.uy - y) > n);
  274. }
  275.  
  276. #endif /* OVLB */
  277.  
  278. #ifdef WALKIES
  279. #define MAXLEASHED    2
  280.  
  281. #ifdef OVLB
  282.  
  283. int
  284. number_leashed()
  285. {
  286.     register int i = 0;
  287.     register struct obj *obj;
  288.  
  289.     for(obj = invent; obj; obj = obj->nobj)
  290.         if(obj->otyp == LEASH && obj->leashmon != 0) i++;
  291.     return(i);
  292. }
  293.  
  294. void
  295. o_unleash(otmp)     /* otmp is about to be destroyed or stolen */
  296. register struct obj *otmp;
  297. {
  298.     register struct monst *mtmp;
  299.  
  300.     for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
  301.         if(mtmp->m_id == (unsigned)otmp->leashmon)
  302.             mtmp->mleashed = 0;
  303.     otmp->leashmon = 0;
  304. }
  305.  
  306. void
  307. m_unleash(mtmp)     /* mtmp is about to die, or become untame */
  308. register struct monst *mtmp;
  309. {
  310.     register struct obj *otmp;
  311.  
  312.     for(otmp = invent; otmp; otmp = otmp->nobj)
  313.         if(otmp->otyp == LEASH &&
  314.                 otmp->leashmon == (int)mtmp->m_id)
  315.             otmp->leashmon = 0;
  316.     mtmp->mleashed = 0;
  317. }
  318.  
  319. void
  320. unleash_all()        /* player is about to die (for bones) */
  321. {
  322.     register struct obj *otmp;
  323.     register struct monst *mtmp;
  324.  
  325.     for(otmp = invent; otmp; otmp = otmp->nobj)
  326.         if(otmp->otyp == LEASH) otmp->leashmon = 0;
  327.     for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
  328.         if(mtmp->mtame) mtmp->mleashed = 0;
  329. }
  330.  
  331. /* ARGSUSED */
  332. static void
  333. use_leash(obj)
  334. struct obj *obj;
  335. {
  336.     register int x, y;
  337.     register struct monst *mtmp;
  338.     int spotmon;
  339.  
  340.     if(!obj->leashmon && number_leashed() >= MAXLEASHED) {
  341.         You("can't leash additional pets.");
  342.         return;
  343.     }
  344.  
  345.     if(!getdir(NULL)) return;
  346.  
  347.     x = u.ux + u.dx;
  348.     y = u.uy + u.dy;
  349.  
  350.     if((x == u.ux) && (y == u.uy)) {
  351.         pline("Leash yourself?  Very funny...");
  352.         return;
  353.     }
  354.  
  355.     if(!(mtmp = m_at(x, y))) {
  356.         pline("There is no creature here.");
  357.         return;
  358.     }
  359.  
  360.     spotmon = canseemon(mtmp) || sensemon(mtmp);
  361.  
  362.     if(!mtmp->mtame) {
  363.         if(!spotmon)
  364.         pline("There is no creature here.");
  365.         else
  366.         pline("%s is not %s!", Monnam(mtmp), (!obj->leashmon) ?
  367.                 "leashable" : "leashed");
  368.         return;
  369.     }
  370.     if(!obj->leashmon) {
  371.         if(mtmp->mleashed) {
  372.             pline("This %s is already leashed!",
  373.                   spotmon ? l_monnam(mtmp) : "monster");
  374.             return;
  375.         }
  376.         You("slip the leash around %s%s.",
  377.             spotmon ? "your " : "", l_monnam(mtmp));
  378.         mtmp->mleashed = 1;
  379.         obj->leashmon = (int)mtmp->m_id;
  380.         if(mtmp->msleep)  mtmp->msleep = 0;
  381.         return;
  382.     }
  383.     if(obj->leashmon != (int)mtmp->m_id) {
  384.         pline("This leash is not attached to that creature!");
  385.         return;
  386.     } else {
  387.         if(obj->cursed) {
  388.             pline("The leash wouldn't come off!");
  389.             return;
  390.         }
  391.         mtmp->mleashed = 0;
  392.         obj->leashmon = 0;
  393.         You("remove the leash from %s%s.",
  394.             spotmon ? "your " : "", l_monnam(mtmp));
  395.     }
  396.     return;
  397. }
  398.  
  399. #endif /* OVLB */
  400. #ifdef OVL1
  401.  
  402. boolean
  403. next_to_u()
  404. {
  405.     register struct monst *mtmp;
  406.     register struct obj *otmp;
  407.  
  408.     for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
  409.         if(mtmp->mleashed) {
  410.             if (distu(mtmp->mx,mtmp->my) > 2) mnexto(mtmp);
  411.             if (distu(mtmp->mx,mtmp->my) > 2) {
  412.                 for(otmp = invent; otmp; otmp = otmp->nobj)
  413.                 if(otmp->otyp == LEASH &&
  414.                     otmp->leashmon == (int)mtmp->m_id) {
  415.                     if(otmp->cursed) return(FALSE);
  416.                     You("feel %s leash go slack.",
  417.                     (number_leashed() > 1) ? "a" : "the");
  418.                     mtmp->mleashed = 0;
  419.                     otmp->leashmon = 0;
  420.                 }
  421.             }
  422.         }
  423.     return(TRUE);
  424. }
  425.  
  426. #endif /* OVL1 */
  427. #ifdef OVLB
  428. struct obj *
  429. get_mleash(mtmp)     /* assuming mtmp->mleashed has been checked */
  430. register struct monst *mtmp;
  431. {
  432.     register struct obj *otmp;
  433.  
  434.     otmp = invent;
  435.     while(otmp) {
  436.         if(otmp->otyp == LEASH && otmp->leashmon == (int)mtmp->m_id)
  437.             return(otmp);
  438.         otmp = otmp->nobj;
  439.     }
  440.     return((struct obj *)0);
  441. }
  442. #endif /* OVLB */
  443.  
  444. #endif /* WALKIES */
  445. #ifdef OVL0
  446.  
  447. #ifdef WALKIES
  448. void
  449. check_leash(x, y)
  450. register xchar x, y;
  451. {
  452.     register struct obj *otmp;
  453.     register struct monst *mtmp = fmon;
  454.  
  455.     for(otmp = invent; otmp; otmp = otmp->nobj)
  456.         if(otmp->otyp == LEASH && otmp->leashmon != 0) {
  457.         while(mtmp) {
  458.             if((int)mtmp->m_id == otmp->leashmon &&
  459.                 (dist2(u.ux,u.uy,mtmp->mx,mtmp->my) >
  460.                 dist2(x,y,mtmp->mx,mtmp->my))
  461.             ) {
  462.             if(otmp->cursed) {
  463.                 if(um_dist(mtmp->mx, mtmp->my, 5)) {
  464.                 pline("%s chokes to death!",Monnam(mtmp));
  465.                 mondied(mtmp);
  466.                 } else
  467.                 if(um_dist(mtmp->mx, mtmp->my, 3))
  468.                     pline("%s chokes on the leash!",
  469.                         Monnam(mtmp));
  470.             } else {
  471.                 if(um_dist(mtmp->mx, mtmp->my, 5)) {
  472.                 pline("%s's leash snaps loose!",Monnam(mtmp));
  473.                 m_unleash(mtmp);
  474.                 } else {
  475.                 if(um_dist(mtmp->mx, mtmp->my, 3)) {
  476.                     You("pull on the leash.");
  477. # ifdef SOUNDS
  478.                     if (mtmp->data->msound != MS_SILENT)
  479.                     switch(rn2(3)) {
  480.                     case 0:  growl(mtmp);    break;
  481.                     case 1:  yelp(mtmp);    break;
  482.                     default: whimper(mtmp); break;
  483.                     }
  484. # endif
  485.                 }
  486.                 }
  487.             }
  488.             }
  489.             mtmp = mtmp->nmon;
  490.         }
  491.         }
  492. }
  493.  
  494. #endif /* WALKIES */
  495.  
  496. #endif /* OVL0 */
  497. #ifdef OVLB
  498.  
  499. static boolean
  500. rm_waslit() {
  501.     register xchar x, y;
  502.  
  503.     if(levl[u.ux][u.uy].typ == ROOM && levl[u.ux][u.uy].waslit) 
  504.         return(TRUE);
  505.     for(x = u.ux-2; x < u.ux+3; x++)
  506.         for(y = u.uy-1; y < u.uy+2; y++)
  507.         if(isok(x,y) && levl[x][y].waslit) return(TRUE);
  508.     return(FALSE);
  509. }
  510.  
  511. /* Change level topology.  Messes with vision tables and ignores things like
  512.  * boulders in the name of a nice effect.  Vision will get fixed up again
  513.  * immediately after the effect is complete.
  514.  */
  515. static void
  516. mkcavepos(x, y, dist, waslit, rockit)
  517.     xchar x,y;
  518.     int dist;
  519.     boolean waslit, rockit;
  520. {
  521.     register struct rm *lev;
  522.  
  523.     if(!isok(x,y)) return;
  524.     lev = &levl[x][y];
  525.  
  526.     if(rockit) {
  527.         register struct monst *mtmp;
  528.  
  529.         if(IS_ROCK(lev->typ)) return;
  530.     if(t_at(x, y)) return; /* don't cover the portal */
  531.     if(mtmp = m_at(x, y)) /* make sure crucial monsters survive */
  532.         if(!passes_walls(mtmp->data)) rloc(mtmp);
  533.     } else if(lev->typ == ROOM) return;
  534.  
  535.     unblock_point(x,y);    /* make sure vision knows this location is open */
  536.  
  537.     /* fake out saved state */
  538.     lev->seen = FALSE;
  539.     lev->doormask = 0;
  540.     if(dist < 3) lev->lit = (rockit ? FALSE : TRUE);
  541.     if(waslit) lev->waslit = (rockit ? FALSE : TRUE);
  542.     lev->horizontal = FALSE;
  543.     viz_array[y][x] = (dist < 3 ) ?
  544.     (IN_SIGHT|COULD_SEE) : /* short-circuit vision recalc */
  545.     COULD_SEE;
  546.     lev->typ = (rockit ? STONE : ROOM);
  547.     if(dist >= 3)
  548.     impossible("mkcavepos called with dist %d", dist);
  549.     if(Blind)
  550.     feel_location(x, y);
  551.     else newsym(x,y);
  552. }
  553.  
  554. static void
  555. mkcavearea(rockit)
  556. register boolean rockit;
  557. {
  558.     int dist;
  559.     xchar xmin = u.ux, xmax = u.ux;
  560.     xchar ymin = u.uy, ymax = u.uy;
  561.     register xchar i;
  562.     register boolean waslit = rm_waslit();
  563.  
  564.     if(rockit) pline("Crash!  The ceiling collapses around you!");
  565.     else pline("A mysterious force %s cave around you!",
  566.          (levl[u.ux][u.uy].typ == CORR) ? "creates a" : "extends the");
  567.     display_nhwindow(WIN_MESSAGE, TRUE);
  568.  
  569.     for(dist = 1; dist <= 2; dist++) {
  570.     xmin--; xmax++;
  571.  
  572.     /* top and bottom */
  573.     if(dist < 2) { /* the area is wider that it is high */
  574.         ymin--; ymax++;
  575.         for(i = xmin+1; i < xmax; i++) {
  576.         mkcavepos(i, ymin, dist, waslit, rockit);
  577.         mkcavepos(i, ymax, dist, waslit, rockit);
  578.         }
  579.     }
  580.  
  581.     /* left and right */
  582.     for(i = ymin; i <= ymax; i++) {
  583.         mkcavepos(xmin, i, dist, waslit, rockit);
  584.         mkcavepos(xmax, i, dist, waslit, rockit);
  585.     }
  586.  
  587.     flush_screen(1);    /* make sure the new glyphs shows up */
  588.     delay_output();
  589.     }
  590.  
  591.     if(!rockit && levl[u.ux][u.uy].typ == CORR) {
  592.         levl[u.ux][u.uy].typ = ROOM;
  593.     if(waslit) levl[u.ux][u.uy].waslit = TRUE;
  594.     newsym(u.ux, u.uy); /* in case player is invisible */
  595.     }
  596.  
  597.     vision_full_recalc = 1;    /* everything changed */
  598. }
  599.  
  600. STATIC_OVL int
  601. dig()
  602. {
  603.     register struct rm *lev;
  604.     register xchar dpx = dig_pos.x, dpy = dig_pos.y;
  605.  
  606.     lev = &levl[dpx][dpy];
  607.     /* perhaps a nymph stole your pick-axe while you were busy digging */
  608.     /* or perhaps you teleported away */
  609.     if(u.uswallow || !uwep || uwep->otyp != PICK_AXE ||
  610.         !on_level(&dig_level, &u.uz) ||
  611.         ((dig_down && (dpx != u.ux || dpy != u.uy)) ||
  612.          (!dig_down && distu(dpx,dpy) > 2)))
  613.         return(0);
  614.     if (dig_down) {
  615.         if(On_stairs(u.ux, u.uy)) {
  616.         if(u.ux == xdnladder || u.ux == xupladder)
  617.              pline("The ladder resists your effort.");
  618.         else pline("The stairs here are too hard to dig in.");
  619.         return(0);
  620.         }
  621.         if(IS_THRONE(levl[u.ux][u.uy].typ)) {
  622.         pline("The throne here is too hard to break apart.");
  623.         return (0);
  624.         }
  625.         if(IS_ALTAR(levl[u.ux][u.uy].typ)) {
  626.         pline("The altar here is too hard to break apart.");
  627.         return (0);
  628.         }
  629.         if(t_at(dpx, dpy) && !Can_dig_down(&u.uz)) {
  630.         pline("The floor here is too hard to dig in.");
  631.         return(0);
  632.         }
  633.         if(sobj_at(BOULDER, dpx, dpy)) {
  634.         pline("There is not enough room here to dig.");
  635.         return(0);
  636.         }
  637.         if(Is_airlevel(&u.uz)) {
  638.         You("cannot dig in thin air.");
  639.         return(0);
  640.         }
  641.         if(Is_waterlevel(&u.uz)) {
  642.         pline("The water splashes and subsides.");
  643.         return(0);
  644.         }
  645.     } else /* !dig_down */
  646.         if(IS_ROCK(lev->typ) && !may_dig(dpx,dpy)) {
  647.         pline("This wall is too hard to dig into.");
  648.         return(0);
  649.         }
  650.     if(Fumbling && !rn2(3)) {
  651.         switch(rn2(3)) {
  652.         case 0:  if(!welded(uwep)) {
  653.                  You("fumble and drop your %s.", xname(uwep));
  654.                  dropx(uwep);
  655.                  setuwep((struct obj *)0);
  656.              } else {
  657.                  pline("Ouch!  Your %s bounces and hits you!",
  658.                 xname(uwep));
  659.                  set_wounded_legs(RIGHT_SIDE, 5 + rnd(5));
  660.              }
  661.              break;
  662.         case 1:  pline("Bang!  You hit with the broad side of %s!",
  663.                    the(xname(uwep)));
  664.              break;
  665.         default: Your("swing misses its mark."); 
  666.              break;
  667.         }
  668.         return(0);
  669.     }
  670.     dig_effort += 10 + abon() + uwep->spe - uwep->oeroded + rn2(5);
  671.     if(dig_down) {
  672.         register struct trap *ttmp;
  673.  
  674.         if(dig_effort > 250) {
  675.             dighole();
  676.             dig_level.dnum = 0;
  677.             dig_level.dlevel = -1;
  678.             return(0);    /* done with digging */
  679.         }
  680.  
  681.         if (dig_effort <= 50)
  682.             return(1);
  683.  
  684.         if ((ttmp = t_at(dpx,dpy)) &&
  685.             ((ttmp->ttyp == PIT) || (ttmp->ttyp == SPIKED_PIT) ||
  686.              (ttmp->ttyp == TRAPDOOR)))
  687.             return(1);
  688.  
  689.         if (IS_ALTAR(lev->typ)) {
  690.             altar_wrath(dpx, dpy);
  691.             angry_priest();
  692.         }
  693.  
  694.         ttmp = maketrap(dpx,dpy,PIT);
  695.         ttmp->tseen = 1;
  696.         if(Invisible) newsym(ttmp->tx,ttmp->ty);
  697.         You("have dug a pit.");
  698.         u.utrap = rn1(4,2);
  699.         u.utraptype = TT_PIT;
  700.         vision_full_recalc = 1;    /* vision limits change */
  701.         dig_level.dnum = 0;
  702.         dig_level.dlevel = -1;
  703.         return(0);
  704.     } 
  705.     if(dig_effort > 100) {
  706.         register const char *digtxt, *dmgtxt = (const char*) 0;
  707.         register struct obj *obj;
  708.         register boolean shopedge = *in_rooms(dpx, dpy, SHOPBASE);
  709.  
  710.         if(obj = sobj_at(STATUE, dpx, dpy)) {
  711.             if (break_statue(obj))
  712.                 digtxt = "The statue shatters.";
  713.             else
  714.                 /* it was a statue trap; break_statue()
  715.                  * printed a message and updated the screen
  716.                  */
  717.                 digtxt = NULL;
  718.         } else if(obj = sobj_at(BOULDER, dpx, dpy)) {
  719.             fracture_rock(obj);
  720.             digtxt = "The boulder falls apart.";
  721.         } else if(!lev->typ || lev->typ == SCORR) {
  722.                 if(Is_earthlevel(&u.uz)) {
  723.                 if(uwep->blessed && !rn2(3)) {
  724.                     mkcavearea(FALSE);
  725.                 goto cleanup;
  726.                 } else if((uwep->cursed && !rn2(4)) || 
  727.                           (!uwep->blessed && !rn2(6))) {
  728.                     mkcavearea(TRUE);
  729.                     goto cleanup;
  730.                 }
  731.             }
  732.             lev->typ = CORR;
  733.             digtxt = "You succeeded in cutting away some rock.";
  734.         } else if(IS_WALL(lev->typ)) {
  735.             if(shopedge) {
  736.                     add_damage(dpx, dpy, 10L * ACURRSTR);
  737.                 dmgtxt = "dig into";
  738.             }
  739.                 if (level.flags.is_maze_lev) {
  740.                 lev->typ = ROOM;
  741.                 } else if (level.flags.is_cavernous_lev) {
  742.                 lev->typ = CORR;
  743.             } else {
  744.                 lev->typ = DOOR;
  745.                 lev->doormask = D_NODOOR;
  746.             }
  747.             digtxt = "You just made an opening in the wall.";
  748.         } else if(lev->typ == SDOOR) {
  749.             lev->typ = DOOR;
  750.             digtxt = "You just broke through a secret door.";
  751.             if(!(lev->doormask & D_TRAPPED))
  752.                 lev->doormask = D_BROKEN;
  753.         } else if(closed_door(dpx, dpy)) {
  754.             digtxt = "You just broke a hole through the door.";
  755.             if(shopedge) {
  756.                     add_damage(dpx, dpy, 400L);
  757.                 dmgtxt = "break";
  758.             }
  759.             if(!(lev->doormask & D_TRAPPED))
  760.                 lev->doormask = D_BROKEN;
  761.         } else return(0); /* statue or boulder got taken */
  762.  
  763.         unblock_point(dpx,dpy);    /* vision:  can see through */
  764.         if(Blind)
  765.             feel_location(dpx, dpy);
  766.         else
  767.             newsym(dpx, dpy);
  768.         if(digtxt) pline(digtxt);    /* after newsym */
  769.         if(dmgtxt)
  770.             pay_for_damage(dmgtxt);
  771.  
  772.         if(Is_earthlevel(&u.uz) && !rn2(3)) {
  773.             register struct monst *mtmp;
  774.  
  775.             switch(rn2(2)) {
  776.               case 0: 
  777.                 mtmp = makemon(&mons[PM_EARTH_ELEMENTAL], dpx, dpy);
  778.             break;
  779.               default: 
  780.             mtmp = makemon(&mons[PM_XORN], dpx, dpy); 
  781.             break;
  782.             }
  783.             if(mtmp) pline("The debris of your dig comes alive!");
  784.         }
  785.         if(IS_DOOR(lev->typ) && (lev->doormask & D_TRAPPED)) {
  786.             b_trapped("door");
  787.             lev->doormask = D_NODOOR;
  788.             newsym(dpx, dpy);
  789.         }
  790. cleanup:
  791.         dig_level.dnum = 0;
  792.         dig_level.dlevel = -1;
  793.         return(0);
  794.     } else {
  795.         if(IS_WALL(lev->typ) || closed_door(dpx, dpy)) {
  796.             if(*in_rooms(dpx, dpy, SHOPBASE)) {
  797.             pline("This %s seems too hard to dig into.",
  798.                   IS_DOOR(lev->typ) ? "door" : "wall");
  799.             return(0);
  800.             }
  801.         } else if (!IS_ROCK(lev->typ) && !sobj_at(STATUE, dpx, dpy)
  802.                 && !sobj_at(BOULDER, dpx, dpy))
  803.             return(0); /* statue or boulder got taken */
  804.         if(!did_dig_msg) {
  805.             You("hit the %s with all your might.",
  806.             sobj_at(STATUE, dpx, dpy) ? "statue" :
  807.             sobj_at(BOULDER, dpx, dpy) ? "boulder" :
  808.             IS_DOOR(lev->typ) ? "door" : "rock");
  809.             did_dig_msg = TRUE;
  810.         }
  811.     }
  812.     return(1);
  813. }
  814.  
  815. /* When will hole be finished? Very rough indication used by shopkeeper. */
  816. int
  817. holetime() {
  818.     if(occupation != dig || !*u.ushops) return(-1);
  819.     return((250 - dig_effort)/20);
  820. }
  821.  
  822. /* Return typ of liquid to fill a hole with, or ROOM, if no liquid nearby */
  823. STATIC_OVL
  824. schar
  825. fillholetyp(x,y)
  826. int x, y;
  827. {
  828.     register int x1, y1;
  829.  
  830.     for(x1 = max(1,x-1); x1<=min(x+1,COLNO-1); x1++)
  831.     for(y1 = max(0,y-1); y1<=min(y+1,ROWNO-1); y1++)
  832.         if(levl[x1][y1].typ == MOAT || levl[x1][y1].typ == LAVAPOOL)
  833.         return levl[x1][y1].typ;
  834.  
  835.     return ROOM;
  836. }
  837.  
  838. void
  839. dighole()
  840. {
  841.     register struct trap *ttmp = t_at(u.ux, u.uy);
  842.     struct rm *lev = &levl[u.ux][u.uy];
  843.     struct obj *boulder_here;
  844.     boolean nohole = !Can_dig_down(&u.uz);
  845.  
  846.     if(ttmp && nohole) {
  847.         pline("The floor here seems too hard to dig in.");
  848.     } else {
  849.         d_level    newlevel;
  850.  
  851.         if (is_pool(u.ux, u.uy) || is_lava(u.ux, u.uy)) {
  852.             pline(
  853.                "The %s sloshes furiously for a moment, then subsides.",
  854.               is_lava(u.ux, u.uy) ? "lava" : "water");
  855.             return;
  856.         }
  857.         if (lev->typ == DRAWBRIDGE_DOWN) {
  858.             destroy_drawbridge(u.ux,u.uy);
  859.             return;
  860.         } else if (boulder_here = sobj_at(BOULDER, u.ux, u.uy)) {
  861.             if (ttmp && ((ttmp->ttyp == PIT) || 
  862.                       (ttmp->ttyp == SPIKED_PIT))) {
  863.                 pline("The boulder settles into the pit.");
  864.                 ttmp->ttyp = PIT;      /* crush spikes */
  865.             } else {
  866.                 /*
  867.                  * digging makes a hole, but the boulder
  868.                  * immediately fills it.  Final outcome:
  869.                  * no hole, no boulder.
  870.                  */
  871.                 pline("KADOOM! The boulder falls in!");
  872.  
  873.                 /* destroy traps that emanate from the floor */
  874.                 /* some of these are arbitrary -dlc */
  875.                 if (ttmp && ((ttmp->ttyp == SQKY_BOARD) ||
  876.                          (ttmp->ttyp == BEAR_TRAP) ||
  877.                          (ttmp->ttyp == LANDMINE) ||
  878.                          (ttmp->ttyp == FIRE_TRAP) ||
  879.                          (ttmp->ttyp == TRAPDOOR) ||
  880.                          (ttmp->ttyp == TELEP_TRAP) ||
  881.                          (ttmp->ttyp == LEVEL_TELEP) ||
  882.                          (ttmp->ttyp == WEB) ||
  883.                          (ttmp->ttyp == MAGIC_TRAP) ||
  884.                          (ttmp->ttyp == ANTI_MAGIC))) {
  885.                     deltrap(ttmp);
  886.                     u.utrap = 0;
  887.                     u.utraptype = 0;
  888.                 }
  889.             }
  890.             delobj(boulder_here);
  891.             return;
  892.         }
  893.         if (lev->typ == DRAWBRIDGE_UP) {
  894.             /* must be floor or ice, other cases handled above */
  895.             /* dig "pit" and let fluid flow in (if possible) */
  896.             schar typ = fillholetyp(u.ux,u.uy);
  897.  
  898.             if(typ == ROOM) {
  899.                 if(lev->drawbridgemask & DB_ICE)
  900.                 typ = MOAT;
  901.                 else {
  902.                 /*
  903.                  * We can't dig a pit here since that will
  904.                  * destroy the drawbridge.  The following is
  905.                  * a cop-out. --dlc
  906.                  */
  907.                 pline("The floor here seems too hard to dig in.");
  908.                 return;
  909.                 }
  910.             }
  911.  
  912.                 lev->drawbridgemask &= DB_DIR;
  913.             if(typ == LAVAPOOL) lev->drawbridgemask |= DB_LAVA;
  914.             newsym(u.ux,u.uy);
  915.  
  916.             pline("As you dig a pit, it fills with %s!",
  917.                   typ == LAVAPOOL ? "lava" : "water");
  918.             if(!Levitation
  919. #ifdef POLYSELF
  920.                && !is_flyer(uasmon)
  921. #endif
  922.                             ) {
  923.                 if (typ == LAVAPOOL)
  924.                 (void) lava_effects();
  925.                 else if(!Wwalking)
  926.                 (void) drown();
  927.             }
  928.             return;
  929.         } else if (lev->typ == ICE) {
  930.             /* assume we can remove most of the ice by drilling
  931.              * without melting it or allowing neighboring water
  932.              * to flow in.
  933.              */
  934.             lev->typ = ROOM;
  935.         } else if (IS_FOUNTAIN(lev->typ)) {
  936.             dogushforth(FALSE);
  937.             dryup(u.ux,u.uy);
  938.             return;
  939. #ifdef SINKS
  940.         } else if (IS_SINK(lev->typ)) {
  941.             breaksink(u.ux, u.uy);
  942.             return;
  943. #endif
  944.         /* the following two are here for the wand of digging */
  945.         } else if(IS_THRONE(levl[u.ux][u.uy].typ)) {
  946.             pline("The throne here is too hard to break apart.");
  947.             return;
  948.         } else if(IS_ALTAR(levl[u.ux][u.uy].typ)) {
  949.             pline("The altar here is too hard to break apart.");
  950.             return;
  951.         } else if(ttmp) {
  952.             ttmp->ttyp = TRAPDOOR;
  953.         } else if(nohole) {
  954.             /* can't make a trapdoor, so make a pit */
  955.             ttmp = maketrap(u.ux, u.uy, PIT);
  956.         } else
  957.             ttmp = maketrap(u.ux, u.uy, TRAPDOOR);
  958.         ttmp->tseen = 1;
  959.         if(Invisible) newsym(ttmp->tx,ttmp->ty);
  960.         if(ttmp->ttyp == PIT) {
  961.             You("have dug a pit.");
  962.             if(!Levitation) {
  963.             u.utrap = rn1(4,2);
  964.             u.utraptype = TT_PIT;
  965.             vision_full_recalc = 1;    /* vision limits change */
  966.             } else
  967.             u.utrap = 0;
  968.             return;
  969.         } 
  970.         pline("You've made a hole in the floor.");
  971.  
  972.         /* floor objects get a chance of falling down.
  973.          * the case where the hero does NOT fall down
  974.          * is treated here.  the case where the hero
  975.          * does fall down is treated in goto_level().
  976.          */
  977.         if(OBJ_AT(u.ux, u.uy) && (u.ustuck || Levitation 
  978. #ifdef WALKIES
  979.                                  || !next_to_u()
  980. #endif
  981.                       ))
  982.             impact_drop((struct obj *)0, u.ux, u.uy, 0);
  983.  
  984.         if (*u.ushops)
  985.             add_damage(u.ux, u.uy, 0L);
  986.         if(!u.ustuck && !Levitation) {            /* KAA */
  987.             if(*u.ushops)
  988.                 shopdig(1);
  989. #ifdef WALKIES
  990.             if(!next_to_u())
  991.                 You("are jerked back by your pet!");
  992.             else
  993. #endif
  994.             {
  995.                 You("fall through...");
  996.  
  997.                 /* the checks above must ensure that   */
  998.                 /* the destination level exists and is */
  999.                 /* in the present dungeon.           */
  1000.  
  1001.                 newlevel.dnum = u.uz.dnum;
  1002.                 newlevel.dlevel = u.uz.dlevel + 1;
  1003.                 goto_level(&newlevel, FALSE, TRUE, FALSE);
  1004.             }
  1005.         }
  1006.     }
  1007. }
  1008.  
  1009. static boolean
  1010. wield_tool(obj)
  1011. struct obj *obj;
  1012. {
  1013.     if(welded(uwep)) {
  1014.         /* Andreas Bormann - ihnp4!decvax!mcvax!unido!ab */
  1015.         if(flags.verbose) {
  1016.             pline("Since your weapon is welded to your %s,",
  1017.                 bimanual(uwep) ?
  1018.                 (const char *)makeplural(body_part(HAND))
  1019.                 : body_part(HAND));
  1020.             pline("you cannot wield that %s.", xname(obj));
  1021.         }
  1022.         return(FALSE);
  1023.     }
  1024. # ifdef POLYSELF
  1025.     if(cantwield(uasmon)) {
  1026.         You("can't hold it strongly enough.");
  1027.         return(FALSE);
  1028.     }
  1029. # endif
  1030.     unweapon = TRUE;
  1031.     You("now wield %s.", doname(obj));
  1032.     setuwep(obj);
  1033.     if (uwep != obj) return(FALSE); /* rewielded old object after dying */
  1034.     return(TRUE);
  1035. }
  1036.  
  1037. static int
  1038. use_pick_axe(obj)
  1039. struct obj *obj;
  1040. {
  1041.     char dirsyms[12];
  1042.     char qbuf[QBUFSZ];
  1043.     register char *dsp = dirsyms;
  1044.     register const char *sdp = flags.num_pad ? ndir : sdir;
  1045.     register struct rm *lev;
  1046.     register int rx, ry, res = 0;
  1047.     register boolean isclosedoor;
  1048.  
  1049.     if(obj != uwep)
  1050.         if (!wield_tool(obj)) return(0);
  1051.         else res = 1;
  1052.  
  1053.     while(*sdp) {
  1054.         (void) movecmd(*sdp);    /* sets u.dx and u.dy and u.dz */
  1055.         rx = u.ux + u.dx;
  1056.         ry = u.uy + u.dy;
  1057.         if(u.dz > 0 || (u.dz == 0 && isok(rx, ry) &&
  1058.             (IS_ROCK(levl[rx][ry].typ)
  1059.             || sobj_at(STATUE, rx, ry)
  1060.             || sobj_at(BOULDER, rx, ry))))
  1061.             *dsp++ = *sdp;
  1062.         sdp++;
  1063.     }
  1064.     *dsp = 0;
  1065.     Sprintf(qbuf, "In what direction do you want to dig? [%s]", dirsyms);
  1066.     if(!getdir(qbuf))
  1067.         return(res);
  1068.     if(u.uswallow && attack(u.ustuck)) /* return(1) */;
  1069.     else if(Underwater) {
  1070.         pline("Turbulence torpedoes your digging attempts.");
  1071.     } else if(u.dz < 0) {
  1072.         if(Levitation)
  1073.             You("don't have enough leverage.");
  1074.         else
  1075.             You("cannot reach the ceiling.");
  1076.     } else if(!u.dx && !u.dy && !u.dz) {
  1077.         char buf[BUFSZ];
  1078.         int dam;
  1079.  
  1080.         dam = rnd(2) + dbon() + obj->spe;
  1081.         if (dam <= 0) dam = 1;
  1082.         You("hit yourself with your own pick-axe.");
  1083.         /* self_pronoun() won't work twice in a sentence */
  1084.         Strcpy(buf, self_pronoun("killed %sself with %%s own pick-axe",
  1085.             "him"));
  1086.         losehp(dam, self_pronoun(buf, "his"), NO_KILLER_PREFIX);
  1087.         flags.botl=1;
  1088.         return(1);
  1089.     } else if(u.dz == 0) {
  1090.         if(Stunned || (Confusion && !rn2(5))) confdir();
  1091.         rx = u.ux + u.dx;
  1092.         ry = u.uy + u.dy;
  1093.         if(!isok(rx, ry)) {
  1094.             pline("Clash!");
  1095.             return(1);
  1096.         }
  1097.         lev = &levl[rx][ry];
  1098.         if(MON_AT(rx, ry) && attack(m_at(rx, ry)))
  1099.             return(1);
  1100.         isclosedoor = closed_door(rx, ry);
  1101.         if(!IS_ROCK(lev->typ)
  1102.              && !isclosedoor
  1103.              && !sobj_at(STATUE, rx, ry)
  1104.              && !sobj_at(BOULDER, rx, ry)) {
  1105.             /* ACCESSIBLE or POOL */
  1106.             You("swing your %s through thin air.",
  1107.                 aobjnam(obj, NULL));
  1108.         } else {
  1109.             if(dig_pos.x != rx || dig_pos.y != ry
  1110.                 || !on_level(&dig_level, &u.uz) || dig_down) {
  1111.                 dig_down = FALSE;
  1112.                 dig_pos.x = rx;
  1113.                 dig_pos.y = ry;
  1114.                 assign_level(&dig_level, &u.uz);
  1115.                 dig_effort = 0;
  1116.                     You("start %s.",
  1117.                    sobj_at(STATUE, rx, ry) ?
  1118.                         "chipping the statue" :
  1119.                    sobj_at(BOULDER, rx, ry) ?
  1120.                         "hitting the boulder" :
  1121.                    isclosedoor ? "chopping at the door" :
  1122.                         "digging");
  1123.             } else
  1124.                 You("continue %s.",
  1125.                    sobj_at(STATUE, rx, ry) ?
  1126.                         "chipping the statue" :
  1127.                    sobj_at(BOULDER, rx, ry) ?
  1128.                         "hitting the boulder" :
  1129.                    isclosedoor ? "chopping at the door" :
  1130.                         "digging");
  1131.             did_dig_msg = FALSE;
  1132.             set_occupation(dig, "digging", 0);
  1133.         }
  1134.     } else if (Is_airlevel(&u.uz) || Is_waterlevel(&u.uz)) {
  1135.         /* it must be air -- water checked above */
  1136.         You("swing your %s through thin air.", aobjnam(obj, NULL));
  1137.     } else if(Levitation) {
  1138.         You("cannot reach the floor.");
  1139.     } else if (is_pool(u.ux, u.uy)) {
  1140.         /* Monsters which swim also happen not to be able to dig */
  1141.         You("cannot stay underwater long enough.");
  1142.     } else {
  1143.         if(dig_pos.x != u.ux || dig_pos.y != u.uy
  1144.             || !on_level(&dig_level, &u.uz) || !dig_down) {
  1145.             dig_down = TRUE;
  1146.             dig_pos.x = u.ux;
  1147.             dig_pos.y = u.uy;
  1148.             assign_level(&dig_level, &u.uz);
  1149.             dig_effort = 0;
  1150.             You("start digging in the floor.");
  1151.             if(*u.ushops)
  1152.                 shopdig(0);
  1153.         } else
  1154.             You("continue digging in the floor.");
  1155.         did_dig_msg = FALSE;
  1156.         set_occupation(dig, "digging", 0);
  1157.     }
  1158.     return(1);
  1159. }
  1160.  
  1161. #define WEAK    3    /* from eat.c */
  1162.  
  1163. static char look_str[] = "look %s.";
  1164.  
  1165. static int
  1166. use_mirror(obj)
  1167. struct obj *obj;
  1168. {
  1169.     register struct monst *mtmp;
  1170.     register char mlet;
  1171.     boolean vis;
  1172.  
  1173.     if(!getdir(NULL)) return 0;
  1174.     if(obj->cursed && !rn2(2)) {
  1175.         if (!Blind)
  1176.             pline("The mirror fogs up and doesn't reflect!");
  1177.         return 1;
  1178.     }
  1179.     if(!u.dx && !u.dy && !u.dz) {
  1180.         if(!Blind && !Invisible) {
  1181. #ifdef POLYSELF
  1182.             if(u.umonnum == PM_FLOATING_EYE) {
  1183.             pline(Hallucination ?
  1184.                   "Yow!  The mirror stared back at you!" :
  1185.                   "Yikes!  You've frozen yourself!");
  1186.             nomul(-rnd((MAXULEV+6) - (int)u.ulevel));
  1187.             } else if (u.usym == S_VAMPIRE)
  1188.             You("don't seem to reflect anything.");
  1189.             else if(u.umonnum == PM_UMBER_HULK) {
  1190.             pline("Huh?  That doesn't look like you!");
  1191.             make_confused(HConfusion + d(3,4),FALSE);
  1192.             } else
  1193. #endif
  1194.                if (Hallucination) You(look_str, hcolor());
  1195.             else if (Sick)
  1196.             You(look_str, "peaked");
  1197.             else if (u.uhs >= WEAK)
  1198.             You(look_str, "undernourished");
  1199.             else You("look as %s as ever.",
  1200.                 ACURR(A_CHA) > 14 ?
  1201.                 (poly_gender()==1 ? "beautiful" : "handsome") :
  1202.                 "ugly");
  1203.         } else {
  1204.             You("can't see your %s %s.",
  1205.                 ACURR(A_CHA) > 14 ?
  1206.                 (poly_gender()==1 ? "beautiful" : "handsome") :
  1207.                 "ugly",
  1208.                 body_part(FACE));
  1209.         }
  1210.         return 1;
  1211.     }
  1212.     if(u.uswallow) {
  1213.         if (!Blind) You("reflect %s's %s.", mon_nam(u.ustuck),
  1214.             is_animal(u.ustuck->data)? "stomach" : "interior");
  1215.         return 1;
  1216.     }
  1217.     if(Underwater) {
  1218.         You("offer the fish a chance to do some makeup.");
  1219.         return 1;
  1220.     }
  1221.     if(u.dz) {
  1222.         if (!Blind)
  1223.             You("reflect the %s.", (u.dz > 0) ? "floor" : "ceiling");
  1224.         return 1;
  1225.     }
  1226.     if(!(mtmp = bhit(u.dx,u.dy,COLNO,INVIS_BEAM,
  1227.                     (int(*)())0,(int(*)())0,obj)) ||
  1228.        !haseyes(mtmp->data))
  1229.         return 1;
  1230.  
  1231.     vis = canseemon(mtmp);
  1232.     mlet = mtmp->data->mlet;
  1233.     if(mtmp->msleep) {
  1234.         if (vis)
  1235.             pline ("%s is tired and doesn't look at your mirror.",
  1236.                 Monnam(mtmp));
  1237.     } else if (!mtmp->mcansee) {
  1238.         if (vis)
  1239.         pline("%s can't see anything at the moment.", Monnam(mtmp));
  1240.     /* some monsters do special things */
  1241.     } else if (mlet == S_VAMPIRE || mlet == S_GHOST) {
  1242.         if (vis)
  1243.         pline ("%s doesn't seem to reflect anything.", Monnam(mtmp));
  1244.     } else if(!mtmp->mcan && mtmp->data == &mons[PM_MEDUSA]) {
  1245.         if (vis)
  1246.             pline("%s is turned to stone!", Monnam(mtmp));
  1247.         stoned = TRUE;
  1248.         killed(mtmp);
  1249.     } else if(!mtmp->mcan && !mtmp->minvis &&
  1250.                     mtmp->data == &mons[PM_FLOATING_EYE]) {
  1251.         int tmp = d((int)mtmp->m_lev, (int)mtmp->data->mattk[0].damd);
  1252.         if (!rn2(4)) tmp = 120;
  1253.     /* Note: floating eyes cannot use their abilities while invisible,
  1254.      * but Medusa and umber hulks can.
  1255.      */
  1256.         if (vis)
  1257.             pline("%s is frozen by its reflection.",Monnam(mtmp));
  1258.         else You("hear something stop moving.");
  1259.         mtmp->mcanmove = 0;
  1260.         if ( (int) mtmp->mfrozen + tmp > 127)
  1261.             mtmp->mfrozen = 127;
  1262.         else mtmp->mfrozen += tmp;
  1263.     } else if(!mtmp->mcan && mtmp->data == &mons[PM_UMBER_HULK]) {
  1264.         if (vis)
  1265.             pline ("%s has confused itself!", Monnam(mtmp));
  1266.             mtmp->mconf = 1;
  1267.     } else if(!mtmp->mcan && !mtmp->minvis && (mlet == S_NYMPH
  1268.                          || mtmp->data==&mons[PM_SUCCUBUS])) {
  1269.         if (vis) {
  1270.                 pline ("%s looks beautiful in your mirror.",Monnam(mtmp));
  1271.                 pline ("She decides to take it!");
  1272.         } else pline ("It steals your mirror!");
  1273.         setnotworn(obj); /* in case mirror was wielded */
  1274.             freeinv(obj);
  1275.             mpickobj(mtmp,obj);
  1276.             rloc(mtmp);
  1277.     } else if (mlet != S_UNICORN && !humanoid(mtmp->data) &&
  1278.             (!mtmp->minvis || perceives(mtmp->data)) && rn2(5)) {
  1279.         if (vis)
  1280.             pline ("%s is frightened by its reflection.",
  1281.                 Monnam(mtmp));
  1282.         mtmp->mflee = 1;
  1283.         mtmp->mfleetim += d(2,4);
  1284.     } else if (!Blind) {
  1285.         if (mtmp->minvis && !See_invisible)
  1286.             ;
  1287.         else if ((mtmp->minvis && !perceives(mtmp->data))
  1288.              || !haseyes(mtmp->data))
  1289.             pline("%s doesn't seem to be aware of its reflection.",
  1290.             Monnam(mtmp));
  1291.         else
  1292.             pline("%s doesn't seem to mind %s reflection.",
  1293.             Monnam(mtmp),
  1294.             humanoid(mtmp->data) ? (mtmp->female ? "her" : "his")
  1295.                         : "its");
  1296.     }
  1297.     return 1;
  1298. }
  1299.  
  1300. static void
  1301. use_bell(obj)
  1302. register struct obj *obj;
  1303. {
  1304.     You("ring %s.", the(xname(obj)));
  1305.  
  1306.     if(Underwater) {
  1307.         pline("But it sounds kind of muffled.");
  1308.         return;
  1309.     }
  1310.         if(obj->otyp == BELL) {
  1311.         if(u.uswallow) {
  1312.             pline(nothing_happens);
  1313.         return;
  1314.         }
  1315.         if(obj->cursed && !rn2(3)) {
  1316.             register struct monst *mtmp;
  1317.  
  1318.         if(mtmp = makemon(&mons[PM_WOOD_NYMPH], u.ux, u.uy))
  1319.            You("summon %s!", a_monnam(mtmp));
  1320.         }
  1321.         wake_nearby();
  1322.         return;
  1323.     }
  1324.  
  1325.     /* bell of opening */
  1326.     if(u.uswallow && !obj->blessed) {
  1327.         pline(nothing_happens);
  1328.         return;
  1329.     }
  1330.         if(obj->cursed) {
  1331.         coord mm;
  1332.         mm.x = u.ux;
  1333.         mm.y = u.uy;
  1334.         mkundead(&mm);
  1335. cursed_bell:
  1336.         wake_nearby();
  1337.         if(obj->spe > 0) obj->spe--;
  1338.         return;
  1339.     }
  1340.     if(invocation_pos(u.ux, u.uy) && 
  1341.                  !On_stairs(u.ux, u.uy) && !u.uswallow) {
  1342.         pline("%s emits an unnerving high-pitched sound...",
  1343.                                                   The(xname(obj)));
  1344.         obj->age = moves;
  1345.         if(obj->spe > 0) obj->spe--;
  1346.         wake_nearby();
  1347.         obj->known = 1;
  1348.         return;
  1349.     }
  1350.     if(obj->blessed) {
  1351.         if(obj->spe > 0) {
  1352.             register int cnt = openit();
  1353.         if(cnt == -1) return; /* was swallowed */
  1354.         switch(cnt) {
  1355.           case 0:  pline(nothing_happens); break;
  1356.           case 1:  pline("Something opens..."); break;
  1357.               default: pline("Things open around you..."); break;
  1358.             }
  1359.         if(cnt > 0) obj->known = 1;
  1360.         obj->spe--;
  1361.         } else pline(nothing_happens);
  1362.     } else {  /* uncursed */
  1363.         if(obj->spe > 0) {
  1364.             register int cnt = findit();
  1365.         if(cnt == 0) pline(nothing_happens);
  1366.         else obj->known = 1;
  1367.             obj->spe--;
  1368.         } else {
  1369.             if(!rn2(3)) goto cursed_bell;
  1370.         else pline(nothing_happens);
  1371.         }
  1372.         }
  1373. }
  1374.  
  1375. static void
  1376. use_candelabrum(obj)
  1377. register struct obj *obj;
  1378. {
  1379.     if(Underwater) {
  1380.         You("can't make fire under water.");
  1381.         return;
  1382.     }
  1383.     if(obj->lamplit) {
  1384.         You("snuff the candle%s out.", obj->spe > 1 ? "s" : "");
  1385.         obj->lamplit = 0;
  1386.         check_lamps();
  1387.         return;
  1388.     }
  1389.     if(obj->spe <= 0) {
  1390.         pline("This %s has no candles.", xname(obj));
  1391.         return;
  1392.     }
  1393.     if(u.uswallow || obj->cursed) {
  1394.         pline("The candle%s flicker%s on for a moment, then die%s.", 
  1395.             obj->spe > 1 ? "s" : "",
  1396.             obj->spe > 1 ? "" : "s",
  1397.             obj->spe > 1 ? "" : "s");
  1398.             return;
  1399.     } 
  1400.         if(obj->spe < 7) {
  1401.             pline("There %s only %d candle%s in %s.",
  1402.                obj->spe == 1 ? "is" : "are", 
  1403.                obj->spe,
  1404.                obj->spe > 1 ? "s" : "",
  1405.                the(xname(obj)));
  1406.         pline("%s lit.  %s emits a dim light.",
  1407.                obj->spe == 1 ? "It is" : "They are", The(xname(obj)));
  1408.     } else {
  1409.         pline("%s's candles burn%s", The(xname(obj)),
  1410.             (Blind ? "." : " brightly!"));
  1411.     }
  1412.     if (!invocation_pos(u.ux, u.uy)) {
  1413.         pline("The candle%s being rapidly consumed!",
  1414.             (obj->spe > 1 ? "s are" : " is"));
  1415.         obj->age /= 2;
  1416.     } else {
  1417.             if(obj->spe == 7)
  1418.                 pline("%s glows with a strange light!", The(xname(obj)));
  1419.         obj->known = 1;
  1420.     }
  1421.     obj->lamplit = 1;
  1422.     check_lamps();
  1423. }
  1424.  
  1425. static void
  1426. use_candle(obj)
  1427. register struct obj *obj;
  1428. {
  1429.  
  1430.     register struct obj *otmp;
  1431.     char qbuf[QBUFSZ];
  1432.  
  1433.     if(obj->lamplit) {
  1434.             use_lamp(obj);
  1435.         return;
  1436.     }
  1437.  
  1438.     if(u.uswallow) {
  1439.             You("don't have enough elbow-room to maneuver.");
  1440.         return;
  1441.     }
  1442.     if(Underwater) {
  1443.         pline("Sorry, fire and water don't mix.");
  1444.         return;
  1445.     }
  1446.  
  1447.     for(otmp = invent; otmp; otmp = otmp->nobj) {
  1448.         if(otmp->otyp == CANDELABRUM_OF_INVOCATION && otmp->spe < 7)
  1449.             break;
  1450.     }
  1451.     if(!otmp || otmp->spe == 7) {
  1452.         use_lamp(obj);
  1453.         return;
  1454.     }
  1455.  
  1456.     Sprintf(qbuf, "Attach %s", the(xname(obj)));
  1457.     Sprintf(eos(qbuf), " to %s?", the(xname(otmp)));
  1458.     if(yn(qbuf) == 'n') {
  1459.         You("try to light %s...", the(xname(obj)));
  1460.         use_lamp(obj);
  1461.         return;
  1462.     } else {
  1463.         register long needed = 7L - (long)otmp->spe;
  1464.  
  1465.         You("attach %ld%s candle%s to %s.", 
  1466.             obj->quan >= needed ? needed : obj->quan,
  1467.             !otmp->spe ? "" : " more",
  1468.             (needed > 1L && obj->quan > 1L) ? "s" : "",
  1469.             the(xname(otmp)));
  1470.         if(otmp->lamplit) 
  1471.             pline("The new candle%s magically ignite%s!",
  1472.                 (needed > 1L && obj->quan > 1L) ? "s" : "",
  1473.                 (needed > 1L && obj->quan > 1L) ? "" : "s");
  1474.         if(obj->unpaid) 
  1475.             You("use %s, you bought %s!",
  1476.                 (needed > 1L && obj->quan > 1L) ? "them" : "it",
  1477.                 (needed > 1L && obj->quan > 1L) ? "them" : "it");
  1478.         if(!otmp->spe || otmp->age > obj->age)
  1479.             otmp->age = obj->age;
  1480.         if(obj->quan > needed) {
  1481.             if(obj->unpaid) {
  1482.             /* this is a hack, until we re-write the billing */
  1483.             /* code to accommodate such cases directly. IM*/
  1484.             register long delta = obj->quan - needed;
  1485.  
  1486.             subfrombill(obj, shop_keeper(*u.ushops));
  1487.             obj->quan = needed;
  1488.             addtobill(obj, TRUE, FALSE, TRUE);
  1489.             bill_dummy_object(obj);
  1490.             obj->quan = delta;
  1491.             addtobill(obj, TRUE, FALSE, TRUE);
  1492.              } else {
  1493.             obj->quan -= needed;
  1494.              }
  1495.              otmp->spe += (int)needed;
  1496.         } else {
  1497.             otmp->spe += (int)obj->quan;
  1498.             freeinv(obj);
  1499.             obfree(obj, (struct obj *)0);
  1500.         }
  1501.         if(needed < 7L && otmp->spe == 7)
  1502.             pline("%s has now seven%s candles attached.",
  1503.             The(xname(otmp)), otmp->lamplit ? " lit" : "");
  1504.     }
  1505. }
  1506.  
  1507. boolean
  1508. snuff_candle(otmp)  /* call in drop, throw, and put in box, etc. */
  1509. register struct obj *otmp;
  1510. {
  1511.     register boolean candle = Is_candle(otmp);
  1512.  
  1513.     if ((candle || otmp->otyp == CANDELABRUM_OF_INVOCATION) &&
  1514.         otmp->lamplit) {
  1515.         register boolean many = candle ? otmp->quan > 1L : otmp->spe > 1;
  1516.         pline("The %scandle%s flame%s extinguished.",
  1517.           (candle ? "" : "candelabrum's "),
  1518.           (many ? "s'" : "'s"), (many ? "s are" : " is"));
  1519.        otmp->lamplit = 0;
  1520.        check_lamps();
  1521.        return(TRUE);
  1522.     }
  1523.     return(FALSE);
  1524. }
  1525.  
  1526. boolean
  1527. snuff_lit(obj)
  1528. struct obj *obj;
  1529. {
  1530.     if(obj->lamplit) {
  1531.         if(obj->otyp == OIL_LAMP || obj->otyp == MAGIC_LAMP ||
  1532.                 obj->otyp == BRASS_LANTERN) {
  1533.             Your("lamp is now off.");
  1534.             obj->lamplit = 0;
  1535.             check_lamps();
  1536.             return(TRUE);
  1537.         } 
  1538.  
  1539.         if(snuff_candle(obj)) return(TRUE);
  1540.     }
  1541.  
  1542.     return(FALSE);
  1543. }
  1544.  
  1545. static void
  1546. use_lamp(obj)
  1547. struct obj *obj;
  1548. {
  1549.     if(Underwater) {
  1550.         pline("This is not a diving lamp.");
  1551.         return;
  1552.     }
  1553.     if(obj->lamplit) {
  1554.         if(obj->otyp == OIL_LAMP || obj->otyp == MAGIC_LAMP ||
  1555.                 obj->otyp == BRASS_LANTERN)
  1556.             Your("lamp is now off.");
  1557.         else
  1558.             You("snuff out %s.", the(xname(obj)));
  1559.         obj->lamplit = 0;
  1560.         check_lamps();
  1561.         return;
  1562.     }
  1563.     if (!Is_candle(obj) && obj->spe <= 0) {
  1564.         if (obj->otyp == BRASS_LANTERN)
  1565.             Your("lamp has run out of power.");
  1566.         else pline("This %s has no oil.", xname(obj));
  1567.         return;
  1568.     }
  1569.     if(obj->cursed && !rn2(2))
  1570.         pline("%s flicker%s on for a moment, then die%s.", 
  1571.                The(xname(obj)),
  1572.                obj->quan > 1L ? "" : "s",
  1573.                obj->quan > 1L ? "" : "s");
  1574.     else {
  1575.         if(obj->otyp == OIL_LAMP || obj->otyp == MAGIC_LAMP ||
  1576.                 obj->otyp == BRASS_LANTERN)
  1577.             Your("lamp is now on.");
  1578.         else
  1579.             pline("%s%s flame%s burn%s%s", The(xname(obj)),
  1580.                 obj->quan > 1L ? "'" : "'s",
  1581.                 obj->quan > 1L ? "s" : "",
  1582.                 obj->quan > 1L ? "" : "s",
  1583.             Blind ? "." : " brightly!");
  1584.         obj->lamplit = 1;
  1585.         check_lamps();
  1586.         if (obj->unpaid && Is_candle(obj) &&
  1587.             obj->age == 20L * (long)objects[obj->otyp].oc_cost) {
  1588.             const char *it_them = obj->quan > 1L ? "them" : "it";
  1589.             You("use %s, you've bought %s!", it_them, it_them);
  1590.             bill_dummy_object(obj);
  1591.         }
  1592.     }
  1593. }
  1594.  
  1595. void
  1596. check_lamps()
  1597. {
  1598.     register struct obj *obj;
  1599.     int lamps = 0;
  1600.  
  1601.     for(obj = invent; obj; obj = obj->nobj)
  1602.         if (obj->lamplit) {
  1603.             lamps++;
  1604.             break;
  1605.         }
  1606.  
  1607.     if (lamps && u.nv_range == 1) {
  1608.         u.nv_range = 3;
  1609.         vision_full_recalc = 1;
  1610.     } else if (!lamps && u.nv_range == 3) {
  1611.         u.nv_range = 1;
  1612.         vision_full_recalc = 1;
  1613.     }
  1614. }
  1615.  
  1616. static const char NEARDATA cuddly[] = { TOOL_CLASS, 0 };
  1617.  
  1618. int
  1619. dorub()
  1620. {
  1621.     struct obj *obj = getobj(cuddly, "rub");
  1622.  
  1623.     if(!obj || (obj != uwep && !wield_tool(obj))) return 0;
  1624.  
  1625.     /* now uwep is obj */
  1626.     if (uwep->otyp == MAGIC_LAMP) {
  1627.         if (uwep->spe > 0 && !rn2(3)) {
  1628.         djinni_from_bottle(uwep);
  1629.         makeknown(MAGIC_LAMP);
  1630.         uwep->otyp = OIL_LAMP;
  1631.         uwep->spe = 1; /* for safety */
  1632.         uwep->age = rn1(500,1000);
  1633.         } else if (rn2(2) && !Blind)
  1634.         You("see a puff of smoke.");
  1635.         else pline(nothing_happens);
  1636.     } else if (obj->otyp == BRASS_LANTERN) {
  1637.         /* message from Adventure */
  1638.         pline("Rubbing the electric lamp is not particularly rewarding.");
  1639.         pline("Anyway, nothing exciting happens.");
  1640.     } else pline(nothing_happens);
  1641.     return 1;
  1642. }
  1643.  
  1644. int
  1645. dojump()
  1646. {
  1647.     coord cc;
  1648.     register struct monst *mtmp;
  1649.     if (!Jumping || Levitation) {
  1650.         You("can't jump very far.");
  1651.         return 0;
  1652.     } else if (u.uswallow) {
  1653.         pline("You've got to be kidding!");
  1654.         return 0;
  1655.     } else if (u.uinwater) {
  1656.         pline("This calls for swimming, not jumping!");
  1657.         return 0;
  1658.     } else if (u.ustuck) {
  1659.         You("cannot escape from %s!", mon_nam(u.ustuck));
  1660.         return 0;
  1661.     } else if (near_capacity() > UNENCUMBERED) {
  1662.         You("are carrying too much to jump!");
  1663.         return 0;
  1664.     } else if (u.uhunger <= 100 || ACURR(A_STR) < 6) {
  1665.         You("lack the strength to jump!");
  1666.         return 0;
  1667.     }
  1668.     pline("Where do you want to jump?");
  1669.     cc.x = u.ux;
  1670.     cc.y = u.uy;
  1671.     getpos(&cc, TRUE, "the desired position");
  1672.         if(cc.x == -10) return 0; /* user pressed esc */
  1673.     if (!(Jumping & ~INTRINSIC) && distu(cc.x, cc.y) != 5) {
  1674.         pline("Illegal move!");
  1675.         return 0;
  1676.     } else if (distu(cc.x, cc.y) > 9) {
  1677.         pline("Too far!");
  1678.         return 0;
  1679.     } else if (!cansee(cc.x, cc.y)) {
  1680.         You("cannot see where to land!");
  1681.         return 0;
  1682.     } else if (mtmp = m_at(cc.x, cc.y)) {
  1683.         You("cannot trample %s!", mon_nam(mtmp));
  1684.         return 0;
  1685.     } else if (!isok(cc.x, cc.y) ||
  1686. #ifdef POLYSELF
  1687.         (IS_ROCK(levl[cc.x][cc.y].typ) && !passes_walls(uasmon)) ||
  1688. #else
  1689.         IS_ROCK(levl[cc.x][cc.y].typ) ||
  1690. #endif
  1691.         sobj_at(BOULDER, cc.x, cc.x) ) {
  1692.             You("cannot jump there!");
  1693.             return 0;
  1694.     } else {
  1695.         if(u.utrap)
  1696.         switch(u.utraptype) {
  1697.         case TT_BEARTRAP: {
  1698.             register long side = rn2(3) ? LEFT_SIDE : RIGHT_SIDE;
  1699.             You("rip yourself out of the bear trap!  Ouch!");
  1700.             losehp(rnd(10), "jumping out of a bear trap", KILLED_BY);
  1701.             set_wounded_legs(side, rn1(1000,500));
  1702.             break;
  1703.           }
  1704.         case TT_PIT:
  1705.             You("leap from the pit!");
  1706.             break;
  1707.         case TT_WEB:
  1708.             You("tear the web apart as you pull yourself free!");
  1709.             deltrap(t_at(u.ux,u.uy));
  1710.             break;
  1711.         case TT_LAVA:
  1712.             You("pull yourself above the lava!");
  1713.             u.utrap = 0;
  1714.             return 1;
  1715.         case TT_INFLOOR:
  1716.             You("strain your %s, but are still stuck in the floor.",
  1717.             makeplural(body_part(LEG)));
  1718.             set_wounded_legs(LEFT_SIDE, rn1(10, 11));
  1719.             set_wounded_legs(RIGHT_SIDE, rn1(10, 11));
  1720.             return 1;
  1721.         }
  1722.  
  1723.         teleds(cc.x, cc.y);
  1724.         nomul(-1);
  1725.         nomovemsg = "";
  1726.         morehungry(rnd(25));
  1727.         return 1;
  1728.     }
  1729. }
  1730.  
  1731. static void
  1732. use_tinning_kit(obj)
  1733. register struct obj *obj;
  1734. {
  1735.     register struct obj *corpse, *can;
  1736.  
  1737.     /* This takes only 1 move.  If this is to be changed to take many
  1738.      * moves, we've got to deal with decaying corpses...
  1739.      */
  1740.     if (!(corpse = floorfood("can", 1))) return;
  1741.     if (corpse->oeaten) {
  1742.         You("cannot tin something which is partly eaten.");
  1743.         return;
  1744.     }
  1745.     if ((corpse->corpsenm == PM_COCKATRICE)
  1746. #ifdef POLYSELF
  1747.         && !resists_ston(uasmon)
  1748. #endif
  1749.         && !uarmg) {
  1750. pline("Tinning a cockatrice corpse without gloves was not a very wise move...");
  1751. #if defined(POLYSELF)
  1752. /* this will have to change if more monsters can poly */
  1753.         if(!(poly_when_stoned(uasmon) && polymon(PM_STONE_GOLEM)))
  1754. #endif
  1755.         {
  1756.         You("turn to stone...");
  1757.         killer_format = KILLED_BY;
  1758.         killer = "trying to tin a cockatrice without gloves";
  1759.         done(STONING);
  1760.         }
  1761.     }
  1762.     if (mons[corpse->corpsenm].cnutrit == 0) {
  1763.         You("can't tin something that insubstantial!");
  1764.         return;
  1765.     }
  1766.     if (is_rider(&mons[corpse->corpsenm])) {
  1767.         revive_corpse(corpse, 0, FALSE);
  1768.         verbalize("Yes....  But War does not preserve its enemies...");
  1769.         return;
  1770.     }
  1771.     if(can = mksobj(TIN, FALSE, FALSE)) {
  1772.         can->corpsenm = corpse->corpsenm;
  1773.         can->cursed = obj->cursed;
  1774.         can->blessed = obj->blessed;
  1775.         can->owt = weight(can);
  1776.         can->known = 1;
  1777.         can->spe = -1;  /* Mark tinned tins. No spinach allowed... */
  1778.         can = hold_another_object(can, "You make, but cannot pick up, %s.",
  1779.                       doname(can), (const char *)0);
  1780.         if (carried(corpse)) useup(corpse);
  1781.         else useupf(corpse);
  1782.     } else impossible("Tinning failed.");
  1783. }
  1784.  
  1785. void
  1786. use_unicorn_horn(obj)
  1787. struct obj *obj;
  1788. {
  1789.     boolean blessed = (obj && obj->blessed);
  1790.     boolean did_something = FALSE;
  1791.  
  1792.     if (obj && obj->cursed) {
  1793.         switch (rn2(6)) {
  1794.             static char buf[BUFSZ];
  1795.             case 0: make_sick(Sick ? 1L : (long) rn1(20, 20), TRUE);
  1796.                 Strcpy(buf, xname(obj));
  1797.                 u.usick_cause = (const char *)buf;
  1798.                 break;
  1799.             case 1: make_blinded(Blinded + (long) rnd(100), TRUE);
  1800.                 break;
  1801.             case 2: if (!Confusion)
  1802.                 You("suddenly feel %s.",
  1803.                     Hallucination ? "trippy" : "confused");
  1804.                 make_confused(HConfusion + (long) rnd(100), TRUE);
  1805.                 break;
  1806.             case 3: make_stunned(HStun + (long) rnd(100), TRUE);
  1807.                 break;
  1808.             case 4: (void) adjattrib(rn2(6), -1, FALSE);
  1809.                 break;
  1810.             case 5: make_hallucinated(HHallucination + (long) rnd(100),
  1811.                 TRUE, 0L);
  1812.                 break;
  1813.         }
  1814.         return;
  1815.     }
  1816.         
  1817.     if (Sick) {
  1818.         make_sick(0L, TRUE);
  1819.         did_something++;
  1820.     }
  1821.     if (Blinded > (long)(u.ucreamed+1) && (!did_something || blessed)) {
  1822.         make_blinded(u.ucreamed ? (long)(u.ucreamed+1) : 0L, TRUE);
  1823.         did_something++;
  1824.     }
  1825.     if (Hallucination && (!did_something || blessed)) {
  1826.         make_hallucinated(0L, TRUE, 0L);
  1827.         did_something++;
  1828.     }
  1829.     if (Vomiting && (!did_something || blessed)) {
  1830.         make_vomiting(0L, TRUE);
  1831.         did_something++;
  1832.     }
  1833.     if (HConfusion && (!did_something || blessed)) {
  1834.         make_confused(0L, TRUE);
  1835.         did_something++;
  1836.     }
  1837.     if (HStun && (!did_something || blessed)) {
  1838.         make_stunned(0L, TRUE);
  1839.         did_something++;
  1840.     }
  1841.     if (!did_something || blessed) {
  1842.         register int j;
  1843.         int did_stat = 0;
  1844.         int i = rn2(A_MAX);
  1845.         for(j=0; j<A_MAX; j++) {
  1846.             /* don't recover strength lost while hungry */
  1847.             if ((blessed || j==i) &&
  1848.                 ((j != A_STR || u.uhs < WEAK)
  1849.                 ? (ABASE(i) < AMAX(i))
  1850.                 : (ABASE(A_STR) < (AMAX(A_STR) - 1)))) {
  1851.                 did_something++;
  1852.                 /* They may have to use it several times... */
  1853.                 if (!did_stat) {
  1854.                     did_stat++;
  1855.                     pline("This makes you feel good!");
  1856.                 }
  1857.                 ABASE(i)++;
  1858.                 flags.botl = 1;
  1859.             }
  1860.         }
  1861.     }
  1862.     if (!did_something) pline(nothing_happens);
  1863. }
  1864.  
  1865. static void
  1866. use_figurine(obj)
  1867. register struct obj *obj;
  1868. {
  1869.     xchar x, y;
  1870.  
  1871.     if(!getdir(NULL)) {
  1872.         flags.move = multi = 0;
  1873.         return;
  1874.     }
  1875.     x = u.ux + u.dx; y = u.uy + u.dy;
  1876.     if (!isok(x,y)) {
  1877.         You("can't seem to put the figurine there.");
  1878.         return;
  1879.     }
  1880.     if (IS_ROCK(levl[x][y].typ) && !passes_walls(&mons[obj->corpsenm])) {
  1881.         You("can't place a figurine in solid rock!");
  1882.         return;
  1883.     }
  1884.     if (sobj_at(BOULDER,x,y) && !passes_walls(&mons[obj->corpsenm])
  1885.             && !throws_rocks(&mons[obj->corpsenm])) {
  1886.         You("can't fit the figurine on the boulder.");
  1887.         return;
  1888.     }
  1889.     You("%s and it transforms.",
  1890.         (u.dx||u.dy) ? "set the figurine besides you" :
  1891.         (Is_airlevel(&u.uz) || Is_waterlevel(&u.uz)) ?
  1892.         "release the figurine" :
  1893.         (u.dz < 0 ?
  1894.         "toss the figurine into the air" :
  1895.         "set the figurine on the ground"));
  1896.     make_familiar(obj, u.ux+u.dx, u.uy+u.dy);
  1897.     useup(obj);
  1898. }
  1899.  
  1900. static void
  1901. use_grease(obj)
  1902. struct obj *obj;
  1903. {
  1904.     struct obj *otmp;
  1905.  
  1906.     if (obj->spe > 0) {
  1907.         char allow_all[2];
  1908.         if (obj->cursed && !rn2(2)) {
  1909.             pline("The %s slips from your fingers!",xname(obj));
  1910.             dropx(obj);
  1911.             obj->spe -= 1;
  1912.             return;
  1913.         }
  1914.         allow_all[0] = ALL_CLASSES; allow_all[1] = '\0';
  1915.         otmp = getobj(allow_all,"grease");
  1916.         if (otmp) {
  1917.             You("cover your %s with a thick layer of grease.",xname(otmp));
  1918.             otmp->greased = 1;
  1919.             obj->spe -= 1;
  1920.         }
  1921.     }
  1922. }
  1923.  
  1924. int
  1925. doapply()
  1926. {
  1927.     register struct obj *obj;
  1928.     register int res = 1;
  1929.  
  1930.     if(check_capacity(NULL)) return (0);
  1931.     obj = getobj(tools, "use or apply");
  1932.     if(!obj) return 0;
  1933.  
  1934.     check_unpaid(obj);
  1935.  
  1936.     switch(obj->otyp){
  1937.     case BLINDFOLD:
  1938.         if (obj == ublindf) {
  1939.             if(cursed(obj)) break;
  1940.             else Blindf_off(obj);
  1941.         } 
  1942.         else if (!ublindf) Blindf_on(obj);
  1943.         else You("are already %s", ublindf->otyp == TOWEL ?
  1944.              "covered by a towel." : "wearing a blindfold!");
  1945.         break;
  1946.     case LARGE_BOX:
  1947.     case CHEST:
  1948.     case ICE_BOX:
  1949.     case SACK:
  1950.     case BAG_OF_HOLDING:
  1951.     case OILSKIN_SACK:
  1952.         res = use_container(obj, 1); 
  1953.         break;
  1954.     case BAG_OF_TRICKS:
  1955.         if(obj->spe > 0) {
  1956.             register int cnt = 1;
  1957.  
  1958.             obj->spe -= 1;
  1959.             if(!rn2(23)) cnt += rn2(7) + 1;
  1960.             while(cnt--)
  1961.                 (void) makemon((struct permonst *) 0, u.ux, u.uy);
  1962.             makeknown(BAG_OF_TRICKS);
  1963.         } else
  1964.             pline(nothing_happens);
  1965.         break;
  1966.     case CAN_OF_GREASE:
  1967.         use_grease(obj);
  1968.         break;
  1969.     case LOCK_PICK:
  1970. #ifdef TOURIST
  1971.     case CREDIT_CARD:
  1972. #endif
  1973.     case SKELETON_KEY:
  1974.         (void) pick_lock(obj);
  1975.         break;
  1976.     case PICK_AXE:
  1977.         res = use_pick_axe(obj);
  1978.         break;
  1979.     case TINNING_KIT:
  1980.         use_tinning_kit(obj);
  1981.         break;
  1982. #ifdef WALKIES
  1983.     case LEASH:
  1984.         use_leash(obj);
  1985.         break;
  1986. #endif
  1987.     case MAGIC_WHISTLE:
  1988.         use_magic_whistle(obj);
  1989.         break;
  1990.     case TIN_WHISTLE:
  1991.         use_whistle(obj);
  1992.         break;
  1993.     case STETHOSCOPE:
  1994.         res = 0;
  1995.         use_stethoscope(obj);
  1996.         break;
  1997.     case MIRROR:
  1998.         res = use_mirror(obj);
  1999.         break;
  2000.     case BELL:
  2001.     case BELL_OF_OPENING:
  2002.             use_bell(obj);
  2003.         break;
  2004.     case CANDELABRUM_OF_INVOCATION:
  2005.         use_candelabrum(obj);
  2006.         break;
  2007.     case WAX_CANDLE:
  2008.     case TALLOW_CANDLE:
  2009.         use_candle(obj);
  2010.         break;
  2011.     case OIL_LAMP:
  2012.     case MAGIC_LAMP:
  2013.     case BRASS_LANTERN:
  2014.         use_lamp(obj);
  2015.         break;
  2016. #ifdef TOURIST
  2017.     case EXPENSIVE_CAMERA:
  2018.         res = use_camera(obj); 
  2019.         break;
  2020. #endif
  2021.     case TOWEL:
  2022.         res = use_towel(obj); 
  2023.         break;
  2024.     case CRYSTAL_BALL:
  2025.         use_crystal_ball(obj);
  2026.         break;
  2027.     case MAGIC_MARKER:
  2028.         res = dowrite(obj);
  2029.         break;
  2030.     case TIN_OPENER:
  2031.         if(!carrying(TIN)) {
  2032.             You("have no tin to open.");
  2033.             goto xit;
  2034.         }
  2035.         You("cannot open a tin without eating or discarding its contents.");
  2036.         if(flags.verbose)
  2037.             pline("In order to eat, use the 'e' command.");
  2038.         if(obj != uwep)
  2039.     pline("Opening the tin will be much easier if you wield the tin opener.");
  2040.         goto xit;
  2041.  
  2042.     case FIGURINE:
  2043.         use_figurine(obj);
  2044.         break;
  2045.     case UNICORN_HORN:
  2046.         use_unicorn_horn(obj);
  2047.         break;
  2048.     case WOODEN_FLUTE:
  2049.     case MAGIC_FLUTE:
  2050.     case TOOLED_HORN:
  2051.     case FROST_HORN:
  2052.     case FIRE_HORN:
  2053.     case WOODEN_HARP:
  2054.     case MAGIC_HARP:
  2055.     case BUGLE:
  2056.     case LEATHER_DRUM:
  2057.     case DRUM_OF_EARTHQUAKE:
  2058.         res = do_play_instrument(obj);
  2059.         break;
  2060.     case HORN_OF_PLENTY:
  2061.         if (obj->spe > 0) {
  2062.             struct obj *otmp;
  2063.             const char *what;
  2064.  
  2065. #ifdef MAC
  2066.             char melody [ 3 ] = { 0 , 0 , 0 } ;
  2067.             melody [ 0 ] = rn2 ( 8 ) + 'A' ;
  2068.             melody [ 1 ] = rn2 ( 8 ) + 'A' ;
  2069.             mac_speaker ( obj , & melody ) ;
  2070. #endif
  2071.  
  2072.             obj->spe -= 1;
  2073.             if (!rn2(13)) {
  2074.             otmp = mkobj(POTION_CLASS, FALSE);
  2075.             if (objects[otmp->otyp].oc_magic) do {
  2076.                 otmp->otyp = rnd_class(POT_BOOZE, POT_WATER);
  2077.             } while (otmp->otyp == POT_SICKNESS);
  2078.             what = "A potion";
  2079.             } else {
  2080.             otmp = mkobj(FOOD_CLASS, FALSE);
  2081.             if (otmp->otyp == FOOD_RATION && !rn2(7))
  2082.                 otmp->otyp = LUMP_OF_ROYAL_JELLY;
  2083.             what = "Some food";
  2084.             }
  2085.             pline("%s spills out.", what);
  2086.             otmp->blessed = obj->blessed;
  2087.             otmp->cursed = obj->cursed;
  2088.             otmp->owt = weight(otmp);
  2089.             otmp = hold_another_object(otmp, u.uswallow ?
  2090.                            "Oops!  %s away from you!" :
  2091.                            "Oops!  %s to the floor!",
  2092.                            The(aobjnam(otmp, "slip")),
  2093.                            (const char *)0);
  2094.             makeknown(HORN_OF_PLENTY);
  2095.         } else
  2096.             pline(nothing_happens);
  2097.         break;
  2098.     default:
  2099.         pline("Sorry, I don't know how to use that.");
  2100.     xit:
  2101.         nomul(0);
  2102.         return 0;
  2103.     }
  2104.     nomul(0);
  2105.     return res;
  2106. }
  2107.  
  2108. #endif /* OVLB */
  2109.  
  2110. /*apply.c*/
  2111.