home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume16 / nethack31 / patch2d / patches02d
Text File  |  1993-06-16  |  57KB  |  2,043 lines
  1. *** /tmp/da10978    Tue Jun  1 16:13:38 1993
  2. --- src/exper.c    Wed Mar  3 14:21:59 1993
  3. ***************
  4. *** 24,29 ****
  5. --- 24,32 ----
  6.   experience(mtmp, nk)    /* return # of exp points for mtmp after nk killed */
  7.       register struct    monst *mtmp;
  8.       register int    nk;
  9. + #if defined(applec)
  10. + # pragma unused(nk)
  11. + #endif
  12.   {
  13.       register struct permonst *ptr = mtmp->data;
  14.       int    i, tmp, tmp2;
  15. *** /tmp/da10986    Tue Jun  1 16:13:40 1993
  16. --- src/explode.c    Mon May 17 14:04:31 1993
  17. ***************
  18. *** 1,4 ****
  19. ! /*    SCCS Id: @(#)explode.c 3.1    93/02/17
  20.   /*    Copyright (C) 1990 by Ken Arromdee */
  21.   /* NetHack may be freely redistributed.  See license for details. */
  22.   
  23. --- 1,4 ----
  24. ! /*    SCCS Id: @(#)explode.c 3.1    93/05/15    */
  25.   /*    Copyright (C) 1990 by Ken Arromdee */
  26.   /* NetHack may be freely redistributed.  See license for details. */
  27.   
  28. ***************
  29. *** 5,14 ****
  30.   #include "hack.h"
  31.   
  32.   /* Note: Arrays are column first, while the screen is row first */
  33. ! static int expl[3][3] = 
  34. ! { S_explode1, S_explode4, S_explode7,
  35. !   S_explode2, S_explode5, S_explode8,
  36. !   S_explode3, S_explode6, S_explode9 };
  37.   
  38.   /* Note: I had to choose one of three possible kinds of "type" when writing
  39.    * this function: a wand type (like in zap.c), an adtyp, or an object type.
  40. --- 5,15 ----
  41.   #include "hack.h"
  42.   
  43.   /* Note: Arrays are column first, while the screen is row first */
  44. ! static int expl[3][3] = {
  45. !     { S_explode1, S_explode4, S_explode7 },
  46. !     { S_explode2, S_explode5, S_explode8 },
  47. !     { S_explode3, S_explode6, S_explode9 }
  48. ! };
  49.   
  50.   /* Note: I had to choose one of three possible kinds of "type" when writing
  51.    * this function: a wand type (like in zap.c), an adtyp, or an object type.
  52. ***************
  53. *** 68,74 ****
  54.               }
  55.           }
  56.           /* can be both you and mtmp if you're swallowed */
  57. !         if (mtmp = m_at(i+x-1, j+y-1)) {
  58.               switch(adtyp) {
  59.               case AD_FIRE:
  60.                   explmask[i][j] = resists_fire(mtmp->data)
  61. --- 69,75 ----
  62.               }
  63.           }
  64.           /* can be both you and mtmp if you're swallowed */
  65. !         if ((mtmp = m_at(i+x-1, j+y-1)) != 0) {
  66.               switch(adtyp) {
  67.               case AD_FIRE:
  68.                   explmask[i][j] = resists_fire(mtmp->data)
  69. ***************
  70. *** 83,89 ****
  71.                   explmask[i][j] = 0;
  72.                   break;
  73.               }
  74. !         } else if (i+x-1 != u.ux || j+j-1 != u.uy)
  75.               explmask[i][j] = 0;
  76.   
  77.           if (cansee(i+x-1, j+y-1)) visible = TRUE;
  78. --- 84,90 ----
  79.                   explmask[i][j] = 0;
  80.                   break;
  81.               }
  82. !         } else if (i+x-1 != u.ux || j+y-1 != u.uy)
  83.               explmask[i][j] = 0;
  84.   
  85.           if (cansee(i+x-1, j+y-1)) visible = TRUE;
  86. *** /tmp/da11002    Tue Jun  1 16:13:44 1993
  87. --- src/files.c    Mon May 24 12:32:37 1993
  88. ***************
  89. *** 449,470 ****
  90.   
  91.   /* ----------  BEGIN FILE COMPRESSION HANDLING ----------- */
  92.   
  93.   /* compress file */
  94.   void
  95.   compress(filename)
  96.   const char *filename;
  97.   {
  98.   #ifdef COMPRESS
  99. !     char cmd[80];
  100. ! 
  101. !     Strcpy(cmd, COMPRESS);
  102. !     Strcat(cmd, " ");
  103. ! # ifdef COMPRESS_OPTIONS
  104. !     Strcat(cmd, COMPRESS_OPTIONS);
  105. !     Strcat(cmd, " ");
  106. ! # endif
  107. !     Strcat(cmd,filename);
  108. !     (void) system(cmd);
  109.   #endif
  110.   }
  111.   
  112. --- 449,534 ----
  113.   
  114.   /* ----------  BEGIN FILE COMPRESSION HANDLING ----------- */
  115.   
  116. + #ifdef COMPRESS
  117. + /* 
  118. +  * using system() is simpler, but opens up security holes and causes
  119. +  * problems on at least Interactive UNIX 3.0.1 (SVR3.2), where any
  120. +  * setuid is renounced by /bin/sh, so the files cannot be accessed.
  121. +  *
  122. +  * cf. child() in unixunix.c.
  123. +  */
  124. + void
  125. + docompress_file(filename, uncomp)
  126. + char *filename;
  127. + boolean uncomp;
  128. + {
  129. +     char *args[10];
  130. + # ifdef COMPRESS_OPTIONS
  131. +     char opts[80];
  132. + # endif
  133. +     int i = 0;
  134. +     int f;
  135. + 
  136. +     args[0] = COMPRESS;
  137. +     if (uncomp) args[++i] = "-d";    /* uncompress */
  138. + # ifdef COMPRESS_OPTIONS
  139. +     {
  140. +         /* we can't guarantee there's only one additional option, sigh */
  141. +         char *opt;
  142. +         boolean inword = FALSE;
  143. + 
  144. +         Strcpy(opts, COMPRESS_OPTIONS);
  145. +         opt = opts;
  146. +         while (*opt) {
  147. +         if ((*opt == ' ') || (*opt == '\t')) {
  148. +             if (inword) {
  149. +             *opt = '\0';
  150. +             inword = FALSE;
  151. +             }
  152. +         } else if (!inword) {
  153. +             args[++i] = opt;
  154. +             inword = TRUE;
  155. +         }
  156. +         opt++;
  157. +         }
  158. +     }
  159. + # endif
  160. +     args[++i] = filename;
  161. +     args[++i] = NULL;
  162. + 
  163. +     f = fork();
  164. +     if (f == 0) {    /* child */
  165. +         (void) execv(args[0], args);
  166. +         perror(NULL);
  167. +         pline("Exec to %scompress %s failed.",
  168. +             uncomp ? "un" : "", filename);
  169. +         exit(1);
  170. +     } else if (f == -1) {
  171. +         perror(NULL);
  172. +         pline("Fork to %scompress %s failed.",
  173. +             uncomp ? "un" : "", filename);
  174. +         return;
  175. +     }
  176. +     (void) signal(SIGINT, SIG_IGN);
  177. +     (void) signal(SIGQUIT, SIG_IGN);
  178. +     (void) wait((int *)0);
  179. +     (void) signal(SIGINT, (SIG_RET_TYPE) done1);
  180. + # ifdef WIZARD
  181. +     if (wizard) (void) signal(SIGQUIT, SIG_DFL);
  182. + # endif
  183. + }
  184. + #endif
  185. + 
  186.   /* compress file */
  187.   void
  188.   compress(filename)
  189.   const char *filename;
  190. + #ifdef applec
  191. + # pragma unused(filename)
  192. + #endif
  193.   {
  194.   #ifdef COMPRESS
  195. !     docompress_file(filename, FALSE);
  196.   #endif
  197.   }
  198.   
  199. ***************
  200. *** 473,497 ****
  201.   void
  202.   uncompress(filename)
  203.   const char *filename;
  204.   {
  205.   #ifdef COMPRESS
  206. !     char cmd[80], cfn[80];
  207.       int fd;
  208.   
  209. !     Strcpy(cfn,filename);
  210.   # ifdef COMPRESS_EXTENSION
  211. !     Strcat(cfn,COMPRESS_EXTENSION);
  212.   # endif
  213. !     if((fd = open(cfn,O_RDONLY)) >= 0) {
  214. !         (void) close(fd);
  215. !         Strcpy(cmd, COMPRESS);
  216. !         Strcat(cmd, " -d ");        /* uncompress */
  217. ! # ifdef COMPRESS_OPTIONS
  218. !         Strcat(cmd, COMPRESS_OPTIONS);
  219. !         Strcat(cmd, " ");
  220. ! # endif
  221. !         Strcat(cmd,cfn);
  222. !         (void) system(cmd);
  223.       }
  224.   #endif
  225.   }
  226. --- 537,557 ----
  227.   void
  228.   uncompress(filename)
  229.   const char *filename;
  230. + #ifdef applec
  231. + # pragma unused(filename)
  232. + #endif
  233.   {
  234.   #ifdef COMPRESS
  235. !     char cfn[80];
  236.       int fd;
  237.   
  238. !     Strcpy(cfn, filename);
  239.   # ifdef COMPRESS_EXTENSION
  240. !     Strcat(cfn, COMPRESS_EXTENSION);
  241.   # endif
  242. !     if ((fd = open(cfn, O_RDONLY)) >= 0) {
  243. !         (void) close(fd);
  244. !         docompress_file(cfn, TRUE);
  245.       }
  246.   #endif
  247.   }
  248. ***************
  249. *** 540,545 ****
  250. --- 600,608 ----
  251.   lock_file(filename, retryct)
  252.   const char *filename;
  253.   int retryct;
  254. + #ifdef applec
  255. + # pragma unused(filename, retryct)
  256. + #endif
  257.   {
  258.   #if defined(UNIX) || defined(VMS)
  259.       char *lockname;
  260. ***************
  261. *** 609,614 ****
  262. --- 672,680 ----
  263.   void
  264.   unlock_file(filename)
  265.   const char *filename;
  266. + #if defined(applec)
  267. + # pragma unused(filename)
  268. + #endif
  269.   {
  270.   #if defined(UNIX) || defined(VMS)
  271.       char *lockname;
  272. ***************
  273. *** 658,666 ****
  274.   #endif
  275.   
  276.       /* "filename" is an environment variable, so it should hang around */
  277. !     if (filename && ((fp = fopenp(filename, "r")) != (FILE *)0)) {
  278. !         configfile = filename;
  279. !         return(fp);
  280.       }
  281.   
  282.   #if defined(MICRO) || defined(MAC)
  283. --- 724,748 ----
  284.   #endif
  285.   
  286.       /* "filename" is an environment variable, so it should hang around */
  287. !     if (filename) {
  288. ! #ifdef UNIX
  289. !         if (access(filename, 4) == -1) {
  290. !             /* 4 is R_OK on newer systems */
  291. !             /* nasty sneaky attempt to read file through
  292. !              * NetHack's setuid permissions -- this is the only
  293. !              * place a file name may be wholly under the player's
  294. !              * control
  295. !              */
  296. !             raw_printf("Access to %s denied (%d).",
  297. !                     filename, errno);
  298. !             wait_synch();
  299. !             /* fall through to standard names */
  300. !         } else
  301. ! #endif
  302. !         if ((fp = fopenp(filename, "r")) != (FILE *)0) {
  303. !             configfile = filename;
  304. !             return(fp);
  305. !         }
  306.       }
  307.   
  308.   #if defined(MICRO) || defined(MAC)
  309. ***************
  310. *** 752,757 ****
  311. --- 834,842 ----
  312.   char        *buf;
  313.   char        *tmp_ramdisk;
  314.   char        *tmp_levels;
  315. + #if defined(applec)
  316. + # pragma unused(tmp_ramdisk,tmp_levels)
  317. + #endif
  318.   {
  319.       char        *bufp, *altp;
  320.   
  321. ***************
  322. *** 798,813 ****
  323.           (void) strncpy(tmp_levels, bufp, PATHLEN);
  324.   
  325.       } else if (!strncmpi(buf, "SAVE", 4)) {
  326.           char *ptr;
  327.           if (ptr = index(bufp, ';')) {
  328.               *ptr = '\0';
  329.   # ifdef MFLOPPY
  330.               if (*(ptr+1) == 'n' || *(ptr+1) == 'N') {
  331. -                 extern    int saveprompt;
  332.                   saveprompt = FALSE;
  333.               }
  334.   # endif
  335. !     }
  336.           (void) strncpy(SAVEP, bufp, PATHLEN);
  337.           append_slash(SAVEP);
  338.   #endif /* MICRO */
  339. --- 883,905 ----
  340.           (void) strncpy(tmp_levels, bufp, PATHLEN);
  341.   
  342.       } else if (!strncmpi(buf, "SAVE", 4)) {
  343. + # ifdef MFLOPPY
  344. +         extern    int saveprompt;
  345. + #endif
  346.           char *ptr;
  347.           if (ptr = index(bufp, ';')) {
  348.               *ptr = '\0';
  349.   # ifdef MFLOPPY
  350.               if (*(ptr+1) == 'n' || *(ptr+1) == 'N') {
  351.                   saveprompt = FALSE;
  352.               }
  353.   # endif
  354. !         }
  355. ! #ifdef    MFLOPPY
  356. !         else
  357. !             saveprompt = flags.asksavedisk;
  358. ! #endif
  359. ! 
  360.           (void) strncpy(SAVEP, bufp, PATHLEN);
  361.           append_slash(SAVEP);
  362.   #endif /* MICRO */
  363. ***************
  364. *** 836,854 ****
  365.           (void) get_uchars(fp, buf, bufp, &(monsyms[1]),
  366.                       MAXMCLASSES-1, "MONSTERS");
  367.   #ifdef AMIGA
  368.       } else if (!strncmpi(buf, "PATH", 4)) {
  369.           (void) strncpy(PATH, bufp, PATHLEN);
  370. - #endif
  371. - #ifdef AMII_GRAPHICS
  372.       } else if (!strncmpi(buf, "PENS", 3)) {
  373.           int i;
  374.           char *t;
  375. !         for (i = 0, t = strtok(bufp, ",");
  376. !                 t && i < 8;
  377. !                 t = strtok(NULL, ","), ++i) {
  378.               sscanf(t, "%hx", &flags.amii_curmap[i]);
  379.           }
  380.           amii_setpens();
  381.   #endif
  382.       } else
  383.           return 0;
  384. --- 928,959 ----
  385.           (void) get_uchars(fp, buf, bufp, &(monsyms[1]),
  386.                       MAXMCLASSES-1, "MONSTERS");
  387.   #ifdef AMIGA
  388. +     } else if (!strncmpi(buf, "FONT", 4)) {
  389. +         char *t;
  390. +         int size;
  391. +         extern void amii_set_text_font( char *, int );
  392. + 
  393. +         if( t = strchr( buf+5, ':' ) )
  394. +         {
  395. +             *t = 0;
  396. +             amii_set_text_font( buf+5, atoi( t + 1 ) );
  397. +             *t = ':';
  398. +         }
  399.       } else if (!strncmpi(buf, "PATH", 4)) {
  400.           (void) strncpy(PATH, bufp, PATHLEN);
  401.       } else if (!strncmpi(buf, "PENS", 3)) {
  402. + # ifdef AMII_GRAPHICS
  403.           int i;
  404.           char *t;
  405. !         extern void amii_setpens( void );
  406. ! 
  407. !         for (i = 0, t = strtok(bufp, ",/"); t != NULL;
  408. !                     t = strtok(NULL, ",/"), ++i)
  409. !         {
  410.               sscanf(t, "%hx", &flags.amii_curmap[i]);
  411.           }
  412.           amii_setpens();
  413. + # endif
  414.   #endif
  415.       } else
  416.           return 0;
  417. ***************
  418. *** 942,947 ****
  419. --- 1047,1055 ----
  420.   void
  421.   check_recordfile(dir)
  422.   const char *dir;
  423. + #if defined(applec)
  424. + # pragma unused(dir)
  425. + #endif
  426.   {
  427.   #if defined(UNIX) || defined(VMS)
  428.       int fd = open(RECORD, O_RDWR, 0);
  429. *** /tmp/da11010    Tue Jun  1 16:13:47 1993
  430. --- src/fountain.c    Wed May 19 10:08:25 1993
  431. ***************
  432. *** 1,4 ****
  433. ! /*    SCCS Id: @(#)fountain.c    3.1    93/02/13    */
  434.   /*    Copyright Scott R. Turner, srt@ucla, 10/27/86 */
  435.   /* NetHack may be freely redistributed.  See license for details. */
  436.   
  437. --- 1,4 ----
  438. ! /*    SCCS Id: @(#)fountain.c    3.1    93/05/18    */
  439.   /*    Copyright Scott R. Turner, srt@ucla, 10/27/86 */
  440.   /* NetHack may be freely redistributed.  See license for details. */
  441.   
  442. ***************
  443. *** 108,116 ****
  444.           pline("Water gushes forth from the overflowing fountain!");
  445.   
  446.       /* Put a pool at x, y */
  447. - 
  448.       levl[x][y].typ = POOL;
  449. ! 
  450.       water_damage(level.objects[x][y], FALSE, TRUE);
  451.   
  452.       if ((mtmp = m_at(x, y)) != 0)
  453. --- 108,115 ----
  454.           pline("Water gushes forth from the overflowing fountain!");
  455.   
  456.       /* Put a pool at x, y */
  457.       levl[x][y].typ = POOL;
  458. !     del_engr_at(x, y);
  459.       water_damage(level.objects[x][y], FALSE, TRUE);
  460.   
  461.       if ((mtmp = m_at(x, y)) != 0)
  462. ***************
  463. *** 513,524 ****
  464.               morehungry(rn1(30-ACURR(A_CON), 11));
  465.               vomit();
  466.               break;
  467. - #ifdef POLYSELF
  468.           case 10: pline("This water contains toxic wastes!");
  469.               You("undergo a freakish metamorphosis!");
  470.               polyself();
  471. !             break;
  472.   #endif
  473.           /* more odd messages --JJB */
  474.           case 11: You("hear clanking from the pipes....");
  475.               break;
  476. --- 512,525 ----
  477.               morehungry(rn1(30-ACURR(A_CON), 11));
  478.               vomit();
  479.               break;
  480.           case 10: pline("This water contains toxic wastes!");
  481.               You("undergo a freakish metamorphosis!");
  482. + #ifdef POLYSELF
  483.               polyself();
  484. ! #else
  485. !             newman();
  486.   #endif
  487. +             break;
  488.           /* more odd messages --JJB */
  489.           case 11: You("hear clanking from the pipes....");
  490.               break;
  491. *** /tmp/da11018    Tue Jun  1 16:13:50 1993
  492. --- src/hack.c    Tue Jun  1 10:42:03 1993
  493. ***************
  494. *** 1,4 ****
  495. ! /*    SCCS Id: @(#)hack.c    3.1    93/02/18    */
  496.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  497.   /* NetHack may be freely redistributed.  See license for details. */
  498.   
  499. --- 1,4 ----
  500. ! /*    SCCS Id: @(#)hack.c    3.1    93/05/18    */
  501.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  502.   /* NetHack may be freely redistributed.  See license for details. */
  503.   
  504. ***************
  505. *** 115,120 ****
  506. --- 115,124 ----
  507.           case SPIKED_PIT:
  508.           case PIT:
  509.               freeobj(otmp);
  510. +             /* vision kludge to get messages right;
  511. +                the pit will temporarily be seen even
  512. +                if this is one among multiple boulders */
  513. +             if (!Blind) viz_array[ry][rx] |= IN_SIGHT;
  514.               if (!flooreffects(otmp, rx, ry, "fall")) {
  515.               place_object(otmp, rx, ry);
  516.               otmp->nobj = fobj;
  517. ***************
  518. *** 126,132 ****
  519.                 The(xname(otmp)));
  520.               deltrap(ttmp);
  521.               delobj(otmp);
  522. !             delallobj(rx, ry);
  523.               if (cansee(rx,ry)) newsym(rx,ry);
  524.               continue;
  525.           case LEVEL_TELEP:
  526. --- 130,136 ----
  527.                 The(xname(otmp)));
  528.               deltrap(ttmp);
  529.               delobj(otmp);
  530. !             bury_objs(rx, ry);
  531.               if (cansee(rx,ry)) newsym(rx,ry);
  532.               continue;
  533.           case LEVEL_TELEP:
  534. ***************
  535. *** 286,292 ****
  536.       } else if (lev->typ == SDOOR) {
  537.       if (lev->doormask & D_TRAPPED) {
  538.           lev->doormask = D_NODOOR;
  539. !         b_trapped("secret door");
  540.       } else {
  541.           digtxt = "chew through the secret door.";
  542.           lev->doormask = D_BROKEN;
  543. --- 290,296 ----
  544.       } else if (lev->typ == SDOOR) {
  545.       if (lev->doormask & D_TRAPPED) {
  546.           lev->doormask = D_NODOOR;
  547. !         b_trapped("secret door", 0);
  548.       } else {
  549.           digtxt = "chew through the secret door.";
  550.           lev->doormask = D_BROKEN;
  551. ***************
  552. *** 300,306 ****
  553.       }
  554.       if (lev->doormask & D_TRAPPED) {
  555.           lev->doormask = D_NODOOR;
  556. !         b_trapped("door");
  557.       } else {
  558.           digtxt = "chew through the door.";
  559.           lev->doormask = D_BROKEN;
  560. --- 304,310 ----
  561.       }
  562.       if (lev->doormask & D_TRAPPED) {
  563.           lev->doormask = D_NODOOR;
  564. !         b_trapped("door", 0);
  565.       } else {
  566.           digtxt = "chew through the door.";
  567.           lev->doormask = D_BROKEN;
  568. ***************
  569. *** 513,518 ****
  570. --- 517,532 ----
  571.                   y = u.uy + u.dy;
  572.               } while(!isok(x, y) || bad_rock(x, y));
  573.           }
  574. +         /* turbulence might alter your actual destination */
  575. +         if (u.uinwater) {
  576. +             water_friction();
  577. +             if (!u.dx && !u.dy) {
  578. +                 nomul(0);
  579. +                 return;
  580. +             }
  581. +             x = u.ux + u.dx;
  582. +             y = u.uy + u.dy;
  583. +         }
  584.           if(!isok(x, y)) {
  585.               nomul(0);
  586.               return;
  587. ***************
  588. *** 783,789 ****
  589.   
  590.       /* now move the hero */
  591.       mtmp = m_at(x, y);
  592. -     if (u.uinwater) water_friction();
  593.       u.ux += u.dx;
  594.       u.uy += u.dy;
  595.       /* if safepet at destination then move the pet to the hero's
  596. --- 797,802 ----
  597. ***************
  598. *** 980,990 ****
  599.       if(IS_SINK(levl[u.ux][u.uy].typ) && Levitation)
  600.           dosinkfall();
  601.   #endif
  602. !     if(!flags.nopick && OBJ_AT(u.ux, u.uy) &&
  603. !        (!is_pool(u.ux,u.uy) || Underwater))
  604. !         pickup(1);
  605. !     else read_engr_at(u.ux,u.uy);
  606. !     if(trap = t_at(u.ux,u.uy))
  607.           dotrap(trap);    /* fall into pit, arrow trap, etc. */
  608.       if((mtmp = m_at(u.ux, u.uy)) && !u.uswallow) {
  609.           mtmp->mundetected = 0;
  610. --- 993,1000 ----
  611.       if(IS_SINK(levl[u.ux][u.uy].typ) && Levitation)
  612.           dosinkfall();
  613.   #endif
  614. !     pickup(1);
  615. !     if ((trap = t_at(u.ux,u.uy)) != 0)
  616.           dotrap(trap);    /* fall into pit, arrow trap, etc. */
  617.       if((mtmp = m_at(u.ux, u.uy)) && !u.uswallow) {
  618.           mtmp->mundetected = 0;
  619. ***************
  620. *** 1162,1172 ****
  621.       if (*u.ushops0)
  622.           u_left_shop(u.ushops_left, newlev);
  623.   
  624. !     if (!*u.uentered && !*u.ushops_entered) 
  625.           return;        /* no entrance messages necessary */
  626.   
  627.       /* Did we just enter a shop? */
  628. !     if (*u.ushops_entered && !newlev)
  629.               u_entered_shop(u.ushops_entered);
  630.   
  631.       for (ptr = &u.uentered[0]; *ptr; ptr++) {
  632. --- 1172,1182 ----
  633.       if (*u.ushops0)
  634.           u_left_shop(u.ushops_left, newlev);
  635.   
  636. !     if (!*u.uentered && !*u.ushops_entered)     /* implied by newlev */
  637.           return;        /* no entrance messages necessary */
  638.   
  639.       /* Did we just enter a shop? */
  640. !     if (*u.ushops_entered)
  641.               u_entered_shop(u.ushops_entered);
  642.   
  643.       for (ptr = &u.uentered[0]; *ptr; ptr++) {
  644. ***************
  645. *** 1176,1228 ****
  646.           /* vault.c insists that a vault remain a VAULT,
  647.            * and temples should remain TEMPLEs,
  648.            * but everything else gives a message only the first time */
  649. !         if(!newlev) 
  650. !            switch (rt) {
  651. !             case ZOO:
  652. !                pline("Welcome to David's treasure zoo!");
  653. !                 break;
  654. !             case SWAMP:
  655. !                 pline("It %s rather %s down here.",
  656. !                       Blind ? "feels" : "looks",
  657. !                       Blind ? "humid" : "muddy");
  658. !                 break;
  659. !             case COURT:
  660. !             You("enter an opulent throne room!");
  661. !                 break;
  662. !             case MORGUE:
  663. !                 if(midnight())
  664. !                 pline("Run away!  Run away!");
  665. !                 else
  666. !                 You("have an uncanny feeling...");
  667. !                 break;
  668. !             case BEEHIVE:
  669. !                 You("enter a giant beehive!");
  670. !                 break;
  671.   #ifdef ARMY
  672. !             case BARRACKS:
  673. !                 if(monstinroom(&mons[PM_SOLDIER], roomno) ||
  674. !                 monstinroom(&mons[PM_SERGEANT], roomno) ||
  675. !                 monstinroom(&mons[PM_LIEUTENANT], roomno) ||
  676. !                 monstinroom(&mons[PM_CAPTAIN], roomno))
  677. !                     You("enter a military barracks!");
  678. !                 else 
  679. !                 You("enter an abandoned barracks.");
  680. !                 break;
  681.   #endif
  682. !             case DELPHI:
  683. !                 if(monstinroom(&mons[PM_ORACLE], roomno))
  684. !                 verbalize("Hello, %s, welcome to Delphi!", plname);
  685. !                 break;
  686. !             case TEMPLE:
  687. !             intemple(roomno + ROOMOFFSET);
  688. !                 /* fall through */
  689. !             default:
  690. !                 rt = 0;
  691. !             } 
  692. !         else 
  693. !         rt = 0;
  694.   
  695. !         if(rt != 0) {
  696.           rooms[roomno].rtype = OROOM;
  697.           if (!search_special(rt)) {
  698.               /* No more room of that type */
  699. --- 1186,1240 ----
  700.           /* vault.c insists that a vault remain a VAULT,
  701.            * and temples should remain TEMPLEs,
  702.            * but everything else gives a message only the first time */
  703. !         switch (rt) {
  704. !         case ZOO:
  705. !             pline("Welcome to David's treasure zoo!");
  706. !             break;
  707. !         case SWAMP:
  708. !             pline("It %s rather %s down here.",
  709. !               Blind ? "feels" : "looks",
  710. !               Blind ? "humid" : "muddy");
  711. !             break;
  712. !         case COURT:
  713. !             You("enter an opulent throne room!");
  714. !             break;
  715. !         case MORGUE:
  716. !             if(midnight()) {
  717. ! #ifdef POLYSELF
  718. !             const char *run = locomotion(uasmon, "Run");
  719. !             pline("%s away!  %s away!", run, run);
  720. ! #else
  721. !             pline("Run away!  Run away!");
  722. ! #endif
  723. !             } else
  724. !             You("have an uncanny feeling...");
  725. !             break;
  726. !         case BEEHIVE:
  727. !             You("enter a giant beehive!");
  728. !             break;
  729.   #ifdef ARMY
  730. !         case BARRACKS:
  731. !             if(monstinroom(&mons[PM_SOLDIER], roomno) ||
  732. !             monstinroom(&mons[PM_SERGEANT], roomno) ||
  733. !             monstinroom(&mons[PM_LIEUTENANT], roomno) ||
  734. !             monstinroom(&mons[PM_CAPTAIN], roomno))
  735. !             You("enter a military barracks!");
  736. !             else 
  737. !             You("enter an abandoned barracks.");
  738. !             break;
  739.   #endif
  740. !         case DELPHI:
  741. !             if(monstinroom(&mons[PM_ORACLE], roomno))
  742. !             verbalize("Hello, %s, welcome to Delphi!", plname);
  743. !             break;
  744. !         case TEMPLE:
  745. !             intemple(roomno + ROOMOFFSET);
  746. !             /* fall through */
  747. !         default:
  748. !             rt = 0;
  749. !         } 
  750.   
  751. !         if (rt != 0) {
  752.           rooms[roomno].rtype = OROOM;
  753.           if (!search_special(rt)) {
  754.               /* No more room of that type */
  755. ***************
  756. *** 1302,1308 ****
  757.           return(0);
  758.       }
  759.       if(Levitation && !Is_airlevel(&u.uz) && !Is_waterlevel(&u.uz)) {
  760. !         You("cannot reach the floor.");
  761.           return(1);
  762.       }
  763.       pickup(-count);
  764. --- 1314,1320 ----
  765.           return(0);
  766.       }
  767.       if(Levitation && !Is_airlevel(&u.uz) && !Is_waterlevel(&u.uz)) {
  768. !         You("cannot reach the %s.", surface(u.ux,u.uy));
  769.           return(1);
  770.       }
  771.       pickup(-count);
  772. *** /tmp/da11034    Tue Jun  1 16:13:55 1993
  773. --- src/invent.c    Wed May 19 10:30:00 1993
  774. ***************
  775. *** 1,4 ****
  776. ! /*    SCCS Id: @(#)invent.c    3.1    92/12/11    */
  777.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  778.   /* NetHack may be freely redistributed.  See license for details. */
  779.   
  780. --- 1,4 ----
  781. ! /*    SCCS Id: @(#)invent.c    3.1    93/05/17    */
  782.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  783.   /* NetHack may be freely redistributed.  See license for details. */
  784.   
  785. ***************
  786. *** 21,26 ****
  787. --- 21,27 ----
  788.   static struct obj *FDECL(find_unpaid,(struct obj *,struct obj **));
  789.   static boolean NDECL(wearing_armor);
  790.   static boolean FDECL(is_worn,(struct obj *));
  791. + static boolean FDECL(is_fully_identified,(struct obj *));
  792.   #endif /* OVLB */
  793.   STATIC_DCL char FDECL(obj_to_let,(struct obj *));
  794.   
  795. ***************
  796. *** 28,38 ****
  797.   
  798.   static int lastinvnr = 51;    /* 0 ... 51 (never saved&restored) */
  799.   
  800. - char inv_order[] = {    /* manipulated in options.c, used below */
  801. -     AMULET_CLASS, WEAPON_CLASS, ARMOR_CLASS, FOOD_CLASS, SCROLL_CLASS,
  802. -     SPBOOK_CLASS, POTION_CLASS, RING_CLASS, WAND_CLASS, TOOL_CLASS, 
  803. -     GEM_CLASS, ROCK_CLASS, BALL_CLASS, CHAIN_CLASS, 0 };
  804. - 
  805.   #ifdef WIZARD
  806.   /* wizards can wish for venom, which will become an invisible inventory
  807.    * item without this.  putting it in inv_order would mean venom would
  808. --- 29,34 ----
  809. ***************
  810. *** 325,333 ****
  811.       struct obj *otmp, *otmp2;
  812.   
  813.       for (otmp = level.objects[x][y]; otmp; otmp = otmp2) {
  814. -         otmp2 = otmp->nexthere;
  815.           if (otmp == uball)
  816.               unpunish();
  817.           if (otmp == uchain)
  818.               continue;
  819.           delobj(otmp);
  820. --- 321,330 ----
  821.       struct obj *otmp, *otmp2;
  822.   
  823.       for (otmp = level.objects[x][y]; otmp; otmp = otmp2) {
  824.           if (otmp == uball)
  825.               unpunish();
  826. +         /* after unpunish(), or might get deallocated chain */
  827. +         otmp2 = otmp->nexthere;
  828.           if (otmp == uchain)
  829.               continue;
  830.           delobj(otmp);
  831. ***************
  832. *** 334,339 ****
  833. --- 331,426 ----
  834.       }
  835.   }
  836.   
  837. + /* move objects from fobj/nexthere lists to buriedobjlist, keeping position
  838. +  * information */
  839. + void
  840. + bury_objs(x, y)
  841. + int x, y;
  842. + {
  843. +     struct obj *otmp, *otmp2;
  844. + 
  845. +     for (otmp = level.objects[x][y]; otmp; otmp = otmp2) {
  846. +         if (otmp == uball)
  847. +             unpunish();
  848. +         /* after unpunish(), or might get deallocated chain */
  849. +         otmp2 = otmp->nexthere;
  850. +         if (otmp == uchain)
  851. +             continue;
  852. + #ifdef WALKIES
  853. +         if (otmp->otyp == LEASH && otmp->leashmon != 0)
  854. +             o_unleash(otmp);
  855. + #endif
  856. +         if (otmp->lamplit) {
  857. +             otmp->lamplit = 0;
  858. +             check_lamps();
  859. +         }
  860. +         freeobj(otmp);
  861. +         if (otmp->otyp == ROCK) {
  862. +             /* melts into burying material */
  863. +             obfree(otmp, (struct obj *)0);
  864. +             continue;
  865. +         }
  866. +         otmp->nexthere = (struct obj *)0;
  867. +         otmp->nobj = level.buriedobjlist;
  868. +         level.buriedobjlist = otmp;
  869. +     }
  870. +     /* don't expect any engravings here, but just in case */
  871. +     del_engr_at(x, y);
  872. +     newsym(x, y);
  873. + }
  874. + 
  875. + /* delete buried object */
  876. + void
  877. + delburiedobj(obj)
  878. + struct obj *obj;
  879. + {
  880. +     struct obj *otmp;
  881. +     if (obj == level.buriedobjlist)
  882. +         level.buriedobjlist = obj->nobj;
  883. +     else {
  884. +         for (otmp = level.buriedobjlist; otmp; otmp = otmp->nobj)
  885. +             if (otmp->nobj == obj) {
  886. +                 otmp->nobj = obj->nobj;
  887. +                 break;
  888. +             }
  889. +         if (!otmp) panic("error in delburiedobj");
  890. +     }
  891. +     obfree(obj, (struct obj *) 0);    /* frees contents also */
  892. + }
  893. + 
  894. + /* move objects from buriedobjlist to fobj/nexthere lists */
  895. + void
  896. + unearth_objs(x, y)
  897. + int x, y;
  898. + {
  899. +     struct obj *otmp, *otmp2, *prevobj;
  900. + 
  901. +     remove_cadavers(&level.buriedobjlist);
  902. + 
  903. +     prevobj = (struct obj *) 0;
  904. +     for (otmp = level.buriedobjlist; otmp; otmp = otmp2) {
  905. +         otmp2 = otmp->nobj;
  906. +         if (otmp->ox == x && otmp->oy == y) {
  907. +             if (prevobj)
  908. +                 prevobj->nobj = otmp2;
  909. +             else
  910. +                 level.buriedobjlist = otmp2;
  911. +             if (is_organic(otmp) && rn2(2)) {
  912. +                 /* rotted away */
  913. +                 obfree(otmp, (struct obj *) 0);
  914. +             } else {
  915. +                 otmp->nobj = fobj;
  916. +                 fobj = otmp;
  917. +                 place_object(otmp, x, y);
  918. +                 stackobj(otmp);
  919. +             }
  920. +         } else
  921. +             prevobj = otmp;
  922. +     }
  923. +     del_engr_at(x, y);
  924. +     newsym(x, y);
  925. + }
  926. + 
  927.   #endif /* OVL3 */
  928.   #ifdef OVL2
  929.   
  930. ***************
  931. *** 345,350 ****
  932. --- 432,448 ----
  933.   #ifdef WALKIES
  934.       if(obj->otyp == LEASH && obj->leashmon != 0) o_unleash(obj);
  935.   #endif
  936. +     if (obj->otyp == AMULET_OF_YENDOR ||
  937. +             obj->otyp == CANDELABRUM_OF_INVOCATION ||
  938. +             obj->otyp == BELL_OF_OPENING ||
  939. +             obj->otyp == SPE_BOOK_OF_THE_DEAD) {
  940. +         /* player might be doing something stupid, but we
  941. +          * can't guarantee that.  assume special artifacts
  942. +          * are indestructible via drawbridges, and exploding
  943. +          * chests, and golem creation, and ...
  944. +          */
  945. +         return;
  946. +     }
  947.       freeobj(obj);
  948.       newsym(obj->ox,obj->oy);
  949.       obfree(obj, (struct obj *) 0);    /* frees contents also */
  950. ***************
  951. *** 431,437 ****
  952.   
  953.       while(objchn) {
  954.           if(objchn->o_id == id) return(objchn);
  955. !         if (Is_container(objchn) && (temp = o_on(id,objchn->cobj)))
  956.               return temp;
  957.           objchn = objchn->nobj;
  958.       }
  959. --- 529,535 ----
  960.   
  961.       while(objchn) {
  962.           if(objchn->o_id == id) return(objchn);
  963. !         if (Has_contents(objchn) && (temp = o_on(id,objchn->cobj)))
  964.               return temp;
  965.           objchn = objchn->nobj;
  966.       }
  967. ***************
  968. *** 589,609 ****
  969.           else if ((!strcmp(word, "wear") &&
  970.               (otmp->oclass == TOOL_CLASS &&
  971.                otmp->otyp != BLINDFOLD && otmp->otyp != TOWEL))
  972.   #ifdef POLYSELF
  973.           || (!strcmp(word, "eat") && !is_edible(otmp))
  974.   #endif
  975. !         || (!strcmp(word, "can") &&
  976. !             (otmp->otyp != CORPSE))
  977.           || (!strcmp(word, "write with") &&
  978.               (otmp->oclass == TOOL_CLASS &&
  979.                otmp->otyp != MAGIC_MARKER && otmp->otyp != TOWEL))
  980.           || (!strcmp(word, "rub") &&
  981.               (otmp->oclass == TOOL_CLASS &&
  982.                otmp->otyp != OIL_LAMP && otmp->otyp != MAGIC_LAMP &&
  983.                otmp->otyp != BRASS_LANTERN))
  984. -         || (!strcmp(word, "wield") &&
  985. -             (otmp->oclass == TOOL_CLASS &&
  986. -              otmp->otyp != PICK_AXE && otmp->otyp != UNICORN_HORN))
  987.               )
  988.               foo--;
  989.           } else {
  990. --- 687,711 ----
  991.           else if ((!strcmp(word, "wear") &&
  992.               (otmp->oclass == TOOL_CLASS &&
  993.                otmp->otyp != BLINDFOLD && otmp->otyp != TOWEL))
  994. +         || (!strcmp(word, "wield") &&
  995. +             (otmp->oclass == TOOL_CLASS &&
  996. +              otmp->otyp != PICK_AXE && otmp->otyp != UNICORN_HORN))
  997.   #ifdef POLYSELF
  998.           || (!strcmp(word, "eat") && !is_edible(otmp))
  999.   #endif
  1000. !         || (!strcmp(word, "sacrifice") &&
  1001. !             (otmp->otyp != CORPSE &&
  1002. !              otmp->otyp != AMULET_OF_YENDOR &&
  1003. !              otmp->otyp != FAKE_AMULET_OF_YENDOR))
  1004.           || (!strcmp(word, "write with") &&
  1005.               (otmp->oclass == TOOL_CLASS &&
  1006.                otmp->otyp != MAGIC_MARKER && otmp->otyp != TOWEL))
  1007. +         || (!strcmp(word, "tin") &&
  1008. +             (otmp->otyp != CORPSE))
  1009.           || (!strcmp(word, "rub") &&
  1010.               (otmp->oclass == TOOL_CLASS &&
  1011.                otmp->otyp != OIL_LAMP && otmp->otyp != MAGIC_LAMP &&
  1012.                otmp->otyp != BRASS_LANTERN))
  1013.               )
  1014.               foo--;
  1015.           } else {
  1016. ***************
  1017. *** 782,787 ****
  1018. --- 884,897 ----
  1019.       return(!!(otmp->owornmask & (W_ARMOR | W_RING | W_AMUL | W_TOOL | W_WEP)));
  1020.   }
  1021.   
  1022. + static boolean
  1023. + is_fully_identified(otmp)
  1024. + register struct obj *otmp;
  1025. + {
  1026. +     return(otmp->known && otmp->dknown && otmp->bknown && otmp->rknown
  1027. +        && objects[otmp->otyp].oc_name_known);
  1028. + }
  1029. + 
  1030.   static NEARDATA const char removeables[] =
  1031.       { ARMOR_CLASS, WEAPON_CLASS, RING_CLASS, AMULET_CLASS, TOOL_CLASS, 0 };
  1032.   
  1033. ***************
  1034. *** 801,806 ****
  1035. --- 911,917 ----
  1036.       int FDECL((*ckfn),(OBJ_P)) = (int (*)()) 0;
  1037.       xchar allowgold = (u.ugold && !strcmp(word, "drop")) ? 1 : 0; /* BAH */
  1038.       register boolean takeoff = !strcmp(word, "take off");
  1039. +     register boolean ident = !strcmp(word, "identify");
  1040.       struct obj *obj;
  1041.       int unpaid, oc_of_sym;
  1042.   
  1043. ***************
  1044. *** 819,825 ****
  1045.       unpaid = 0;
  1046.       for (obj = invent; obj; obj = obj->nobj) {
  1047.           sym = (char) def_oc_syms[(int) obj->oclass];
  1048. !         if (!index(ilets, sym) && (!takeoff || is_worn(obj))) {
  1049.               ilets[iletct++] = sym;
  1050.               /* necessary because of index() being used above */
  1051.               ilets[iletct] = '\0';
  1052. --- 930,937 ----
  1053.       unpaid = 0;
  1054.       for (obj = invent; obj; obj = obj->nobj) {
  1055.           sym = (char) def_oc_syms[(int) obj->oclass];
  1056. !         if (!index(ilets, sym) && (!takeoff || is_worn(obj))
  1057. !             && (!ident || !is_fully_identified(obj))) {
  1058.               ilets[iletct++] = sym;
  1059.               /* necessary because of index() being used above */
  1060.               ilets[iletct] = '\0';
  1061. ***************
  1062. *** 828,834 ****
  1063.           if (obj->unpaid) unpaid = 1;
  1064.       }
  1065.   
  1066. !     if (!takeoff && (unpaid || invent)) {
  1067.           ilets[iletct++] = ' ';
  1068.           if (unpaid) ilets[iletct++] = 'u';
  1069.           if (invent) ilets[iletct++] = 'a';
  1070. --- 940,949 ----
  1071.           if (obj->unpaid) unpaid = 1;
  1072.       }
  1073.   
  1074. !     if (ident && !iletct) {
  1075. !         You("have already identified all your possessions.");
  1076. !         return -1;        /* special case for seffects(read.c) */
  1077. !     } else if (!takeoff && (unpaid || invent)) {
  1078.           ilets[iletct++] = ' ';
  1079.           if (unpaid) ilets[iletct++] = 'u';
  1080.           if (invent) ilets[iletct++] = 'a';
  1081. ***************
  1082. *** 938,946 ****
  1083.           if(ilet == 'z') ilet = 'A'; else ilet++;
  1084.           otmp2 = otmp->nobj;
  1085.           if (olets && *olets && otmp->oclass != *olets) continue;
  1086. !         if(takeoff && !is_worn(otmp)) continue;
  1087. !         if(ckfn && !(*ckfn)(otmp)) continue;
  1088. !         if(!allflag) {
  1089.               Strcpy(qbuf, ininv ?
  1090.                   xprname(otmp, ilet, !nodot, 0L) : doname(otmp));
  1091.               Strcat(qbuf, "?");
  1092. --- 1053,1062 ----
  1093.           if(ilet == 'z') ilet = 'A'; else ilet++;
  1094.           otmp2 = otmp->nobj;
  1095.           if (olets && *olets && otmp->oclass != *olets) continue;
  1096. !         if (takeoff && !is_worn(otmp)) continue;
  1097. !         if (ident && is_fully_identified(otmp)) continue;
  1098. !         if (ckfn && !(*ckfn)(otmp)) continue;
  1099. !         if (!allflag) {
  1100.               Strcpy(qbuf, ininv ?
  1101.                   xprname(otmp, ilet, !nodot, 0L) : doname(otmp));
  1102.               Strcat(qbuf, "?");
  1103. ***************
  1104. *** 981,986 ****
  1105. --- 1097,1104 ----
  1106.           default:
  1107.               break;
  1108.           case 'q':
  1109. +             /* special case for seffects() */
  1110. +             if (ident) cnt = -1;
  1111.               goto ret;
  1112.           }
  1113.       }
  1114. ***************
  1115. *** 1111,1117 ****
  1116.           } else
  1117.           return (*last_found = list);
  1118.       }
  1119. !     if (Is_container(list) && list->cobj) {
  1120.           if ((obj = find_unpaid(list->cobj, last_found)) != 0)
  1121.           return obj;
  1122.       }
  1123. --- 1229,1235 ----
  1124.           } else
  1125.           return (*last_found = list);
  1126.       }
  1127. !     if (Has_contents(list)) {
  1128.           if ((obj = find_unpaid(list->cobj, last_found)) != 0)
  1129.           return obj;
  1130.       }
  1131. ***************
  1132. *** 1136,1142 ****
  1133.       register struct obj *otmp;
  1134.       struct obj *z_obj;
  1135.       register char ilet;
  1136. !     char *invlet = inv_order;
  1137.       int classcount;
  1138.   #if defined(LINT) || defined(GCC_WARN)
  1139.       int save_unpaid = 0;
  1140. --- 1254,1260 ----
  1141.       register struct obj *otmp;
  1142.       struct obj *z_obj;
  1143.       register char ilet;
  1144. !     char *invlet = flags.inv_order;
  1145.       int classcount;
  1146.   #if defined(LINT) || defined(GCC_WARN)
  1147.       int save_unpaid = 0;
  1148. ***************
  1149. *** 1161,1167 ****
  1150.           if (do_containers) {    /* single non-inventory object */
  1151.               z_obj = (struct obj *) 0;
  1152.               if ((otmp = find_unpaid(invent, &z_obj)) != 0)
  1153. !             pline(xprname(otmp, CONTAINED_SYM, TRUE,
  1154.                        (show_cost ? unpaid_cost(otmp) : 0L)));
  1155.               else
  1156.               impossible(
  1157. --- 1279,1286 ----
  1158.           if (do_containers) {    /* single non-inventory object */
  1159.               z_obj = (struct obj *) 0;
  1160.               if ((otmp = find_unpaid(invent, &z_obj)) != 0)
  1161. !             pline("%s",
  1162. !                   xprname(otmp, CONTAINED_SYM, TRUE,
  1163.                        (show_cost ? unpaid_cost(otmp) : 0L)));
  1164.               else
  1165.               impossible(
  1166. ***************
  1167. *** 1169,1175 ****
  1168.           } else {
  1169.               for(otmp = invent; otmp; otmp = otmp->nobj) {
  1170.               if (otmp->invlet == lets[0]) {
  1171. !                 pline(xprname(otmp, lets[0], TRUE,
  1172.                        (show_cost ? unpaid_cost(otmp) : 0L)));
  1173.                   break;
  1174.               }
  1175. --- 1288,1295 ----
  1176.           } else {
  1177.               for(otmp = invent; otmp; otmp = otmp->nobj) {
  1178.               if (otmp->invlet == lets[0]) {
  1179. !                 pline("%s",
  1180. !                   xprname(otmp, lets[0], TRUE,
  1181.                        (show_cost ? unpaid_cost(otmp) : 0L)));
  1182.                   break;
  1183.               }
  1184. ***************
  1185. *** 1227,1233 ****
  1186.            *  have unpaid items that have been already listed.
  1187.            */
  1188.           for (otmp = invent; otmp; otmp = otmp->nobj) {
  1189. !         if (Is_container(otmp) && otmp->cobj) {
  1190.               z_obj = (struct obj *) 0;    /* haven't found any */
  1191.               while (find_unpaid(otmp->cobj, (struct obj **)&z_obj)) {
  1192.               totcost += cost = unpaid_cost(z_obj);
  1193. --- 1347,1353 ----
  1194.            *  have unpaid items that have been already listed.
  1195.            */
  1196.           for (otmp = invent; otmp; otmp = otmp->nobj) {
  1197. !         if (Has_contents(otmp)) {
  1198.               z_obj = (struct obj *) 0;    /* haven't found any */
  1199.               while (find_unpaid(otmp->cobj, (struct obj **)&z_obj)) {
  1200.               totcost += cost = unpaid_cost(z_obj);
  1201. ***************
  1202. *** 1263,1269 ****
  1203.   
  1204.       while (list) {
  1205.       if (list->unpaid) count++;
  1206. !     if (Is_container(list) && list->cobj)
  1207.           count += count_unpaid(list->cobj);
  1208.       list = list->nobj;
  1209.       }
  1210. --- 1383,1389 ----
  1211.   
  1212.       while (list) {
  1213.       if (list->unpaid) count++;
  1214. !     if (Has_contents(list))
  1215.           count += count_unpaid(list->cobj);
  1216.       list = list->nobj;
  1217.       }
  1218. ***************
  1219. *** 1361,1367 ****
  1220.       const char *verb = Blind ? "feel" : "see";
  1221.       const char *dfeature = (char*) 0;
  1222.       char fbuf[BUFSZ], fbuf2[BUFSZ];
  1223. -     int ct;
  1224.       boolean no_article = FALSE;
  1225.       winid tmpwin;
  1226.   
  1227. --- 1481,1486 ----
  1228. ***************
  1229. *** 1449,1463 ****
  1230.       }
  1231.       /* we know there is something here */
  1232.   
  1233. !     /* find out if there is more than one object there */
  1234. !     for (ct = 0, otmp = otmp0; otmp; otmp = otmp->nexthere)
  1235. !         if (++ct > 1) break;
  1236. ! 
  1237. !     if (ct == 1) {
  1238.           if (dfeature) pline(fbuf);
  1239.           You("%s here %s.", verb, doname(otmp0));
  1240.       } else {
  1241. !         display_nhwindow(NHW_MESSAGE, FALSE);
  1242.           tmpwin = create_nhwindow(NHW_MENU);
  1243.           if(dfeature) {
  1244.           putstr(tmpwin, 0, fbuf);
  1245. --- 1568,1579 ----
  1246.       }
  1247.       /* we know there is something here */
  1248.   
  1249. !     if (!otmp0->nexthere) {
  1250. !         /* only one object */
  1251.           if (dfeature) pline(fbuf);
  1252.           You("%s here %s.", verb, doname(otmp0));
  1253.       } else {
  1254. !         display_nhwindow(WIN_MESSAGE, FALSE);
  1255.           tmpwin = create_nhwindow(NHW_MENU);
  1256.           if(dfeature) {
  1257.           putstr(tmpwin, 0, fbuf);
  1258. ***************
  1259. *** 1542,1547 ****
  1260. --- 1658,1667 ----
  1261.       /* see burn_lamps() for a reference for the magic "25" */
  1262.       if (Is_candle(obj) && obj->age/25 != otmp->age/25)
  1263.           return(FALSE);
  1264. + 
  1265. +     /* don't merge surcharged item with base-cost item */
  1266. +     if (obj->unpaid && !same_price(obj, otmp))
  1267. +         return FALSE;
  1268.   
  1269.   /* if they have names, make sure they're the same */
  1270.       if ( (obj->onamelth != otmp->onamelth &&
  1271. *** /tmp/da11042    Tue Jun  1 16:13:58 1993
  1272. --- src/lock.c    Tue Jun  1 12:07:19 1993
  1273. ***************
  1274. *** 1,8 ****
  1275. ! /*    SCCS Id: @(#)lock.c    3.1    92/09/02
  1276.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1277.   /* NetHack may be freely redistributed.  See license for details. */
  1278.   
  1279. ! #include    "hack.h"
  1280.   
  1281.   #define CONTAINER_BITS 0    /* box options not [yet?] implemented */
  1282.   
  1283. --- 1,8 ----
  1284. ! /*    SCCS Id: @(#)lock.c    3.1    93/05/28    */
  1285.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1286.   /* NetHack may be freely redistributed.  See license for details. */
  1287.   
  1288. ! #include "hack.h"
  1289.   
  1290.   #define CONTAINER_BITS 0    /* box options not [yet?] implemented */
  1291.   
  1292. ***************
  1293. *** 18,23 ****
  1294. --- 18,24 ----
  1295.   
  1296.   #ifdef OVLB
  1297.   
  1298. + static const char *NDECL(lock_action);
  1299.   static boolean FDECL(obstructed,(int,int));
  1300.   static void FDECL(chest_shatter_msg, (struct obj *));
  1301.   
  1302. ***************
  1303. *** 41,46 ****
  1304. --- 42,77 ----
  1305.              xlock.door_or_box && (xlock.door == &levl[x][y])); 
  1306.   }
  1307.   
  1308. + /* produce an occupation string appropriate for the current activity */
  1309. + static const char *
  1310. + lock_action()
  1311. + {
  1312. +     /* "unlocking"+2 == "locking" */
  1313. +     static const char *actions[] = {
  1314. +         /* [0] */    "unlocking the door",
  1315. +         /* [1] */    "unlocking the chest",
  1316. +         /* [2] */    "unlocking the box",
  1317. +         /* [3] */    "picking the lock"
  1318. +     };
  1319. + 
  1320. +     /* if the target is currently unlocked, we're trying to lock it now */
  1321. +     if (xlock.door_or_box && !(xlock.door->doormask & D_LOCKED))
  1322. +         return actions[0]+2;    /* "locking the door" */
  1323. +     else if (!xlock.door_or_box && !xlock.box->olocked)
  1324. +         return xlock.box->otyp == CHEST ? actions[1]+2 : actions[2]+2;
  1325. +     /* otherwise we're trying to unlock it */
  1326. +     else if (xlock.picktyp == LOCK_PICK)
  1327. +         return actions[3];    /* "picking the lock" */
  1328. + #ifdef TOURIST
  1329. +     else if (xlock.picktyp == CREDIT_CARD)
  1330. +         return actions[3];    /* same as lock_pick */
  1331. + #endif
  1332. +     else if (xlock.door_or_box)
  1333. +         return actions[0];    /* "unlocking the door" */
  1334. +     else
  1335. +         return xlock.box->otyp == CHEST ? actions[1] : actions[2];
  1336. + }
  1337. + 
  1338.   STATIC_PTR
  1339.   int
  1340.   picklock()    /* try to open/close a lock */
  1341. ***************
  1342. *** 73,83 ****
  1343.          || nohands(uasmon)
  1344.   #endif
  1345.          ) {
  1346. !         You("give up your attempt to %s the lock.",
  1347. !           (xlock.door_or_box ? !(xlock.door->doormask & D_LOCKED) :
  1348. !            !xlock.box->olocked) ? "lock" :
  1349. !           ((xlock.picktyp == LOCK_PICK) ? "pick" : "open" ));
  1350. ! 
  1351.           exercise(A_DEX, TRUE);    /* even if you don't succeed */
  1352.           return((xlock.usedtime = 0));
  1353.       }
  1354. --- 104,110 ----
  1355.          || nohands(uasmon)
  1356.   #endif
  1357.          ) {
  1358. !         You("give up your attempt at %s.", lock_action());
  1359.           exercise(A_DEX, TRUE);    /* even if you don't succeed */
  1360.           return((xlock.usedtime = 0));
  1361.       }
  1362. ***************
  1363. *** 84,95 ****
  1364.   
  1365.       if(rn2(100) > xlock.chance) return(1);        /* still busy */
  1366.   
  1367.       if(xlock.door_or_box) {
  1368. -         You("succeed in %sing the lock.",
  1369. -           !(xlock.door->doormask & D_LOCKED) ? "lock" :
  1370. -           ((xlock.picktyp == LOCK_PICK) ? "pick" : "open" ));
  1371.           if(xlock.door->doormask & D_TRAPPED) {
  1372. !             b_trapped("door");
  1373.               xlock.door->doormask = D_NODOOR;
  1374.               unblock_point(u.ux+u.dx, u.uy+u.dy);
  1375.               newsym(u.ux+u.dx, u.uy+u.dy);
  1376. --- 111,120 ----
  1377.   
  1378.       if(rn2(100) > xlock.chance) return(1);        /* still busy */
  1379.   
  1380. +     You("succeed in %s.", lock_action());
  1381.       if(xlock.door_or_box) {
  1382.           if(xlock.door->doormask & D_TRAPPED) {
  1383. !             b_trapped("door", FINGER);
  1384.               xlock.door->doormask = D_NODOOR;
  1385.               unblock_point(u.ux+u.dx, u.uy+u.dy);
  1386.               newsym(u.ux+u.dx, u.uy+u.dy);
  1387. ***************
  1388. *** 97,105 ****
  1389.           xlock.door->doormask = D_CLOSED;
  1390.           else xlock.door->doormask = D_LOCKED;
  1391.       } else {
  1392. -         You("succeed in %sing the lock.",
  1393. -           (!xlock.box->olocked) ? "lock" :
  1394. -           (xlock.picktyp == LOCK_PICK) ? "pick" : "open" );
  1395.           xlock.box->olocked = !xlock.box->olocked;
  1396.           if(xlock.box->otrapped)    
  1397.           (void) chest_trap(xlock.box, FINGER, FALSE);
  1398. --- 122,127 ----
  1399. ***************
  1400. *** 152,166 ****
  1401.       xlock.box->olocked = 0;
  1402.       xlock.box->obroken = 1;
  1403.       if(!xlock.picktyp && !rn2(3)) {
  1404. !         register struct monst *shkp;
  1405.           long loss = 0L;
  1406.   
  1407. ! #ifdef GCC_WARN
  1408. !         shkp = (struct monst *) 0;
  1409. ! #endif
  1410.   
  1411. -         if(*u.ushops) shkp = shop_keeper(*u.ushops);
  1412. - 
  1413.           pline("In fact, you've totally destroyed %s.",
  1414.             the(xname(xlock.box)));
  1415.   
  1416. --- 174,186 ----
  1417.       xlock.box->olocked = 0;
  1418.       xlock.box->obroken = 1;
  1419.       if(!xlock.picktyp && !rn2(3)) {
  1420. !         struct monst *shkp;
  1421. !         boolean costly;
  1422.           long loss = 0L;
  1423.   
  1424. !         costly = (*u.ushops && costly_spot(u.ux, u.uy));
  1425. !         shkp = costly ? shop_keeper(*u.ushops) : 0;
  1426.   
  1427.           pline("In fact, you've totally destroyed %s.",
  1428.             the(xname(xlock.box)));
  1429.   
  1430. ***************
  1431. *** 169,175 ****
  1432.           otmp2 = otmp->nobj;
  1433.           if(!rn2(3) || otmp->oclass == POTION_CLASS) {
  1434.               chest_shatter_msg(otmp);
  1435. !             if(*u.ushops && costly_spot(u.ux, u.uy))
  1436.                   loss += stolen_value(otmp, u.ux, u.uy,
  1437.                            (boolean)shkp->mpeaceful, TRUE);
  1438.               if (otmp->quan == 1L) {
  1439. --- 189,195 ----
  1440.           otmp2 = otmp->nobj;
  1441.           if(!rn2(3) || otmp->oclass == POTION_CLASS) {
  1442.               chest_shatter_msg(otmp);
  1443. !             if (costly)
  1444.                   loss += stolen_value(otmp, u.ux, u.uy,
  1445.                            (boolean)shkp->mpeaceful, TRUE);
  1446.               if (otmp->quan == 1L) {
  1447. ***************
  1448. *** 184,191 ****
  1449.           stackobj(otmp);
  1450.           }
  1451.           xlock.box->cobj = (struct obj *) 0;    /* no contents */
  1452. !         if(*u.ushops && costly_spot(u.ux, u.uy))
  1453. !         loss += stolen_value(otmp, u.ux, u.uy,
  1454.                            (boolean)shkp->mpeaceful, TRUE);
  1455.           if(loss) You("owe %ld zorkmids for objects destroyed.", loss);
  1456.           delobj(xlock.box);
  1457. --- 204,211 ----
  1458.           stackobj(otmp);
  1459.           }
  1460.           xlock.box->cobj = (struct obj *) 0;    /* no contents */
  1461. !         if (costly)
  1462. !         loss += stolen_value(xlock.box, u.ux, u.uy,
  1463.                            (boolean)shkp->mpeaceful, TRUE);
  1464.           if(loss) You("owe %ld zorkmids for objects destroyed.", loss);
  1465.           delobj(xlock.box);
  1466. ***************
  1467. *** 216,232 ****
  1468.       ch = 0;        /* GCC myopia */
  1469.   #endif
  1470.       picktyp = pick->otyp;
  1471. !     if(xlock.usedtime && picktyp == xlock.picktyp) {
  1472.   
  1473. !         You("resume your attempt to %s the lock.",
  1474. !           (xlock.door_or_box ? !(xlock.door->doormask & D_LOCKED) :
  1475. !            !xlock.box->olocked) ? "lock" :
  1476. !           ((xlock.picktyp == LOCK_PICK) ? "pick" : "open" ));
  1477. ! 
  1478. !         set_occupation(picklock,
  1479. !                (picktyp == LOCK_PICK) ? "picking the lock" :
  1480. !                             "opening the lock",  0);
  1481. !         return(1);
  1482.       }
  1483.   
  1484.   #ifdef POLYSELF
  1485. --- 236,247 ----
  1486.       ch = 0;        /* GCC myopia */
  1487.   #endif
  1488.       picktyp = pick->otyp;
  1489. !     if (xlock.usedtime && picktyp == xlock.picktyp) {
  1490. !         const char *action = lock_action();
  1491.   
  1492. !         You("resume your attempt at %s.", action);
  1493. !         set_occupation(picklock, action, 0);
  1494. !         return(1);
  1495.       }
  1496.   
  1497.   #ifdef POLYSELF
  1498. ***************
  1499. *** 381,389 ****
  1500.       xlock.chance = ch;
  1501.       xlock.picktyp = picktyp;
  1502.       xlock.usedtime = 0;
  1503. !     set_occupation(picklock,
  1504. !                (picktyp == LOCK_PICK) ? "picking the lock" :
  1505. !                         "opening the lock",  0);
  1506.       return(1);
  1507.   }
  1508.   
  1509. --- 396,402 ----
  1510.       xlock.chance = ch;
  1511.       xlock.picktyp = picktyp;
  1512.       xlock.usedtime = 0;
  1513. !     set_occupation(picklock, lock_action(), 0);
  1514.       return(1);
  1515.   }
  1516.   
  1517. ***************
  1518. *** 522,528 ****
  1519.       if (rnl(20) < (ACURRSTR+ACURR(A_DEX)+ACURR(A_CON))/3) {
  1520.           pline("The door opens.");
  1521.           if(door->doormask & D_TRAPPED) {
  1522. !         b_trapped("door");
  1523.           door->doormask = D_NODOOR;
  1524.           } else
  1525.           door->doormask = D_ISOPEN;
  1526. --- 535,541 ----
  1527.       if (rnl(20) < (ACURRSTR+ACURR(A_DEX)+ACURR(A_CON))/3) {
  1528.           pline("The door opens.");
  1529.           if(door->doormask & D_TRAPPED) {
  1530. !         b_trapped("door", FINGER);
  1531.           door->doormask = D_NODOOR;
  1532.           } else
  1533.           door->doormask = D_ISOPEN;
  1534. ***************
  1535. *** 706,711 ****
  1536. --- 719,733 ----
  1537.       case WAN_LOCKING:
  1538.       case SPE_WIZARD_LOCK:
  1539.           if (obstructed(x,y)) return 0;
  1540. +         /* Don't allow doors to close over traps.  This is for pits */
  1541. +         /* & trap doors, but is it ever OK for anything else? */
  1542. +         if (t_at(x,y)) {
  1543. +         /* maketrap() clears doormask, so it should be NODOOR */
  1544. +         pline(
  1545. +     "A cloud of dust springs up in the doorway, but quickly dissipates.");
  1546. +         return 0;
  1547. +         }
  1548. + 
  1549.           switch (door->doormask & ~D_TRAPPED) {
  1550.           case D_CLOSED:
  1551.           msg = "The door locks!";
  1552. *** /tmp/da11050    Tue Jun  1 16:14:01 1993
  1553. --- src/mail.c    Mon May 17 14:04:38 1993
  1554. ***************
  1555. *** 1,4 ****
  1556. ! /*    SCCS Id: @(#)mail.c    3.1    92/11/14    */
  1557.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1558.   /* NetHack may be freely redistributed.  See license for details. */
  1559.   
  1560. --- 1,4 ----
  1561. ! /*    SCCS Id: @(#)mail.c    3.1    93/05/15    */
  1562.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1563.   /* NetHack may be freely redistributed.  See license for details. */
  1564.   
  1565. ***************
  1566. *** 48,54 ****
  1567.   #  include <sys/stat.h>
  1568.   #  include <pwd.h>
  1569.   /* DON'T trust all Unices to declare getpwuid() in <pwd.h> */
  1570. ! #  if !defined(_BULL_SOURCE) && !defined(sgi)
  1571.   /* DO trust all SVR4 to typedef uid_t in <sys/types.h> (probably to a long) */
  1572.   #   if defined(POSIX_TYPES) || defined(SVR4) || defined(HPUX)
  1573.   extern struct passwd *FDECL(getpwuid,(uid_t));
  1574. --- 48,54 ----
  1575.   #  include <sys/stat.h>
  1576.   #  include <pwd.h>
  1577.   /* DON'T trust all Unices to declare getpwuid() in <pwd.h> */
  1578. ! #  if !defined(_BULL_SOURCE) && !defined(sgi) && !defined(_M_UNIX)
  1579.   /* DO trust all SVR4 to typedef uid_t in <sys/types.h> (probably to a long) */
  1580.   #   if defined(POSIX_TYPES) || defined(SVR4) || defined(HPUX)
  1581.   extern struct passwd *FDECL(getpwuid,(uid_t));
  1582. ***************
  1583. *** 368,377 ****
  1584.   
  1585.       message_seen = TRUE;
  1586.   # ifdef NO_MAILREADER
  1587. !     verbalize("Hello, %s!  You have some mail in the outside world.", plname);
  1588. ! # else
  1589.       verbalize("Hello, %s!  %s.", plname, info->display_txt);
  1590.   
  1591.       if (info->message_typ) {
  1592.       struct obj *obj = mksobj(SCR_MAIL, FALSE, FALSE);
  1593.       if (distu(md->mx,md->my) > 2)
  1594. --- 368,382 ----
  1595.   
  1596.       message_seen = TRUE;
  1597.   # ifdef NO_MAILREADER
  1598. !     if (info->message_typ) {
  1599. !     verbalize("Hello, %s!  You have some mail in the outside world.", plname);
  1600. !     goto go_back;
  1601. !     }    
  1602. ! # endif /* NO_MAILREADER */
  1603. ! 
  1604.       verbalize("Hello, %s!  %s.", plname, info->display_txt);
  1605.   
  1606. + # ifndef NO_MAILREADER
  1607.       if (info->message_typ) {
  1608.       struct obj *obj = mksobj(SCR_MAIL, FALSE, FALSE);
  1609.       if (distu(md->mx,md->my) > 2)
  1610. ***************
  1611. *** 435,453 ****
  1612.   readmail(otmp)
  1613.   struct obj *otmp;
  1614.   {
  1615. - #ifdef AMIGA
  1616.       char *junk[]={
  1617. !     "It reads:  \"Please disregard previous letter.\"",
  1618. !     "It reads:  \"Welcome to NetHack 3.1!\"",
  1619. !     "It reads:  \"Only Amiga makes it possible.\"",
  1620. !     "It reads:  \"CATS have all the answers.\"",
  1621. !     "It reads:  \"Report bugs to nethack-bugs@linc.cis.upenn.edu\""
  1622.       };
  1623.   
  1624. !     pline(junk[rn2(SIZE(junk))]);
  1625. ! #else
  1626. !     pline("It reads:  \"Please disregard previous letter.\"");
  1627. ! #endif
  1628.   }
  1629.   
  1630.   #endif /* OVLB */
  1631. --- 440,456 ----
  1632.   readmail(otmp)
  1633.   struct obj *otmp;
  1634.   {
  1635.       char *junk[]={
  1636. !     "Please disregard previous letter.",
  1637. !     "Welcome to NetHack 3.1!",
  1638. ! #ifdef AMIGA
  1639. !     "Only Amiga makes it possible.",
  1640. !     "CATS have all the answers.",
  1641. ! #endif
  1642. !     "Report bugs to nethack-bugs@linc.cis.upenn.edu"
  1643.       };
  1644.   
  1645. !     pline("It reads:  \"%s\"", junk[rn2(SIZE(junk))]);
  1646.   }
  1647.   
  1648.   #endif /* OVLB */
  1649. ***************
  1650. *** 552,562 ****
  1651.   struct obj *otmp;
  1652.   {
  1653.   #  ifdef SHELL    /* can't access mail reader without spawning subprocess */
  1654. !     char *p, *cmd, buf[BUFSZ], qbuf[BUFSZ];
  1655.   
  1656.       /* there should be a command hidden beyond the object name */
  1657. !     p = otmp->onamelth ? ONAME(otmp) : "";
  1658. !     cmd = (strlen(p) + 1 < otmp->onamelth) ? eos(p) + 1 : (char *) 0;
  1659.       if (!cmd || !*cmd) cmd = "SPAWN";
  1660.   
  1661.       Sprintf(qbuf, "System command (%s)", cmd);
  1662. --- 555,568 ----
  1663.   struct obj *otmp;
  1664.   {
  1665.   #  ifdef SHELL    /* can't access mail reader without spawning subprocess */
  1666. !     const char *txt, *cmd;
  1667. !     char *p, buf[BUFSZ], qbuf[BUFSZ];
  1668. !     int len;
  1669.   
  1670.       /* there should be a command hidden beyond the object name */
  1671. !     txt = otmp->onamelth ? ONAME(otmp) : "";
  1672. !     len = strlen(txt);
  1673. !     cmd = (len + 1 < otmp->onamelth) ? txt + len + 1 : (char *) 0;
  1674.       if (!cmd || !*cmd) cmd = "SPAWN";
  1675.   
  1676.       Sprintf(qbuf, "System command (%s)", cmd);
  1677. *** /tmp/da11058    Tue Jun  1 16:14:03 1993
  1678. --- src/makemon.c    Mon May 24 16:40:28 1993
  1679. ***************
  1680. *** 1,4 ****
  1681. ! /*    SCCS Id: @(#)makemon.c    3.1    93/02/20    */
  1682.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1683.   /* NetHack may be freely redistributed.  See license for details. */
  1684.   
  1685. --- 1,4 ----
  1686. ! /*    SCCS Id: @(#)makemon.c    3.1    93/05/10    */
  1687.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1688.   /* NetHack may be freely redistributed.  See license for details. */
  1689.   
  1690. ***************
  1691. *** 333,338 ****
  1692. --- 333,343 ----
  1693.           (void)mongets(mtmp, KNIFE);
  1694.           (void)mongets(mtmp, LONG_SWORD);
  1695.           break;
  1696. +         case S_ZOMBIE:
  1697. +         if (!rn2(4)) (void)mongets(mtmp, LEATHER_ARMOR);
  1698. +         if (!rn2(4))
  1699. +             (void)mongets(mtmp, (rn2(3) ? KNIFE : SHORT_SWORD));
  1700. +         break;
  1701.           case S_DEMON:
  1702.           switch (mm) {
  1703.               case PM_BALROG:
  1704. ***************
  1705. *** 364,380 ****
  1706.           if (!is_demon(ptr)) break;
  1707.           /* fall thru */
  1708.   /*
  1709. !  *    Now the general case, ~40% chance of getting some type
  1710. !  *    of weapon. TODO: Add more weapons types (use bigmonst());
  1711.    */
  1712.           default:
  1713. !         switch(rnd(12)) {
  1714.               case 1:
  1715. !             m_initthrow(mtmp, DART, 12);
  1716.               break;
  1717.               case 2:
  1718. !             (void) mongets(mtmp, CROSSBOW);
  1719. !             m_initthrow(mtmp, CROSSBOW_BOLT, 12);
  1720.               break;
  1721.               case 3:
  1722.               (void) mongets(mtmp, BOW);
  1723. --- 369,395 ----
  1724.           if (!is_demon(ptr)) break;
  1725.           /* fall thru */
  1726.   /*
  1727. !  *    Now the general case, Some chance of getting some type
  1728. !  *    of weapon for "normal" monsters.  Certain special types
  1729. !  *    of monsters will get a bonus chance or different selections.
  1730.    */
  1731.           default:
  1732. !           {
  1733. !         int bias;
  1734. !         
  1735. !         bias = is_lord(ptr) + is_prince(ptr) * 2 + extra_nasty(ptr);
  1736. !         switch(rnd(14 - (2 * bias))) {
  1737.               case 1:
  1738. !             if(strongmonst(ptr)) (void) mongets(mtmp, BATTLE_AXE);
  1739. !             else m_initthrow(mtmp, DART, 12);
  1740.               break;
  1741.               case 2:
  1742. !             if(strongmonst(ptr))
  1743. !                 (void) mongets(mtmp, TWO_HANDED_SWORD);
  1744. !             else {
  1745. !                 (void) mongets(mtmp, CROSSBOW);
  1746. !                 m_initthrow(mtmp, CROSSBOW_BOLT, 12);
  1747. !             }
  1748.               break;
  1749.               case 3:
  1750.               (void) mongets(mtmp, BOW);
  1751. ***************
  1752. *** 381,398 ****
  1753.               m_initthrow(mtmp, ARROW, 12);
  1754.               break;
  1755.               case 4:
  1756. !             m_initthrow(mtmp, DAGGER, 3);
  1757.               break;
  1758.               case 5:
  1759. !             (void) mongets(mtmp, AKLYS);
  1760.               break;
  1761.               default:
  1762.               break;
  1763.           }
  1764. !         break;
  1765.       }
  1766.   #ifdef MUSE
  1767. !     if ((int) mtmp->m_lev > rn2(70))
  1768.           (void) mongets(mtmp, rnd_offensive_item(mtmp));
  1769.   #endif
  1770.   }
  1771. --- 396,417 ----
  1772.               m_initthrow(mtmp, ARROW, 12);
  1773.               break;
  1774.               case 4:
  1775. !             if(strongmonst(ptr)) (void) mongets(mtmp, LONG_SWORD);
  1776. !             else m_initthrow(mtmp, DAGGER, 3);
  1777.               break;
  1778.               case 5:
  1779. !             if(strongmonst(ptr))
  1780. !                 (void) mongets(mtmp, LUCERN_HAMMER);
  1781. !             else (void) mongets(mtmp, AKLYS);
  1782.               break;
  1783.               default:
  1784.               break;
  1785.           }
  1786. !           }
  1787. !           break;
  1788.       }
  1789.   #ifdef MUSE
  1790. !     if ((int) mtmp->m_lev > rn2(75))
  1791.           (void) mongets(mtmp, rnd_offensive_item(mtmp));
  1792.   #endif
  1793.   }
  1794. ***************
  1795. *** 546,552 ****
  1796.       if (ptr == &mons[PM_SOLDIER] && rn2(13)) return;
  1797.   #endif
  1798.   #ifdef MUSE
  1799. !     if ((int) mtmp->m_lev > rn2(30))
  1800.           (void) mongets(mtmp, rnd_defensive_item(mtmp));
  1801.       if ((int) mtmp->m_lev > rn2(100))
  1802.           (void) mongets(mtmp, rnd_misc_item(mtmp));
  1803. --- 565,571 ----
  1804.       if (ptr == &mons[PM_SOLDIER] && rn2(13)) return;
  1805.   #endif
  1806.   #ifdef MUSE
  1807. !     if ((int) mtmp->m_lev > rn2(50))
  1808.           (void) mongets(mtmp, rnd_defensive_item(mtmp));
  1809.       if ((int) mtmp->m_lev > rn2(100))
  1810.           (void) mongets(mtmp, rnd_misc_item(mtmp));
  1811. ***************
  1812. *** 851,857 ****
  1813.       if (mdat) {
  1814.           if (IS_POOL(levl[x][y].typ))
  1815.           if (mdat == &playermon &&
  1816. !             (HLevitation || Wwalking || Magical_breathing))
  1817.               return 1;
  1818.           else    return (is_flyer(mdat) || is_swimmer(mdat));
  1819.           if (levl[x][y].typ == LAVAPOOL)
  1820. --- 870,876 ----
  1821.       if (mdat) {
  1822.           if (IS_POOL(levl[x][y].typ))
  1823.           if (mdat == &playermon &&
  1824. !             (HLevitation || Wwalking || Amphibious))
  1825.               return 1;
  1826.           else    return (is_flyer(mdat) || is_swimmer(mdat));
  1827.           if (levl[x][y].typ == LAVAPOOL)
  1828. ***************
  1829. *** 1210,1222 ****
  1830.       register int newtype;
  1831.       register struct permonst *ptr = mtmp->data;
  1832.   
  1833. -     if (ptr->mlevel >= 50 || is_golem(ptr) || is_home_elemental(ptr)
  1834. -         || is_mplayer(ptr))
  1835. -         /* doesn't grow up, has strange hp calculation so might be
  1836. -          * weakened by tests below */
  1837. -         return ptr;
  1838. - 
  1839.       if (victim) {
  1840.           mtmp->mhpmax = mtmp->mhpmax + (1 + rn2((int)victim->m_lev+1));
  1841.           if (mtmp->mhpmax <= (8 * (int)mtmp->m_lev)
  1842.               || (mtmp->m_lev == 0 && mtmp->mhpmax <= 4))
  1843. --- 1229,1241 ----
  1844.       register int newtype;
  1845.       register struct permonst *ptr = mtmp->data;
  1846.   
  1847.       if (victim) {
  1848. +         if (ptr->mlevel >= 50 || is_golem(ptr) || is_home_elemental(ptr)
  1849. +             || is_mplayer(ptr))
  1850. +         /* doesn't grow up, has strange hp calculation so might be
  1851. +          * weakened by tests below */
  1852. +         return ptr;
  1853. + 
  1854.           mtmp->mhpmax = mtmp->mhpmax + (1 + rn2((int)victim->m_lev+1));
  1855.           if (mtmp->mhpmax <= (8 * (int)mtmp->m_lev)
  1856.               || (mtmp->m_lev == 0 && mtmp->mhpmax <= 4))
  1857. ***************
  1858. *** 1245,1250 ****
  1859. --- 1264,1270 ----
  1860.               return (struct permonst *)0;
  1861.           }
  1862.           mtmp->data = &mons[newtype];
  1863. +         newsym(mtmp->mx, mtmp->my);    /* color may change */
  1864.           mtmp->m_lev = mons[newtype].mlevel;
  1865.       }
  1866.       if (newtype == monsndx(ptr) && victim &&
  1867. *** /tmp/da11066    Tue Jun  1 16:14:06 1993
  1868. --- src/mcastu.c    Thu May  6 11:25:36 1993
  1869. ***************
  1870. *** 1,25 ****
  1871. ! /*    SCCS Id: @(#)mcastu.c    3.1    90/09/21
  1872.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1873.   /* NetHack may be freely redistributed.  See license for details. */
  1874.   
  1875. ! #include    "hack.h"
  1876.   
  1877.   #ifdef OVL0
  1878. - 
  1879.   static void FDECL(cursetxt,(struct monst *));
  1880. - const char *spelltyp[] = {
  1881. -     "shower of missiles",
  1882. -     "fireball",
  1883. -     "sleep ray",
  1884. -     "cone of cold",
  1885. -     "finger of death",
  1886. -     "bolt of lightning",
  1887. -     "",
  1888. -     "",
  1889. -     "",
  1890. -     ""
  1891. - };
  1892.   
  1893.   static
  1894.   void
  1895.   cursetxt(mtmp)
  1896. --- 1,14 ----
  1897. ! /*    SCCS Id: @(#)mcastu.c    3.1    93/05/04    */
  1898.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1899.   /* NetHack may be freely redistributed.  See license for details. */
  1900.   
  1901. ! #include "hack.h"
  1902.   
  1903.   #ifdef OVL0
  1904.   static void FDECL(cursetxt,(struct monst *));
  1905.   
  1906. + extern const char *flash_types[];    /* from zap.c */
  1907. + 
  1908.   static
  1909.   void
  1910.   cursetxt(mtmp)
  1911. ***************
  1912. *** 337,342 ****
  1913. --- 326,334 ----
  1914.   #endif /* OVLB */
  1915.   #ifdef OVL0
  1916.   
  1917. + /* convert 1..10 to 0..9; add 10 for second group (spell casting) */
  1918. + #define ad_to_typ(k) (10 + (int)k - 1)
  1919. + 
  1920.   int
  1921.   buzzmu(mtmp, mattk)        /* monster uses spell (ranged) */
  1922.       register struct monst *mtmp;
  1923. ***************
  1924. *** 351,358 ****
  1925.           if(mattk->adtyp && (mattk->adtyp < 11)) { /* no cf unsigned >0 */
  1926.           if(canseemon(mtmp))
  1927.               pline("%s zaps you with a %s!", Monnam(mtmp),
  1928. !               spelltyp[mattk->adtyp-1]);
  1929. !         buzz((int) (-10 - (mattk->adtyp-1)), (int)mattk->damn,
  1930.                mtmp->mx, mtmp->my, sgn(tbx), sgn(tby));
  1931.           } else impossible("Monster spell %d cast", mattk->adtyp-1);
  1932.       }
  1933. --- 343,350 ----
  1934.           if(mattk->adtyp && (mattk->adtyp < 11)) { /* no cf unsigned >0 */
  1935.           if(canseemon(mtmp))
  1936.               pline("%s zaps you with a %s!", Monnam(mtmp),
  1937. !               flash_types[ad_to_typ(mattk->adtyp)]);
  1938. !         buzz(-ad_to_typ(mattk->adtyp), (int)mattk->damn,
  1939.                mtmp->mx, mtmp->my, sgn(tbx), sgn(tby));
  1940.           } else impossible("Monster spell %d cast", mattk->adtyp-1);
  1941.       }
  1942. *** /tmp/da11074    Tue Jun  1 16:14:08 1993
  1943. --- src/mhitm.c    Fri May 28 11:31:59 1993
  1944. ***************
  1945. *** 1,4 ****
  1946. ! /*    SCCS Id: @(#)mhitm.c    3.1    93/02/09    */
  1947.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1948.   /* NetHack may be freely redistributed.  See license for details. */
  1949.   
  1950. --- 1,4 ----
  1951. ! /*    SCCS Id: @(#)mhitm.c    3.1    93/05/26    */
  1952.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1953.   /* NetHack may be freely redistributed.  See license for details. */
  1954.   
  1955. ***************
  1956. *** 360,366 ****
  1957.   
  1958.       if(vis) {
  1959.           Sprintf(buf,"%s gazes at", Monnam(magr));
  1960. !         pline("%s %s.", buf, mon_nam(mdef));
  1961.       }
  1962.   
  1963.       if (!mdef->mcansee || mdef->msleep) {
  1964. --- 360,366 ----
  1965.   
  1966.       if(vis) {
  1967.           Sprintf(buf,"%s gazes at", Monnam(magr));
  1968. !         pline("%s %s...", buf, mon_nam(mdef));
  1969.       }
  1970.   
  1971.       if (!mdef->mcansee || mdef->msleep) {
  1972. ***************
  1973. *** 655,661 ****
  1974.           break;
  1975.           case AD_TLPT:
  1976.           if(!magr->mcan && tmp < mdef->mhp) {
  1977. !             rloc(mdef);
  1978.               if(vis && !cansee(mdef->mx, mdef->my))
  1979.               pline("%s suddenly disappears!", Monnam(mdef));
  1980.           }
  1981. --- 655,661 ----
  1982.           break;
  1983.           case AD_TLPT:
  1984.           if(!magr->mcan && tmp < mdef->mhp) {
  1985. !             if (!tele_restrict(mdef)) rloc(mdef);
  1986.               if(vis && !cansee(mdef->mx, mdef->my))
  1987.               pline("%s suddenly disappears!", Monnam(mdef));
  1988.           }
  1989. ***************
  1990. *** 856,862 ****
  1991.           remove_monster(mdef->mx, mdef->my);
  1992.           place_monster(mdef, mdef->mx, mdef->my);
  1993.           }
  1994. !         monkilled(mdef, "", mattk->adtyp);
  1995.           if (mdef->mhp > 0) return 0; /* mdef lifesaved */
  1996.           return (MM_DEF_DIED | (grow_up(magr,mdef) ? 0 : MM_AGR_DIED));
  1997.       }
  1998. --- 856,862 ----
  1999.           remove_monster(mdef->mx, mdef->my);
  2000.           place_monster(mdef, mdef->mx, mdef->my);
  2001.           }
  2002. !         monkilled(mdef, "", (int)mattk->adtyp);
  2003.           if (mdef->mhp > 0) return 0; /* mdef lifesaved */
  2004.           return (MM_DEF_DIED | (grow_up(magr,mdef) ? 0 : MM_AGR_DIED));
  2005.       }
  2006. ***************
  2007. *** 972,980 ****
  2008. --- 972,988 ----
  2009.       /* These affect the enemy only if defender is still alive */
  2010.       if (rn2(3)) switch(mddat->mattk[i].adtyp) {
  2011.           case AD_PLYS: /* Floating eye */
  2012. +         if (tmp > 127) tmp = 127;
  2013.           if (mddat == &mons[PM_FLOATING_EYE]) {
  2014. +             if (!rn2(4)) tmp = 127;
  2015.               if (magr->mcansee && haseyes(madat) && mdef->mcansee &&
  2016.               (perceives(madat) || !mdef->minvis)) {
  2017. + #ifdef MUSE
  2018. +             Sprintf(buf, "%s gaze is reflected by %%s %%s.",
  2019. +                 s_suffix(mon_nam(mdef)));
  2020. +             if (mon_reflects(magr, buf))
  2021. +                 return(mdead|mhit);
  2022. + #endif
  2023.               Strcpy(buf, Monnam(magr));
  2024.               if(canseemon(magr))
  2025.                   pline("%s is frozen by %s gaze!",
  2026. ***************
  2027. *** 1057,1063 ****
  2028.   
  2029.       assess_dmg:
  2030.       if((magr->mhp -= tmp) <= 0) {
  2031. !         monkilled(magr,"",mddat->mattk[i].adtyp);
  2032.           return (mdead | mhit | MM_AGR_DIED);
  2033.       }
  2034.       return (mdead | mhit);
  2035. --- 1065,1071 ----
  2036.   
  2037.       assess_dmg:
  2038.       if((magr->mhp -= tmp) <= 0) {
  2039. !         monkilled(magr, "", (int)mddat->mattk[i].adtyp);
  2040.           return (mdead | mhit | MM_AGR_DIED);
  2041.       }
  2042.       return (mdead | mhit);
  2043.