home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / games / volume16 / nethck31 / patch2d < prev    next >
Encoding:
Internet Message Format  |  1993-06-15  |  61.6 KB

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