home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / usenet / volume7 / nethack3 / patch7n < prev    next >
Encoding:
Internet Message Format  |  1990-02-26  |  57.5 KB

  1. Path: uunet!zephyr.ens.tek.com!tekred!saab!billr
  2. From: billr@saab.CNA.TEK.COM (Bill Randle)
  3. Newsgroups: comp.sources.games
  4. Subject: v09i014:  NetHack3 -  display oriented dungeons & dragons (Ver. 3.0), Patch7n
  5. Message-ID: <5228@tekred.CNA.TEK.COM>
  6. Date: 24 Feb 90 00:57:33 GMT
  7. Sender: news@tekred.CNA.TEK.COM
  8. Lines: 2298
  9. Approved: billr@saab.CNA.TEK.COM
  10.  
  11. Submitted-by: Izchak Miller <izchak@linc.cis.upenn.edu>
  12. Posting-number: Volume 9, Issue 14
  13. Archive-name: NetHack3/Patch7n
  14. Patch-To: NetHack3: Volume 7, Issue 56-93
  15.  
  16.  
  17.  
  18. #! /bin/sh
  19. # This is a shell archive.  Remove anything before this line, then unpack
  20. # it by saving it into a file and typing "sh file".  To overwrite existing
  21. # files, type "sh file -c".  You can also feed this as standard input via
  22. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  23. # will see the following message at the end:
  24. #        "End of archive 14 (of 30)."
  25. # Contents:  patch7.10
  26. # Wrapped by billr@saab on Wed Feb 21 10:04:35 1990
  27. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  28. if test -f 'patch7.10' -a "${1}" != "-c" ; then 
  29.   echo shar: Renaming existing file \"'patch7.10'\" to \"'patch7.10.orig'\"
  30.   mv -f 'patch7.10' 'patch7.10.orig'
  31. fi
  32. echo shar: Extracting \"'patch7.10'\" \(54708 characters\)
  33. sed "s/^X//" >'patch7.10' <<'END_OF_FILE'
  34. X*** src/Old/mail.c    Mon Feb 19 20:26:33 1990
  35. X--- src/mail.c    Thu Jan 25 22:13:05 1990
  36. X***************
  37. X*** 7,12 ****
  38. X--- 7,15 ----
  39. X  #include "hack.h"    /* mainly for index() which depends on BSD */
  40. X  
  41. X  #ifdef MAIL
  42. X+ static void FDECL(mdrush,(struct monst *,int,int));
  43. X+ static void FDECL(mdappear,(struct monst *,BOOLEAN_P));
  44. X+ static void NDECL(newmail);
  45. X  
  46. X  # ifdef UNIX
  47. X  #  include <sys/stat.h>
  48. X***************
  49. X*** 55,64 ****
  50. X--- 58,72 ----
  51. X   *    - It may also do this with adjoining castle rooms.
  52. X   */
  53. X  
  54. X+ #ifdef OVL0
  55. X+ 
  56. X  # if !defined(UNIX) && !defined(VMS)
  57. X  int mustgetmail = -1;
  58. X  # endif
  59. X  
  60. X+ #endif /* OVL0 */
  61. X+ #ifdef OVLB
  62. X+ 
  63. X  # ifdef UNIX
  64. X  extern struct passwd *getpwuid();
  65. X  static struct stat omstat,nmstat;
  66. X***************
  67. X*** 65,70 ****
  68. X--- 73,81 ----
  69. X  static char *mailbox = NULL;
  70. X  static long laststattime;
  71. X  
  72. X+ # ifdef AMS                /* Just a placeholder for AMS */
  73. X+ #   define MAILPATH "/dev/null"
  74. X+ # else
  75. X  #  ifdef BSD
  76. X  #   define MAILPATH "/usr/spool/mail/"
  77. X  #  endif
  78. X***************
  79. X*** 71,84 ****
  80. X--- 82,108 ----
  81. X  #  ifdef SYSV
  82. X  #   define MAILPATH "/usr/mail/"
  83. X  #  endif
  84. X+ # endif /* AMS */
  85. X  
  86. X  void
  87. X  getmailstatus() {
  88. X      if(!mailbox && !(mailbox = getenv("MAIL"))) {
  89. X  #  ifdef MAILPATH
  90. X+ #   ifdef AMS
  91. X+             struct passwd ppasswd;
  92. X+ 
  93. X+         bcopy(getpwuid(getuid()), &ppasswd, sizeof(struct passwd));
  94. X+         if (ppasswd.pw_dir) {
  95. X+              mailbox = (char *) alloc((unsigned) strlen(ppasswd.pw_dir)+sizeof(AMS_MAILBOX));
  96. X+              Strcpy(mailbox, ppasswd.pw_dir);
  97. X+              Strcat(mailbox, AMS_MAILBOX);
  98. X+         } else
  99. X+           return;
  100. X+ #   else
  101. X          mailbox = (char *) alloc(sizeof(MAILPATH)+8);
  102. X          Strcpy(mailbox, MAILPATH);
  103. X          Strcat(mailbox, getpwuid(getuid())->pw_name);
  104. X+ #  endif /* AMS */
  105. X  #  else
  106. X          return;
  107. X  #  endif
  108. X***************
  109. X*** 217,225 ****
  110. X--- 241,254 ----
  111. X  # ifdef VMS
  112. X      pline("\"Hello, %s!  I have a message for you.\"", plname);
  113. X  # else
  114. X+ #  ifdef NO_MAILREADER
  115. X+     pline("\"Hello, %s!  You have some mail in the outside world.\"", plname);
  116. X+ #  else
  117. X      pline("\"Hello, %s!  I have some mail for you.\"", plname);
  118. X  # endif
  119. X+ # endif
  120. X  
  121. X+ # ifndef NO_MAILREADER
  122. X      if(dist(md->mx,md->my) > 2)
  123. X          verbalize("Catch!");
  124. X      more();
  125. X***************
  126. X*** 243,251 ****
  127. X--- 272,286 ----
  128. X  # ifdef VMS
  129. X      broadcasts--;
  130. X  # endif
  131. X+ # endif /* NO_MAILREADER */
  132. X  }
  133. X  
  134. X+ #endif /* OVLB */
  135. X+ 
  136. X  # if !defined(UNIX) && !defined(VMS)
  137. X+ 
  138. X+ #ifdef OVL0
  139. X+ 
  140. X  void
  141. X  ckmailstatus() {
  142. X      if (mustgetmail < 0)
  143. X***************
  144. X*** 256,269 ****
  145. X--- 291,313 ----
  146. X      }
  147. X  }
  148. X  
  149. X+ #endif /* OVL0 */
  150. X+ #ifdef OVLB
  151. X+ 
  152. X  void
  153. X  readmail()
  154. X  {
  155. X      pline("It says:  \"Please disregard previous letter.\"");
  156. X  }
  157. X+ 
  158. X+ #endif /* OVLB */
  159. X+ 
  160. X  # endif /* !UNIX && !VMS */
  161. X  
  162. X  # ifdef UNIX
  163. X+ 
  164. X+ #ifdef OVL0
  165. X+ 
  166. X  void
  167. X  ckmailstatus() {
  168. X      if(!mailbox
  169. X***************
  170. X*** 288,293 ****
  171. X--- 332,340 ----
  172. X      }
  173. X  }
  174. X  
  175. X+ #endif /* OVL0 */
  176. X+ #ifdef OVLB
  177. X+ 
  178. X  void
  179. X  readmail() {
  180. X  #  ifdef DEF_MAILREADER            /* This implies that UNIX is defined */
  181. X***************
  182. X*** 300,314 ****
  183. X          exit(1);
  184. X      }
  185. X  #  else
  186. X      (void) page_file(mailbox, FALSE);
  187. X! #  endif
  188. X      /* get new stat; not entirely correct: there is a small time
  189. X         window where we do not see new mail */
  190. X      getmailstatus();
  191. X  }
  192. X  # endif /* UNIX */
  193. X  
  194. X  # ifdef VMS
  195. X  void
  196. X  ckmailstatus()
  197. X  {
  198. X--- 347,370 ----
  199. X          exit(1);
  200. X      }
  201. X  #  else
  202. X+ #   ifndef AMS              /* AMS mailboxes are directories */
  203. X      (void) page_file(mailbox, FALSE);
  204. X! #   endif /* AMS */
  205. X! #  endif /* DEF_MAILREADER */
  206. X! 
  207. X      /* get new stat; not entirely correct: there is a small time
  208. X         window where we do not see new mail */
  209. X      getmailstatus();
  210. X  }
  211. X+ 
  212. X+ #endif /* OVLB */
  213. X+ 
  214. X  # endif /* UNIX */
  215. X  
  216. X  # ifdef VMS
  217. X+ 
  218. X+ #ifdef OVL0
  219. X+ 
  220. X  void
  221. X  ckmailstatus()
  222. X  {
  223. X***************
  224. X*** 316,321 ****
  225. X--- 372,380 ----
  226. X          newmail();
  227. X  }
  228. X  
  229. X+ #endif /* OVL0 */
  230. X+ #ifdef OVLB
  231. X+ 
  232. X  void
  233. X  readmail()
  234. X  {
  235. X***************
  236. X*** 330,334 ****
  237. X--- 389,395 ----
  238. X      }
  239. X  }
  240. X  # endif /* VMS */
  241. X+ 
  242. X+ #endif /* OVLB */
  243. X  
  244. X  #endif /* MAIL */
  245. X*** src/Old/makedefs.c    Mon Feb 19 20:26:53 1990
  246. X--- src/makedefs.c    Thu Feb  8 17:33:49 1990
  247. X***************
  248. X*** 2,8 ****
  249. X  /* NetHack may be freely redistributed.  See license for details. */
  250. X  /* makedefs.c - NetHack version 3.0 */
  251. X  
  252. X- #define MAKEDEFS_C 1    /* needs to be defined to 1 for Mac */
  253. X  
  254. X  #define EXTERN_H
  255. X  #include    "config.h"
  256. X--- 2,7 ----
  257. X***************
  258. X*** 13,26 ****
  259. X  #endif /* NULL */
  260. X  #define NULL    ((genericptr_t)0)
  261. X  
  262. X! #ifndef LINT
  263. X  static    const char    SCCS_Id[] = "@(#)makedefs.c\t3.0\t89/11/15";
  264. X  #endif
  265. X  
  266. X  #ifdef MSDOS
  267. X! #ifndef TOS
  268. X  # define freopen _freopen
  269. X! #endif
  270. X  # undef    exit
  271. X  extern void FDECL(exit, (int));
  272. X  # define RDMODE    "r"
  273. X--- 12,26 ----
  274. X  #endif /* NULL */
  275. X  #define NULL    ((genericptr_t)0)
  276. X  
  277. X! #if !defined(LINT) && !defined(__GNULINT__)
  278. X  static    const char    SCCS_Id[] = "@(#)makedefs.c\t3.0\t89/11/15";
  279. X  #endif
  280. X  
  281. X  #ifdef MSDOS
  282. X! # if !defined(AMIGA) && !defined(TOS)
  283. X  # define freopen _freopen
  284. X! FILE *FDECL(_freopen, (char *,char *,FILE *));
  285. X! # endif
  286. X  # undef    exit
  287. X  extern void FDECL(exit, (int));
  288. X  # define RDMODE    "r"
  289. X***************
  290. X*** 29,56 ****
  291. X  # define RDMODE  "r+"
  292. X  # define WRMODE  "w+"
  293. X  #endif
  294. X! #if defined(SYSV) || defined(GENIX) || defined(UNIXDEBUG)
  295. X! void rename();
  296. X! #endif
  297. X! #ifdef AMIGA
  298. X! # undef freopen
  299. X! # undef printf
  300. X! # undef puts
  301. X! # undef fflush
  302. X! # define fflush FFLUSH
  303. X! # undef fputs
  304. X! # undef fprintf
  305. X  #endif
  306. X  
  307. X  /* construct definitions of object constants */
  308. X  
  309. X  #ifdef AMIGA
  310. X! # define MONST_FILE     "include:pm.h"
  311. X! # define ONAME_FILE     "include:onames.h"
  312. X! # define TRAP_FILE     "include:trap.h"
  313. X! # define DATE_FILE     "include:date.h"
  314. X! # define DATA_FILE     "auxil:data"
  315. X! # define RUMOR_FILE     "auxil:rumors"
  316. X  #else
  317. X  # ifndef MACOS
  318. X  /* construct definitions of object constants */
  319. X--- 29,53 ----
  320. X  # define RDMODE  "r+"
  321. X  # define WRMODE  "w+"
  322. X  #endif
  323. X! 
  324. X! #ifdef MACOS
  325. X! Boolean FDECL(TouchFile,(char *));
  326. X! Str255 VolName;
  327. X! int vRef;
  328. X! Str255 File;
  329. X! FInfo info;
  330. X! OSErr macErr;
  331. X  #endif
  332. X  
  333. X  /* construct definitions of object constants */
  334. X  
  335. X  #ifdef AMIGA
  336. X! # define MONST_FILE     "Incl:pm.h"
  337. X! # define ONAME_FILE     "Incl:onames.h"
  338. X! # define TRAP_FILE     "Incl:trap.h"
  339. X! # define DATE_FILE     "Incl:date.h"
  340. X! # define DATA_FILE     "Auxil:data"
  341. X! # define RUMOR_FILE     "Auxil:rumors"
  342. X  #else
  343. X  # ifndef MACOS
  344. X  /* construct definitions of object constants */
  345. X***************
  346. X*** 84,95 ****
  347. X  
  348. X  char    in_line[256];
  349. X  extern char *FDECL(gets, (char *));
  350. X! void do_objs(), do_traps(), do_data(), do_date(), do_permonst(), do_rumors();
  351. X  #ifdef SMALLDATA
  352. X! void do_monst(), save_resource();
  353. X  #endif
  354. X  char *FDECL(limit, (char *,BOOLEAN_P));
  355. X! FILE *FDECL(_freopen, (char *,char *,FILE *));
  356. X  
  357. X  int
  358. X  main(argc, argv)
  359. X--- 81,114 ----
  360. X  
  361. X  char    in_line[256];
  362. X  extern char *FDECL(gets, (char *));
  363. X! 
  364. X! int FDECL(main, (int, char **));
  365. X! void NDECL(do_objs);
  366. X! void NDECL(do_traps);
  367. X! void NDECL(do_data);
  368. X! void NDECL(do_date);
  369. X! void NDECL(do_permonst);
  370. X! void NDECL(do_rumors);
  371. X! 
  372. X! char * FDECL(tmpdup, (const char *));
  373. X! 
  374. X! #if defined(SYSV) || defined(GENIX) || defined(UNIXDEBUG)
  375. X! void FDECL(rename, (char *, char *));
  376. X! #endif
  377. X! 
  378. X  #ifdef SMALLDATA
  379. X! void NDECL(do_monst);
  380. X! void NDECL(save_resource);
  381. X  #endif
  382. X+ 
  383. X  char *FDECL(limit, (char *,BOOLEAN_P));
  384. X! 
  385. X! #if defined(SMALLDATA) && defined(MACOS)
  386. X! OSErr FDECL(write_resource, (Handle, short, Str255, short));
  387. X! # if defined(AZTEC) || defined(THINKC4)
  388. X! int NDECL(getpid);
  389. X! # endif
  390. X! #endif
  391. X  
  392. X  int
  393. X  main(argc, argv)
  394. X***************
  395. X*** 113,119 ****
  396. X  
  397. X      /* standard Mac initialization */
  398. X      InitGraf(&MAINGRAFPORT);
  399. X!     
  400. X      InitFonts();
  401. X      InitWindows();
  402. X      InitMenus();
  403. X--- 132,138 ----
  404. X  
  405. X      /* standard Mac initialization */
  406. X      InitGraf(&MAINGRAFPORT);
  407. X! 
  408. X      InitFonts();
  409. X      InitWindows();
  410. X      InitMenus();
  411. X***************
  412. X*** 120,126 ****
  413. X      InitCursor();
  414. X      FlushEvents(everyEvent,0);
  415. X      InitDialogs(NULL);
  416. X!     
  417. X      params[0] = '-';
  418. X      options = "DVPRTOM";
  419. X      dialog = GetNewDialog(200, 0L, (WindowPtr) -1);
  420. X--- 139,145 ----
  421. X      InitCursor();
  422. X      FlushEvents(everyEvent,0);
  423. X      InitDialogs(NULL);
  424. X! 
  425. X      params[0] = '-';
  426. X      options = "DVPRTOM";
  427. X      dialog = GetNewDialog(200, 0L, (WindowPtr) -1);
  428. X***************
  429. X*** 154,160 ****
  430. X      if (itemHit == OK_BUTTON && lastItem >= FIRST_RADIO_BUTTON) {
  431. X          argc = 2;
  432. X          option = params;
  433. X!     
  434. X  #else
  435. X      if(argc == 2) {
  436. X          option = argv[1];
  437. X--- 173,179 ----
  438. X      if (itemHit == OK_BUTTON && lastItem >= FIRST_RADIO_BUTTON) {
  439. X          argc = 2;
  440. X          option = params;
  441. X! 
  442. X  #else
  443. X      if(argc == 2) {
  444. X          option = argv[1];
  445. X***************
  446. X*** 183,195 ****
  447. X          case 'r':
  448. X          case 'R':    do_rumors();
  449. X                  break;
  450. X! #if defined(SMALLDATA) && defined(MACOS)
  451. X          case 'm':
  452. X          case 'M':    do_monst();
  453. X                  break;
  454. X-         
  455. X- #endif    /* SMALLDATA && MACOS */
  456. X  
  457. X          default:
  458. X                  (void) fprintf(stderr,
  459. X                      "Unknown option '%c'.\n", option[1]);
  460. X--- 202,214 ----
  461. X          case 'r':
  462. X          case 'R':    do_rumors();
  463. X                  break;
  464. X! #if defined(SMALLDATA)
  465. X          case 'm':
  466. X          case 'M':    do_monst();
  467. X                  break;
  468. X  
  469. X+ #endif    /* SMALLDATA */
  470. X+ 
  471. X          default:
  472. X                  (void) fprintf(stderr,
  473. X                      "Unknown option '%c'.\n", option[1]);
  474. X***************
  475. X*** 260,266 ****
  476. X  void
  477. X  do_rumors(){
  478. X      char    infile[30];
  479. X-     FILE    *FDECL(freopen, (char *,char *,FILE *));
  480. X      long    true_rumor_size;
  481. X  
  482. X      if(freopen(RUMOR_FILE, WRMODE, stdout) == (FILE *)0) {
  483. X--- 279,284 ----
  484. X***************
  485. X*** 294,299 ****
  486. X--- 312,326 ----
  487. X  
  488. X      (void) fclose(stdin);
  489. X      (void) fclose(stdout);
  490. X+ #ifdef MACOS
  491. X+     strcpy((char *)File, RUMOR_FILE);
  492. X+     CtoPstr((char *)File);
  493. X+     if(!GetVol(VolName, &vRef) && !GetFInfo(File, vRef, &info)){
  494. X+         info.fdCreator = CREATOR;
  495. X+         info.fdType = TEXT_TYPE;
  496. X+         (void) SetFInfo(File, vRef, &info);
  497. X+     }
  498. X+ #endif
  499. X      return;
  500. X  }
  501. X  
  502. X***************
  503. X*** 321,326 ****
  504. X--- 348,357 ----
  505. X  #endif
  506. X      for(c = cbuf; *c != '\n'; c++);    *c = 0; /* strip off the '\n' */
  507. X      Printf("const char datestring[] = \"%s\";\n", cbuf);
  508. X+ #ifdef MSDOS
  509. X+       /* get the time we did a compile for checking save and level files */
  510. X+     Printf("const long compiletime = %ld;\n", clock);
  511. X+ #endif
  512. X  
  513. X      (void) fclose(stdout);
  514. X      return;
  515. X***************
  516. X*** 329,335 ****
  517. X  void
  518. X  do_data(){
  519. X      char    tempfile[30];
  520. X! 
  521. X      Sprintf(tempfile, "%s.base", DATA_FILE);
  522. X      if(freopen(tempfile, RDMODE, stdin) == (FILE *)0) {
  523. X          perror(tempfile);
  524. X--- 360,368 ----
  525. X  void
  526. X  do_data(){
  527. X      char    tempfile[30];
  528. X! #ifndef INFERNO
  529. X!     boolean    skipping_demons = TRUE;
  530. X! #endif
  531. X      Sprintf(tempfile, "%s.base", DATA_FILE);
  532. X      if(freopen(tempfile, RDMODE, stdin) == (FILE *)0) {
  533. X          perror(tempfile);
  534. X***************
  535. X*** 342,365 ****
  536. X      }
  537. X  
  538. X      while(gets(in_line) != NULL) {
  539. X  #ifndef GOLEMS
  540. X!         if(!strcmp(in_line, "'\ta golem;"))
  541. X          while(gets(in_line) != NULL && in_line[0] == '\t')
  542. X              ; /* do nothing */
  543. X  #endif
  544. X! #ifndef    SPELLS
  545. X!         if(!strcmp(in_line, "+\ta spell book"))
  546. X!         ; /* do nothing */
  547. X!         else
  548. X! #endif
  549. X! #ifndef KOPS
  550. X!         if(!strcmp(in_line, "K\ta Keystone Kop"))
  551. X!         ; /* do nothing */
  552. X          else
  553. X  #endif
  554. X! #ifndef WORM
  555. X!         if(!strcmp(in_line, "~\tthe tail of a long worm"))
  556. X!         ; /* do nothing */
  557. X          else
  558. X  #endif
  559. X          (void) puts(in_line);
  560. X--- 375,426 ----
  561. X      }
  562. X  
  563. X      while(gets(in_line) != NULL) {
  564. X+ #ifndef INFERNO
  565. X+         if(skipping_demons)
  566. X+         while(gets(in_line) != NULL && strcmp(in_line, "*centaur"))
  567. X+             ; /* do nothing */
  568. X+         skipping_demons = FALSE;
  569. X+ #endif
  570. X+ #ifndef ARMY
  571. X+         if(!strcmp(in_line, "*soldier")) {
  572. X+         while(gets(in_line) != NULL && in_line[0] != '\t') ;
  573. X+         while(gets(in_line) != NULL && in_line[0] == '\t')
  574. X+             ; /* do nothing */
  575. X+         }
  576. X+         else
  577. X+ #endif
  578. X+ #ifndef WORM
  579. X+         if(!strcmp(in_line, "*long worm")) {
  580. X+         while(gets(in_line) != NULL && in_line[0] != '\t') ;
  581. X+         while(gets(in_line) != NULL && in_line[0] == '\t')
  582. X+             ; /* do nothing */
  583. X+         }
  584. X+         else
  585. X+ #endif
  586. X  #ifndef GOLEMS
  587. X!         if(!strcmp(in_line, "*golem"))
  588. X          while(gets(in_line) != NULL && in_line[0] == '\t')
  589. X              ; /* do nothing */
  590. X+         else
  591. X  #endif
  592. X! #ifndef MEDUSA
  593. X!         if(!strcmp(in_line, "medusa"))
  594. X!         while(gets(in_line) != NULL && in_line[0] == '\t')
  595. X!             ; /* do nothing */
  596. X          else
  597. X  #endif
  598. X! #ifndef NAMED_ITEMS
  599. X!         if(!strcmp(in_line, "snickersnee")
  600. X!         || !strcmp(in_line, "orcrist")
  601. X!           )
  602. X!         while(gets(in_line) != NULL && in_line[0] == '\t')
  603. X!             ; /* do nothing */
  604. X!         else
  605. X! #endif
  606. X! #ifndef TOLKIEN
  607. X!         if(!strcmp(in_line, "hobbit"))
  608. X!         while(gets(in_line) != NULL && in_line[0] == '\t')
  609. X!             ; /* do nothing */
  610. X          else
  611. X  #endif
  612. X          (void) puts(in_line);
  613. X***************
  614. X*** 366,379 ****
  615. X      }
  616. X      (void) fclose(stdin);
  617. X      (void) fclose(stdout);
  618. X!     return;
  619. X  }
  620. X  
  621. X  void
  622. X! do_permonst() {
  623. X! 
  624. X      int    i;
  625. X!     char    *c;
  626. X  
  627. X      if(freopen(MONST_FILE, WRMODE, stdout) == (FILE *)0) {
  628. X          perror(MONST_FILE);
  629. X--- 427,450 ----
  630. X      }
  631. X      (void) fclose(stdin);
  632. X      (void) fclose(stdout);
  633. X! #ifdef MACOS
  634. X!     Strcpy((char *)File, DATA_FILE);
  635. X!     CtoPstr((char *)File);
  636. X!     if(!GetVol(VolName, &vRef) && !GetFInfo(File, vRef, &info)){
  637. X!         info.fdCreator = CREATOR;
  638. X!         info.fdType = TEXT_TYPE;
  639. X!         (void) SetFInfo(File, vRef, &info);
  640. X!     }
  641. X! #endif
  642. X! 
  643. X!     return;
  644. X  }
  645. X  
  646. X  void
  647. X! do_permonst()
  648. X! {
  649. X      int    i;
  650. X!     char    *c, *nam;
  651. X  
  652. X      if(freopen(MONST_FILE, WRMODE, stdout) == (FILE *)0) {
  653. X          perror(MONST_FILE);
  654. X***************
  655. X*** 384,394 ****
  656. X  
  657. X      for(i = 0; mons[i].mlet; i++) {
  658. X          Printf("\n#define\tPM_");
  659. X!         for(c = mons[i].mname; *c; c++) {
  660. X              if((*c >= 'a') && (*c <= 'z')) *c -= (char)('a' - 'A');
  661. X              else if(*c == ' ' || *c == '-')    *c = '_';
  662. X          }
  663. X!         Printf("%s\t%d", mons[i].mname, i);
  664. X      }
  665. X      Printf("\n\n#define\tNUMMONS\t%d\n", i);
  666. X      Printf("\n#endif /* PM_H /**/\n");
  667. X--- 455,465 ----
  668. X  
  669. X      for(i = 0; mons[i].mlet; i++) {
  670. X          Printf("\n#define\tPM_");
  671. X!         for(nam = c = tmpdup(mons[i].mname); *c; c++) {
  672. X              if((*c >= 'a') && (*c <= 'z')) *c -= (char)('a' - 'A');
  673. X              else if(*c == ' ' || *c == '-')    *c = '_';
  674. X          }
  675. X!         Printf("%s\t%d", nam, i);
  676. X      }
  677. X      Printf("\n\n#define\tNUMMONS\t%d\n", i);
  678. X      Printf("\n#endif /* PM_H /**/\n");
  679. X***************
  680. X*** 409,423 ****
  681. X  }
  682. X  
  683. X  void
  684. X! do_objs() {
  685. X! 
  686. X!     register int i = 0, sum = 0;
  687. X!     register char *c;
  688. X  #ifdef SPELLS
  689. X!     register int nspell = 0;
  690. X  #endif
  691. X!     register boolean prefix = 0;
  692. X!     register char let = '\0';
  693. X      boolean    sumerr = FALSE;
  694. X  
  695. X      if(freopen(ONAME_FILE, WRMODE, stdout) == (FILE *)0) {
  696. X--- 480,494 ----
  697. X  }
  698. X  
  699. X  void
  700. X! do_objs()
  701. X! {
  702. X!     int i = 0, sum = 0;
  703. X!     char *c, *objnam;
  704. X  #ifdef SPELLS
  705. X!     int nspell = 0;
  706. X  #endif
  707. X!     boolean prefix = 0;
  708. X!     char let = '\0';
  709. X      boolean    sumerr = FALSE;
  710. X  
  711. X      if(freopen(ONAME_FILE, WRMODE, stdout) == (FILE *)0) {
  712. X***************
  713. X*** 428,434 ****
  714. X      Printf("#ifndef ONAMES_H\n#define ONAMES_H\n\n");
  715. X  
  716. X      for(i = 0; !i || objects[i].oc_olet != ILLOBJ_SYM; i++) {
  717. X!         if (!(c = objects[i].oc_name)) continue;
  718. X  
  719. X          /* make sure probabilities add up to 1000 */
  720. X          if(objects[i].oc_olet != let) {
  721. X--- 499,505 ----
  722. X      Printf("#ifndef ONAMES_H\n#define ONAMES_H\n\n");
  723. X  
  724. X      for(i = 0; !i || objects[i].oc_olet != ILLOBJ_SYM; i++) {
  725. X!         if (!(objnam = tmpdup(objects[i].oc_name))) continue;
  726. X  
  727. X          /* make sure probabilities add up to 1000 */
  728. X          if(objects[i].oc_olet != let) {
  729. X***************
  730. X*** 442,448 ****
  731. X              sum = 0;
  732. X          }
  733. X  
  734. X!         for(; *c; c++) {
  735. X              if((*c >= 'a') && (*c <= 'z')) *c -= (char)('a' - 'A');
  736. X              else if(*c == ' ' || *c == '-')    *c = '_';
  737. X          }
  738. X--- 513,519 ----
  739. X              sum = 0;
  740. X          }
  741. X  
  742. X!         for(c = objnam; *c; c++) {
  743. X              if((*c >= 'a') && (*c <= 'z')) *c -= (char)('a' - 'A');
  744. X              else if(*c == ' ' || *c == '-')    *c = '_';
  745. X          }
  746. X***************
  747. X*** 464,476 ****
  748. X              /* avoid trouble with stupid C preprocessors */
  749. X              if(objects[i].oc_material == GLASS) {
  750. X                  Printf("/* #define\t%s\t%d */\n",
  751. X!                             objects[i].oc_name, i);
  752. X                  continue;
  753. X              }
  754. X              default:
  755. X              Printf("#define\t");
  756. X          }
  757. X!         Printf("%s\t%d\n", limit(objects[i].oc_name, prefix), i);
  758. X          prefix = 0;
  759. X  
  760. X          sum += objects[i].oc_prob;
  761. X--- 535,547 ----
  762. X              /* avoid trouble with stupid C preprocessors */
  763. X              if(objects[i].oc_material == GLASS) {
  764. X                  Printf("/* #define\t%s\t%d */\n",
  765. X!                             objnam, i);
  766. X                  continue;
  767. X              }
  768. X              default:
  769. X              Printf("#define\t");
  770. X          }
  771. X!         Printf("%s\t%d\n", limit(objnam, prefix), i);
  772. X          prefix = 0;
  773. X  
  774. X          sum += objects[i].oc_prob;
  775. X***************
  776. X*** 486,491 ****
  777. X--- 557,573 ----
  778. X      return;
  779. X  }
  780. X  
  781. X+ char *
  782. X+ tmpdup(str)
  783. X+ const char *str;
  784. X+ {
  785. X+     static char buf[128];
  786. X+ 
  787. X+     if (!str) return (char *)0;
  788. X+     (void)strncpy(buf, str, 127);
  789. X+     return buf;
  790. X+ }
  791. X+ 
  792. X  #if defined(SYSV) || defined(GENIX) || defined(UNIXDEBUG)
  793. X  void
  794. X  rename(oldname, newname)
  795. X***************
  796. X*** 536,542 ****
  797. X  #endif /* MSDOS */
  798. X  
  799. X  
  800. X! #if defined(SMALLDATA) && defined(MACOS)
  801. X  void
  802. X  do_monst()
  803. X  {
  804. X--- 618,624 ----
  805. X  #endif /* MSDOS */
  806. X  
  807. X  
  808. X! #if defined(SMALLDATA)
  809. X  void
  810. X  do_monst()
  811. X  {
  812. X***************
  813. X*** 548,559 ****
  814. X      Str255    name;
  815. X      short    findNamedFile();
  816. X      OSErr    write_resource();
  817. X!     
  818. X      for(i = 0; mons[i].mlet; i++) {
  819. X          ;
  820. X      }
  821. X      i++;
  822. X!     
  823. X      /*
  824. X       * convert to struct where character arrays instead of pointers to
  825. X       * strings are used
  826. X--- 630,641 ----
  827. X      Str255    name;
  828. X      short    findNamedFile();
  829. X      OSErr    write_resource();
  830. X! 
  831. X      for(i = 0; mons[i].mlet; i++) {
  832. X          ;
  833. X      }
  834. X      i++;
  835. X! 
  836. X      /*
  837. X       * convert to struct where character arrays instead of pointers to
  838. X       * strings are used
  839. X***************
  840. X*** 564,572 ****
  841. X          BlockMove(&(mons[j].mlet), &(pmMonst[j].pmp.mlet),
  842. X                  (long)sizeof(struct pmpart));
  843. X      }
  844. X!     
  845. X      PtrToHand((Ptr)pmMonst, &monstData, (long)(i * sizeof(struct pmstr)));
  846. X!     
  847. X      /* store the object data, in Nethack the char * will be copied in */
  848. X      for(i = 0; !i || objects[i].oc_olet != ILLOBJ_SYM; i++) {
  849. X          ;
  850. X--- 646,654 ----
  851. X          BlockMove(&(mons[j].mlet), &(pmMonst[j].pmp.mlet),
  852. X                  (long)sizeof(struct pmpart));
  853. X      }
  854. X! 
  855. X      PtrToHand((Ptr)pmMonst, &monstData, (long)(i * sizeof(struct pmstr)));
  856. X! 
  857. X      /* store the object data, in Nethack the char * will be copied in */
  858. X      for(i = 0; !i || objects[i].oc_olet != ILLOBJ_SYM; i++) {
  859. X          ;
  860. X***************
  861. X*** 573,579 ****
  862. X      }
  863. X      PtrToHand((Ptr)objects, &objData, ((i+1)*sizeof(struct objclass)));
  864. X  
  865. X!     strcpy((char *)&name[0], "\014Nethack.rsrc");
  866. X      if (findNamedFile(&name[1], 0, &reply)) {
  867. X          strncpy((char *)&name[0],(char *)&reply.fName[0], reply.fName[0]+1);
  868. X          if ((refNum = OpenResFile(name)) != -1) {
  869. X--- 655,661 ----
  870. X      }
  871. X      PtrToHand((Ptr)objects, &objData, ((i+1)*sizeof(struct objclass)));
  872. X  
  873. X!     strcpy((char *)&name[0], "\010NH3.rsrc");
  874. X      if (findNamedFile(&name[1], 0, &reply)) {
  875. X          strncpy((char *)&name[0],(char *)&reply.fName[0], reply.fName[0]+1);
  876. X          if ((refNum = OpenResFile(name)) != -1) {
  877. X***************
  878. X*** 581,594 ****
  879. X              strcpy((char *)&name[0], "\012MONST_DATA");
  880. X              if (error = write_resource(monstData,
  881. X                          MONST_DATA, name, refNum)) {
  882. X!                 SysBeep(1);
  883. X!                 Printf("Couldn't add monster data resource.\n");
  884. X              }
  885. X              strcpy((char *)&name[0], "\013OBJECT_DATA");
  886. X              if (error = write_resource(objData,
  887. X                          OBJECT_DATA, name, refNum)) {
  888. X!                 SysBeep(1);
  889. X!                 Printf("Couldn't add object data resource.\n");
  890. X              }
  891. X              CloseResFile(refNum);
  892. X              if (ResError() != noErr) {
  893. X--- 663,676 ----
  894. X              strcpy((char *)&name[0], "\012MONST_DATA");
  895. X              if (error = write_resource(monstData,
  896. X                          MONST_DATA, name, refNum)) {
  897. X!             SysBeep(1);
  898. X!             Printf("Couldn't add monster data resource.\n");
  899. X              }
  900. X              strcpy((char *)&name[0], "\013OBJECT_DATA");
  901. X              if (error = write_resource(objData,
  902. X                          OBJECT_DATA, name, refNum)) {
  903. X!             SysBeep(1);
  904. X!             Printf("Couldn't add object data resource.\n");
  905. X              }
  906. X              CloseResFile(refNum);
  907. X              if (ResError() != noErr) {
  908. X***************
  909. X*** 598,608 ****
  910. X          }
  911. X          }
  912. X      }
  913. X!     
  914. X      DisposHandle(monstData);
  915. X      DisposHandle(objData);
  916. X  }
  917. X  
  918. X  OSErr
  919. X  write_resource(data, resID, resName, refNum)
  920. X  Handle    data;
  921. X--- 680,739 ----
  922. X          }
  923. X          }
  924. X      }
  925. X! 
  926. X      DisposHandle(monstData);
  927. X      DisposHandle(objData);
  928. X+ 
  929. X+     vRef = reply.vRefNum;
  930. X+     (void) TouchFile(SHELP);
  931. X+     (void) TouchFile(HELP);
  932. X+ #ifdef NEWS
  933. X+     (void) TouchFile("news");
  934. X+ #endif
  935. X+     if(!TouchFile(RECORD))
  936. X+         (void) Create(File, vRef, CREATOR, TEXT_TYPE);
  937. X+ 
  938. X+     (void) TouchFile(CMDHELPFILE);
  939. X+     (void) TouchFile(HISTORY);
  940. X+     (void) TouchFile(OPTIONFILE);
  941. X+ #ifdef ORACLE
  942. X+     (void) TouchFile(ORACLEFILE);
  943. X+ #endif
  944. X+     (void) TouchFile(LICENSE);
  945. X+ #ifdef MACOS
  946. X+     (void) TouchFile(MACHELP);
  947. X+ #endif
  948. X+ }
  949. X+ 
  950. X+ Boolean
  951. X+ TouchFile(fname)
  952. X+ char *fname;
  953. X+ {
  954. X+     SFReply    reply;
  955. X+     short    findNamedFile();
  956. X+ 
  957. X+     Strcpy((char *)File, fname);
  958. X+     CtoPstr((char *)File);
  959. X+     File[File[0]+1] = 0;
  960. X+     reply.good = TRUE;
  961. X+     if(GetFInfo(File, vRef, &info)){
  962. X+         findNamedFile(&File[1], 2, &reply);
  963. X+         if(reply.good){
  964. X+             vRef = reply.vRefNum;
  965. X+             GetFInfo(File, vRef, &info);
  966. X+         }
  967. X+     }
  968. X+     if(reply.good){
  969. X+         info.fdCreator = CREATOR;
  970. X+         info.fdType = TEXT_TYPE;
  971. X+         (void) SetFInfo(File, vRef, &info);
  972. X+     }
  973. X+ 
  974. X+     return(reply.good);
  975. X  }
  976. X  
  977. X+ 
  978. X+ 
  979. X  OSErr
  980. X  write_resource(data, resID, resName, refNum)
  981. X  Handle    data;
  982. X***************
  983. X*** 625,632 ****
  984. X              error = ResError();
  985. X          }
  986. X          if (error != noErr) {
  987. X!             return error;
  988. X!         }
  989. X      } else if (ResError() != resNotFound && ResError() != noErr) {
  990. X              return (ResError());
  991. X      }
  992. X--- 756,763 ----
  993. X              error = ResError();
  994. X          }
  995. X          if (error != noErr) {
  996. X!             return error;
  997. X!         }
  998. X      } else if (ResError() != resNotFound && ResError() != noErr) {
  999. X              return (ResError());
  1000. X      }
  1001. X***************
  1002. X*** 645,648 ****
  1003. X      return 1;
  1004. X  }
  1005. X  # endif
  1006. X! #endif    /* SMALLDATA && MACOS */
  1007. X--- 776,779 ----
  1008. X      return 1;
  1009. X  }
  1010. X  # endif
  1011. X! #endif    /* SMALLDATA */
  1012. X*** src/Old/makemon.c    Mon Feb 19 20:27:27 1990
  1013. X--- src/makemon.c    Wed Feb 14 18:38:13 1990
  1014. X***************
  1015. X*** 1,20 ****
  1016. X! /*    SCCS Id: @(#)makemon.c    3.0    89/11/15
  1017. X  /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1018. X  /* NetHack may be freely redistributed.  See license for details. */
  1019. X  
  1020. X! #include    "hack.h"
  1021. X  
  1022. X- struct monst zeromonst;
  1023. X  static int FDECL(uncommon, (struct permonst *));
  1024. X  
  1025. X  int monstr[NUMMONS];
  1026. X  
  1027. X  #define m_initsgrp(mtmp, x, y)    m_initgrp(mtmp, x, y, 3)
  1028. X  #define m_initlgrp(mtmp, x, y)    m_initgrp(mtmp, x, y, 10)
  1029. X  #define toostrong(monindx, lev) (monstr[monindx] > lev)
  1030. X  #define tooweak(monindx, lev)    (monstr[monindx] < lev)
  1031. X  
  1032. X! static void
  1033. X  m_initgrp(mtmp, x, y, n)    /* make a group just like mtmp */
  1034. X  register struct monst *mtmp;
  1035. X  register int x, y, n;
  1036. X--- 1,38 ----
  1037. X! /*    SCCS Id: @(#)makemon.c    3.0    89/11/22
  1038. X  /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1039. X  /* NetHack may be freely redistributed.  See license for details. */
  1040. X  
  1041. X! #include "hack.h"
  1042. X! #ifdef REINCARNATION
  1043. X! # include <ctype.h>
  1044. X! #endif
  1045. X! 
  1046. X! VSTATIC struct monst zeromonst;
  1047. X  
  1048. X  static int FDECL(uncommon, (struct permonst *));
  1049. X+ OSTATIC void FDECL(m_initgrp,(struct monst *,int,int,int));
  1050. X+ static void FDECL(m_initthrow,(struct monst *,int,int));
  1051. X+ OSTATIC void FDECL(m_initweap,(struct monst *));
  1052. X+ static void FDECL(m_initinv,(struct monst *));
  1053. X+ static void FDECL(rloc_to,(struct monst *,int,int));
  1054. X+ static int FDECL(mstrength,(struct permonst *));
  1055. X  
  1056. X+ extern int monstr[];
  1057. X+ 
  1058. X+ #ifdef OVLB
  1059. X+ 
  1060. X  int monstr[NUMMONS];
  1061. X  
  1062. X+ #endif /* OVLB */
  1063. X+ 
  1064. X  #define m_initsgrp(mtmp, x, y)    m_initgrp(mtmp, x, y, 3)
  1065. X  #define m_initlgrp(mtmp, x, y)    m_initgrp(mtmp, x, y, 10)
  1066. X  #define toostrong(monindx, lev) (monstr[monindx] > lev)
  1067. X  #define tooweak(monindx, lev)    (monstr[monindx] < lev)
  1068. X  
  1069. X! #ifdef OVLB
  1070. X! 
  1071. X! XSTATIC void
  1072. X  m_initgrp(mtmp, x, y, n)    /* make a group just like mtmp */
  1073. X  register struct monst *mtmp;
  1074. X  register int x, y, n;
  1075. X***************
  1076. X*** 50,55 ****
  1077. X--- 68,74 ----
  1078. X      }
  1079. X  }
  1080. X  
  1081. X+ 
  1082. X  static void
  1083. X  m_initthrow(mtmp,otyp,oquan)
  1084. X  struct monst *mtmp;
  1085. X***************
  1086. X*** 66,72 ****
  1087. X      mpickobj(mtmp, otmp);
  1088. X  }
  1089. X  
  1090. X! static void
  1091. X  m_initweap(mtmp)
  1092. X  register struct monst *mtmp;
  1093. X  {
  1094. X--- 85,91 ----
  1095. X      mpickobj(mtmp, otmp);
  1096. X  }
  1097. X  
  1098. X! XSTATIC void
  1099. X  m_initweap(mtmp)
  1100. X  register struct monst *mtmp;
  1101. X  {
  1102. X***************
  1103. X*** 118,124 ****
  1104. X  #ifdef TOLKIEN
  1105. X          if (mm == PM_HOBBIT) {
  1106. X              switch (rn2(3)) {
  1107. X!               case 0:
  1108. X                  (void)mongets(mtmp, DAGGER);
  1109. X                  break;
  1110. X              case 1:
  1111. X--- 137,143 ----
  1112. X  #ifdef TOLKIEN
  1113. X          if (mm == PM_HOBBIT) {
  1114. X              switch (rn2(3)) {
  1115. X!             case 0:
  1116. X                  (void)mongets(mtmp, DAGGER);
  1117. X                  break;
  1118. X              case 1:
  1119. X***************
  1120. X*** 134,143 ****
  1121. X              (void)mongets(mtmp, IRON_SHOES);
  1122. X              if (!rn2(4)) {
  1123. X              (void)mongets(mtmp, DWARVISH_SHORT_SWORD);
  1124. X!             (void)mongets(mtmp,
  1125. X!                 rn2(3) ? DWARVISH_MATTOCK : AXE);
  1126. X              (void)mongets(mtmp, DWARVISH_IRON_HELM);
  1127. X-             (void)mongets(mtmp, DWARVISH_ROUNDSHIELD);
  1128. X              if (!rn2(3))
  1129. X                  (void)mongets(mtmp, DWARVISH_MITHRIL_COAT);
  1130. X              } else {
  1131. X--- 153,165 ----
  1132. X              (void)mongets(mtmp, IRON_SHOES);
  1133. X              if (!rn2(4)) {
  1134. X              (void)mongets(mtmp, DWARVISH_SHORT_SWORD);
  1135. X!             /* note: you can't use a mattock with a shield */
  1136. X!             if (rn2(2)) (void)mongets(mtmp, DWARVISH_MATTOCK);
  1137. X!             else {
  1138. X!                 (void)mongets(mtmp, AXE);
  1139. X!                 (void)mongets(mtmp, DWARVISH_ROUNDSHIELD);
  1140. X!             }
  1141. X              (void)mongets(mtmp, DWARVISH_IRON_HELM);
  1142. X              if (!rn2(3))
  1143. X                  (void)mongets(mtmp, DWARVISH_MITHRIL_COAT);
  1144. X              } else {
  1145. X***************
  1146. X*** 338,343 ****
  1147. X--- 360,368 ----
  1148. X      }
  1149. X  }
  1150. X  
  1151. X+ #endif /* OVLB */
  1152. X+ #ifdef OVL1
  1153. X+ 
  1154. X  static void
  1155. X  m_initinv(mtmp)
  1156. X  register struct    monst    *mtmp;
  1157. X***************
  1158. X*** 392,397 ****
  1159. X--- 417,424 ----
  1160. X              if (!rn2(2)) (void) mongets(mtmp, C_RATION);
  1161. X              }
  1162. X  #endif
  1163. X+         } else if (ptr == &mons[PM_SHOPKEEPER]) {
  1164. X+             (void) mongets(mtmp,SKELETON_KEY);
  1165. X          }
  1166. X          break;
  1167. X  
  1168. X***************
  1169. X*** 450,456 ****
  1170. X      if(x == 0 && y == 0) {
  1171. X          int uroom;
  1172. X          int tryct = 0;    /* careful with bigrooms */
  1173. X! 
  1174. X          if(!in_mklev) uroom = inroom(u.ux, u.uy);
  1175. X  
  1176. X          do {
  1177. X--- 477,485 ----
  1178. X      if(x == 0 && y == 0) {
  1179. X          int uroom;
  1180. X          int tryct = 0;    /* careful with bigrooms */
  1181. X! #ifdef __GNULINT__
  1182. X!         uroom = 0;    /* supress used before set warning */
  1183. X! #endif
  1184. X          if(!in_mklev) uroom = inroom(u.ux, u.uy);
  1185. X  
  1186. X          do {
  1187. X***************
  1188. X*** 465,480 ****
  1189. X          return((struct monst *) 0);
  1190. X  
  1191. X      if(ptr){
  1192. X!         /* if you are to make a specific monster and it has 
  1193. X             already been genocided, return */
  1194. X          if(ptr->geno & G_GENOD) return((struct monst *) 0);
  1195. X      } else {
  1196. X          /* make a random (common) monster. */
  1197. X- #ifdef REINCARNATION
  1198. X-         if (!(ptr = (dlevel==rogue_level) ? roguemon() : rndmonst()))
  1199. X- #else
  1200. X          if(!(ptr = rndmonst()))
  1201. X- #endif
  1202. X          {
  1203. X  #ifdef DEBUG
  1204. X              pline("Warning: no monster.");
  1205. X--- 494,505 ----
  1206. X          return((struct monst *) 0);
  1207. X  
  1208. X      if(ptr){
  1209. X!         /* if you are to make a specific monster and it has
  1210. X             already been genocided, return */
  1211. X          if(ptr->geno & G_GENOD) return((struct monst *) 0);
  1212. X      } else {
  1213. X          /* make a random (common) monster. */
  1214. X          if(!(ptr = rndmonst()))
  1215. X          {
  1216. X  #ifdef DEBUG
  1217. X              pline("Warning: no monster.");
  1218. X***************
  1219. X*** 489,496 ****
  1220. X      *mtmp = zeromonst;        /* clear all entries in structure */
  1221. X      for(ct = 0; ct < ptr->pxlth; ct++)
  1222. X          ((char *) &(mtmp->mextra[0]))[ct] = 0;
  1223. X-      if(type_is_pname(ptr))
  1224. X-          Strcpy(NAME(mtmp), ptr->mname);
  1225. X      mtmp->nmon = fmon;
  1226. X      fmon = mtmp;
  1227. X      mtmp->m_id = flags.ident++;
  1228. X--- 514,519 ----
  1229. X***************
  1230. X*** 503,521 ****
  1231. X          mtmp->mhpmax = mtmp->mhp = golemhp(monsndx(ptr));
  1232. X      else
  1233. X  #endif /* GOLEMS */
  1234. X!      if(ptr->mlevel > 49) {
  1235. X          /* "special" fixed hp monster
  1236. X           * the hit points are encoded in the mlevel in a somewhat strange
  1237. X           * way to fit in the 50..127 positive range of a signed character
  1238. X           * above the 1..49 that indicate "normal" monster levels */
  1239. X!          mtmp->mhpmax = mtmp->mhp = 2*(ptr->mlevel - 6);
  1240. X!          mtmp->m_lev = mtmp->mhp / 4;    /* approximation */
  1241. X!      } else if((ptr->mlet == S_DRAGON) && (ptr >= &mons[PM_GRAY_DRAGON]))
  1242. X          mtmp->mhpmax = mtmp->mhp = 80;
  1243. X      else if(!mtmp->m_lev) mtmp->mhpmax = mtmp->mhp = rnd(4);
  1244. X      else mtmp->mhpmax = mtmp->mhp = d((int)mtmp->m_lev, 8);
  1245. X      place_monster(mtmp, x, y);
  1246. X!     mtmp->mcansee = 1;
  1247. X      mtmp->mpeaceful = peace_minded(ptr);
  1248. X  
  1249. X      switch(ptr->mlet) {
  1250. X--- 526,544 ----
  1251. X          mtmp->mhpmax = mtmp->mhp = golemhp(monsndx(ptr));
  1252. X      else
  1253. X  #endif /* GOLEMS */
  1254. X!     if(ptr->mlevel > 49) {
  1255. X          /* "special" fixed hp monster
  1256. X           * the hit points are encoded in the mlevel in a somewhat strange
  1257. X           * way to fit in the 50..127 positive range of a signed character
  1258. X           * above the 1..49 that indicate "normal" monster levels */
  1259. X!         mtmp->mhpmax = mtmp->mhp = 2*(ptr->mlevel - 6);
  1260. X!         mtmp->m_lev = mtmp->mhp / 4;    /* approximation */
  1261. X!     } else if((ptr->mlet == S_DRAGON) && (ptr >= &mons[PM_GRAY_DRAGON]))
  1262. X          mtmp->mhpmax = mtmp->mhp = 80;
  1263. X      else if(!mtmp->m_lev) mtmp->mhpmax = mtmp->mhp = rnd(4);
  1264. X      else mtmp->mhpmax = mtmp->mhp = d((int)mtmp->m_lev, 8);
  1265. X      place_monster(mtmp, x, y);
  1266. X!     mtmp->mcansee = mtmp->mcanmove = 1;
  1267. X      mtmp->mpeaceful = peace_minded(ptr);
  1268. X  
  1269. X      switch(ptr->mlet) {
  1270. X***************
  1271. X*** 543,553 ****
  1272. X              if(rn2(5) && !u.uhave_amulet) mtmp->msleep = 1;
  1273. X              break;
  1274. X          case S_UNICORN:
  1275. X!             if ((ptr==&mons[PM_WHITE_UNICORN] && 
  1276. X                  u.ualigntyp == U_LAWFUL) ||
  1277. X!             (ptr==&mons[PM_GRAY_UNICORN] && 
  1278. X                  u.ualigntyp == U_NEUTRAL) ||
  1279. X!             (ptr==&mons[PM_BLACK_UNICORN] && 
  1280. X                  u.ualigntyp == U_CHAOTIC))
  1281. X                  mtmp->mpeaceful = 1;
  1282. X              break;
  1283. X--- 566,576 ----
  1284. X              if(rn2(5) && !u.uhave_amulet) mtmp->msleep = 1;
  1285. X              break;
  1286. X          case S_UNICORN:
  1287. X!             if ((ptr==&mons[PM_WHITE_UNICORN] &&
  1288. X                  u.ualigntyp == U_LAWFUL) ||
  1289. X!             (ptr==&mons[PM_GRAY_UNICORN] &&
  1290. X                  u.ualigntyp == U_NEUTRAL) ||
  1291. X!             (ptr==&mons[PM_BLACK_UNICORN] &&
  1292. X                  u.ualigntyp == U_CHAOTIC))
  1293. X                  mtmp->mpeaceful = 1;
  1294. X              break;
  1295. X***************
  1296. X*** 565,571 ****
  1297. X      } else if (ptr == &mons[PM_WIZARD_OF_YENDOR]) {
  1298. X          mtmp->iswiz = 1;
  1299. X          flags.no_of_wizards++;
  1300. X!     }
  1301. X  
  1302. X      if(in_mklev) {
  1303. X          if(((is_ndemon(ptr)) ||
  1304. X--- 588,595 ----
  1305. X      } else if (ptr == &mons[PM_WIZARD_OF_YENDOR]) {
  1306. X          mtmp->iswiz = 1;
  1307. X          flags.no_of_wizards++;
  1308. X!     } else if (ptr == &mons[PM_QUANTUM_MECHANIC])
  1309. X!         mtmp = qname(mtmp);
  1310. X  
  1311. X      if(in_mklev) {
  1312. X          if(((is_ndemon(ptr)) ||
  1313. X***************
  1314. X*** 676,684 ****
  1315. X          if (passes_walls(mdat)) return 1;
  1316. X      }
  1317. X      if (!ACCESSIBLE(levl[x][y].typ)) return 0;
  1318. X!     if (IS_DOOR(levl[x][y].typ) &&
  1319. X!             (levl[x][y].doormask & (D_LOCKED | D_CLOSED)) &&
  1320. X!             (!mdat || !amorphous(mdat)))
  1321. X          return 0;
  1322. X      if (sobj_at(BOULDER, x, y) && (!mdat || !throws_rocks(mdat)))
  1323. X          return 0;
  1324. X--- 700,706 ----
  1325. X          if (passes_walls(mdat)) return 1;
  1326. X      }
  1327. X      if (!ACCESSIBLE(levl[x][y].typ)) return 0;
  1328. X!     if (closed_door(x, y) && (!mdat || !amorphous(mdat)))
  1329. X          return 0;
  1330. X      if (sobj_at(BOULDER, x, y) && (!mdat || !throws_rocks(mdat)))
  1331. X          return 0;
  1332. X***************
  1333. X*** 685,690 ****
  1334. X--- 707,715 ----
  1335. X      return 1;
  1336. X  }
  1337. X  
  1338. X+ #endif /* OVL1 */
  1339. X+ #ifdef OVLB
  1340. X+ 
  1341. X  static void
  1342. X  rloc_to(mtmp, x, y)
  1343. X  struct monst *mtmp;
  1344. X***************
  1345. X*** 742,747 ****
  1346. X--- 767,775 ----
  1347. X      rloc(mtmp);
  1348. X  }
  1349. X  
  1350. X+ #endif /* OVLB */
  1351. X+ #ifdef OVL0
  1352. X+ 
  1353. X  static int
  1354. X  cmnum()    {    /* return the number of "common" monsters */
  1355. X  
  1356. X***************
  1357. X*** 761,766 ****
  1358. X--- 789,797 ----
  1359. X          (!Inhell ? ptr->geno & G_HELL : ptr->maligntyp > 0);
  1360. X  }
  1361. X  
  1362. X+ #endif /* OVL0 */
  1363. X+ #ifdef OVL1
  1364. X+ 
  1365. X  /* This routine is designed to return an integer value which represents
  1366. X   * an approximation of monster strength.  It uses a similar method of
  1367. X   * determination as "experience()" to arrive at the strength.
  1368. X***************
  1369. X*** 771,777 ****
  1370. X  {
  1371. X      int    i, tmp2, n, tmp = ptr->mlevel;
  1372. X  
  1373. X!      if(tmp > 49)        /* special fixed hp monster */
  1374. X          tmp = 2*(tmp - 6) / 4;
  1375. X  
  1376. X  /*    For creation in groups */
  1377. X--- 802,808 ----
  1378. X  {
  1379. X      int    i, tmp2, n, tmp = ptr->mlevel;
  1380. X  
  1381. X!     if(tmp > 49)        /* special fixed hp monster */
  1382. X          tmp = 2*(tmp - 6) / 4;
  1383. X  
  1384. X  /*    For creation in groups */
  1385. X***************
  1386. X*** 830,843 ****
  1387. X          monstr[ct] = mstrength(&(mons[ct]));
  1388. X  }
  1389. X  
  1390. X  struct    permonst *
  1391. X! rndmonst() {        /* select a random monster */
  1392. X      register struct permonst *ptr;
  1393. X      register int i, ct;
  1394. X      register int zlevel;
  1395. X      static int minmlev, maxmlev, accept;
  1396. X      static long oldmoves = 0L;    /* != 1, starting value of moves */
  1397. X  
  1398. X      if(oldmoves != moves) {        /* must recalculate accept */
  1399. X          oldmoves = moves;
  1400. X          zlevel = u.uhave_amulet ? MAXLEVEL : dlevel;
  1401. X--- 861,886 ----
  1402. X          monstr[ct] = mstrength(&(mons[ct]));
  1403. X  }
  1404. X  
  1405. X+ #endif /* OVL1 */
  1406. X+ #ifdef OVL0
  1407. X+ 
  1408. X  struct    permonst *
  1409. X! rndmonst()        /* select a random monster */
  1410. X! {
  1411. X      register struct permonst *ptr;
  1412. X      register int i, ct;
  1413. X      register int zlevel;
  1414. X      static int minmlev, maxmlev, accept;
  1415. X      static long oldmoves = 0L;    /* != 1, starting value of moves */
  1416. X+ #ifdef REINCARNATION
  1417. X+     static boolean upper;
  1418. X  
  1419. X+     upper = (dlevel == rogue_level);
  1420. X+ #endif
  1421. X+ 
  1422. X+ #ifdef __GNULINT__
  1423. X+     ptr = (struct permonst *)0; /* suppress "used uninitialized" warning */
  1424. X+ #endif
  1425. X      if(oldmoves != moves) {        /* must recalculate accept */
  1426. X          oldmoves = moves;
  1427. X          zlevel = u.uhave_amulet ? MAXLEVEL : dlevel;
  1428. X***************
  1429. X*** 855,861 ****
  1430. X  /*
  1431. X   *    Find out how many monsters exist in the range we have selected.
  1432. X   */
  1433. X!         for(accept = ct = 0 ; mons[ct].mlet; ct++) {
  1434. X          ptr = &(mons[ct]);
  1435. X          if(uncommon(ptr)) continue;
  1436. X          if(tooweak(ct, minmlev) || toostrong(ct, maxmlev))
  1437. X--- 898,910 ----
  1438. X  /*
  1439. X   *    Find out how many monsters exist in the range we have selected.
  1440. X   */
  1441. X!         accept = 0;
  1442. X! #ifdef REINCARNATION
  1443. X!         for(ct = (upper ? PM_APE : 0);
  1444. X!             upper ? isupper(mons[ct].mlet) : mons[ct].mlet; ct++) {
  1445. X! #else
  1446. X!         for(ct = 0 ; mons[ct].mlet; ct++) {
  1447. X! #endif
  1448. X          ptr = &(mons[ct]);
  1449. X          if(uncommon(ptr)) continue;
  1450. X          if(tooweak(ct, minmlev) || toostrong(ct, maxmlev))
  1451. X***************
  1452. X*** 874,880 ****
  1453. X--- 923,934 ----
  1454. X   *    Now, select a monster at random.
  1455. X   */
  1456. X      ct = rnd(accept);
  1457. X+ #ifdef REINCARNATION
  1458. X+     for(i = (upper ? PM_APE : 0);
  1459. X+         (upper ? isupper(mons[i].mlet) : mons[i].mlet) && ct > 0; i++) {
  1460. X+ #else
  1461. X      for(i = 0; mons[i].mlet && ct > 0; i++) {
  1462. X+ #endif
  1463. X          ptr = &(mons[i]);
  1464. X          if(uncommon(ptr)) continue;
  1465. X          if(tooweak(i, minmlev) || toostrong(i, maxmlev))
  1466. X***************
  1467. X*** 890,895 ****
  1468. X--- 944,952 ----
  1469. X      return(ptr);
  1470. X  }
  1471. X  
  1472. X+ #endif /* OVL0 */
  1473. X+ #ifdef OVL1
  1474. X+ 
  1475. X  /*    The routine below is used to make one of the multiple types
  1476. X   *    of a given monster class.  It will return 0 if no monsters
  1477. X   *    in that class can be made.
  1478. X***************
  1479. X*** 949,954 ****
  1480. X--- 1006,1014 ----
  1481. X      return((tmp > tmp2) ? tmp2 : (tmp > 0 ? tmp : 0)); /* 0 lower limit */
  1482. X  }
  1483. X  
  1484. X+ #endif /* OVL1 */
  1485. X+ #ifdef OVLB
  1486. X+ 
  1487. X  struct permonst *
  1488. X  grow_up(mtmp)        /* mon mtmp "grows up" to a bigger version. */
  1489. X  register struct monst *mtmp;
  1490. X***************
  1491. X*** 976,981 ****
  1492. X--- 1036,1044 ----
  1493. X      return(mtmp->data);
  1494. X  }
  1495. X  
  1496. X+ #endif /* OVLB */
  1497. X+ #ifdef OVL1
  1498. X+ 
  1499. X  int
  1500. X  mongets(mtmp, otyp)
  1501. X  register struct monst *mtmp;
  1502. X***************
  1503. X*** 989,1033 ****
  1504. X          curse(otmp);
  1505. X          }
  1506. X          mpickobj(mtmp, otmp);
  1507. X!         return(otmp->spe);        
  1508. X      } else return(0);
  1509. X  }
  1510. X  
  1511. X! #ifdef REINCARNATION
  1512. X! struct permonst *
  1513. X! roguemon()
  1514. X! {
  1515. X! /* Make a monster for a Rogue-like level; only capital letters.  There are
  1516. X!  * no checks for "too hard" or "too easy", though dragons are specifically
  1517. X!  * ruled out because playtesting showed they made the level too hard.
  1518. X!  * Modified from rndmonst().
  1519. X!  */
  1520. X! #define isupper(x) ('A'<=(x) && (x)<='Z')
  1521. X!     register struct permonst *ptr;
  1522. X!     register int accept,ct,i;
  1523. X! 
  1524. X!     /* See how many there are. */
  1525. X!     accept = 0;
  1526. X!     for(ct = PM_APE ; isupper(mons[ct].mlet); ct++) {
  1527. X!         if (mons[ct].mlet == S_DRAGON) continue;
  1528. X!         ptr = &(mons[ct]);
  1529. X!         if(uncommon(ptr)) continue;
  1530. X!         accept += (ptr->geno & G_FREQ);
  1531. X!     }
  1532. X!     if(!accept) return((struct permonst *) 0);
  1533. X! 
  1534. X!     /* Now, select one at random. */
  1535. X!     ct = rnd(accept);
  1536. X!     for(i = PM_APE; isupper(mons[i].mlet) && ct > 0; i++) {
  1537. X!         if (mons[i].mlet == S_DRAGON) continue;
  1538. X!         ptr = &(mons[i]);
  1539. X!         if(uncommon(ptr)) continue;
  1540. X!         ct -= (ptr->geno & G_FREQ);
  1541. X!     }
  1542. X!     if(ct > 0) return((struct permonst *) 0);
  1543. X!     return(ptr);
  1544. X! }
  1545. X! #endif
  1546. X  
  1547. X  #ifdef GOLEMS
  1548. X  int
  1549. X--- 1052,1063 ----
  1550. X          curse(otmp);
  1551. X          }
  1552. X          mpickobj(mtmp, otmp);
  1553. X!         return(otmp->spe);
  1554. X      } else return(0);
  1555. X  }
  1556. X  
  1557. X! #endif /* OVL1 */
  1558. X! #ifdef OVLB
  1559. X  
  1560. X  #ifdef GOLEMS
  1561. X  int
  1562. X***************
  1563. X*** 1048,1053 ****
  1564. X--- 1078,1086 ----
  1565. X  }
  1566. X  #endif /* GOLEMS */
  1567. X  
  1568. X+ #endif /* OVLB */
  1569. X+ #ifdef OVL1
  1570. X+ 
  1571. X  /*
  1572. X   *    Alignment vs. yours determines monster's attitude to you.
  1573. X   *    ( some "animal" types are co-aligned, but also hungry )
  1574. X***************
  1575. X*** 1109,1115 ****
  1576. X          mtmp->malign = abs(mal);
  1577. X  }
  1578. X  
  1579. X! static char syms[] = { 0, 0, RING_SYM, WAND_SYM, WEAPON_SYM, FOOD_SYM, GOLD_SYM,
  1580. X      SCROLL_SYM, POTION_SYM, ARMOR_SYM, AMULET_SYM, TOOL_SYM, ROCK_SYM,
  1581. X      GEM_SYM,
  1582. X  #ifdef SPELLS
  1583. X--- 1142,1151 ----
  1584. X          mtmp->malign = abs(mal);
  1585. X  }
  1586. X  
  1587. X! #endif /* OVL1 */
  1588. X! #ifdef OVLB
  1589. X! 
  1590. X! static char syms[] = { 0, 1, RING_SYM, WAND_SYM, WEAPON_SYM, FOOD_SYM, GOLD_SYM,
  1591. X      SCROLL_SYM, POTION_SYM, ARMOR_SYM, AMULET_SYM, TOOL_SYM, ROCK_SYM,
  1592. X      GEM_SYM,
  1593. X  #ifdef SPELLS
  1594. X***************
  1595. X*** 1119,1169 ****
  1596. X  };
  1597. X  
  1598. X  void
  1599. X! set_mimic_sym(mtmp) /* KAA */
  1600. X  register struct monst *mtmp;
  1601. X  {
  1602. X      int roomno, rt;
  1603. X!     char sym;
  1604. X!     if (!mtmp) return;
  1605. X! 
  1606. X!     syms[0] = UP_SYM;
  1607. X!     syms[1] = DN_SYM;
  1608. X  
  1609. X      mtmp->mimic = 1;
  1610. X!     roomno = inroom(mtmp->mx, mtmp->my);
  1611. X!     if (levl[mtmp->mx][mtmp->my].gmask)
  1612. X!         sym = GOLD_SYM;
  1613. X!     else if (OBJ_AT(mtmp->mx, mtmp->my))
  1614. X!         sym = level.objects[mtmp->mx][mtmp->my]->olet;
  1615. X!     else if (IS_DOOR(levl[mtmp->mx][mtmp->my].typ) ||
  1616. X!          IS_WALL(levl[mtmp->mx][mtmp->my].typ) ||
  1617. X!          levl[mtmp->mx][mtmp->my].typ == SDOOR ||
  1618. X!          levl[mtmp->mx][mtmp->my].typ == SCORR)
  1619. X!         sym = CLOSED_DOOR_SYM;
  1620. X!     else if (is_maze_lev)
  1621. X!         sym = rn2(2) ? ROCK_SYM : syms[rn2(sizeof syms)];
  1622. X!     else if (roomno < 0)
  1623. X!         sym = ROCK_SYM;
  1624. X!     else if ((rt = rooms[roomno].rtype) == ZOO || rt == VAULT)
  1625. X!         sym = GOLD_SYM;
  1626. X  #ifdef ORACLE
  1627. X!     else if (rt == DELPHI)
  1628. X!         sym = rn2(2) ? ROCK_SYM : FOUNTAIN_SYM;
  1629. X  #endif
  1630. X  #ifdef ALTARS
  1631. X!     else if (rt == TEMPLE)
  1632. X!         sym = ALTAR_SYM;
  1633. X  #endif
  1634. X      /* We won't bother with beehives, morgues, barracks, throne rooms
  1635. X       * since they shouldn't contain too many mimics anyway...
  1636. X       */
  1637. X      else if (rt >= SHOPBASE) {
  1638. X!         int s_sym = get_shop_item(rt - SHOPBASE);
  1639. X! 
  1640. X!         if (s_sym < 0) sym = objects[-s_sym].oc_olet;
  1641. X!         else if (s_sym == RANDOM_SYM)
  1642. X!             sym = syms[rn2(sizeof(syms)-2) + 2];
  1643. X!         else sym = s_sym;
  1644. X!     } else sym = syms[rn2(sizeof syms)];
  1645. X!     mtmp->mappearance = sym;
  1646. X  }
  1647. X--- 1155,1260 ----
  1648. X  };
  1649. X  
  1650. X  void
  1651. X! set_mimic_sym(mtmp)        /* KAA, modified by ERS */
  1652. X  register struct monst *mtmp;
  1653. X  {
  1654. X      int roomno, rt;
  1655. X!     unsigned appear, ap_type;
  1656. X!     int s_sym;
  1657. X!     struct obj *otmp;
  1658. X!     int mx, my;
  1659. X  
  1660. X+     if (!mtmp) return;
  1661. X+     mx = mtmp->mx; my = mtmp->my;
  1662. X      mtmp->mimic = 1;
  1663. X!     roomno = inroom(mx, my);
  1664. X!     if (levl[mx][my].gmask) {
  1665. X!         ap_type = M_AP_GOLD;
  1666. X!         if (g_at(mx, my)->amount <= 32767)
  1667. X!             appear = g_at(mx, my)->amount;
  1668. X!         else
  1669. X!             appear = 32000 + rnd(767);
  1670. X!     }
  1671. X!     else if (OBJ_AT(mx, my)) {
  1672. X!         ap_type = M_AP_OBJECT;
  1673. X!         appear = level.objects[mx][my]->otyp;
  1674. X!     }
  1675. X!     else if (IS_DOOR(levl[mx][my].typ) ||
  1676. X!          IS_WALL(levl[mx][my].typ) ||
  1677. X!          levl[mx][my].typ == SDOOR ||
  1678. X!          levl[mx][my].typ == SCORR) {
  1679. X!         ap_type = M_AP_FURNITURE;
  1680. X!         appear = S_cdoor;
  1681. X!     }
  1682. X!     else if (is_maze_lev && rn2(2)) {
  1683. X!         ap_type = M_AP_OBJECT;
  1684. X!         appear = STATUE;
  1685. X!     }
  1686. X!     else if (roomno < 0) {
  1687. X!         ap_type = M_AP_OBJECT;
  1688. X!         appear = BOULDER;
  1689. X!     }
  1690. X!     else if ((rt = rooms[roomno].rtype) == ZOO || rt == VAULT) {
  1691. X!         ap_type = M_AP_GOLD;
  1692. X!         appear = rn2(100)+10;    /* number of gold pieces in pile */
  1693. X!     }
  1694. X  #ifdef ORACLE
  1695. X!     else if (rt == DELPHI) {
  1696. X!         if (rn2(2)) {
  1697. X!             ap_type = M_AP_OBJECT;
  1698. X!             appear = STATUE;
  1699. X!         }
  1700. X!         else {
  1701. X!             ap_type = M_AP_FURNITURE;
  1702. X!             appear = S_fountain;
  1703. X!         }
  1704. X!     }
  1705. X  #endif
  1706. X  #ifdef ALTARS
  1707. X!     else if (rt == TEMPLE) {
  1708. X!         ap_type = M_AP_FURNITURE;
  1709. X!         appear = S_altar;
  1710. X!     }
  1711. X  #endif
  1712. X      /* We won't bother with beehives, morgues, barracks, throne rooms
  1713. X       * since they shouldn't contain too many mimics anyway...
  1714. X       */
  1715. X      else if (rt >= SHOPBASE) {
  1716. X!         s_sym = get_shop_item(rt - SHOPBASE);
  1717. X!         if (s_sym < 0) {
  1718. X!             ap_type = M_AP_OBJECT;
  1719. X!             appear = -s_sym;
  1720. X!         }
  1721. X!         else {
  1722. X!             if (s_sym == RANDOM_SYM)
  1723. X!                 s_sym = syms[rn2(sizeof(syms)-2) + 2];
  1724. X!             goto assign_sym;
  1725. X!         }
  1726. X!     }
  1727. X!     else {
  1728. X!         s_sym = syms[rn2(sizeof syms)];
  1729. X! assign_sym:
  1730. X!         if (s_sym < 2) {
  1731. X!             ap_type = M_AP_FURNITURE;
  1732. X!             appear = s_sym ? S_upstair : S_dnstair;
  1733. X!         }
  1734. X!         else if (s_sym == GOLD_SYM) {
  1735. X!             ap_type = M_AP_GOLD;
  1736. X!             appear = rn2(100)+100;
  1737. X!         }
  1738. X!         else {
  1739. X!             ap_type = M_AP_OBJECT;
  1740. X!             if (s_sym == S_MIMIC_DEF)
  1741. X!                 appear = STRANGE_OBJECT;
  1742. X!             else {
  1743. X!                 otmp = mkobj( (char) s_sym, FALSE );
  1744. X!                 appear = otmp->otyp;
  1745. X!                 free((genericptr_t) otmp);
  1746. X!             }
  1747. X!         }
  1748. X!     }
  1749. X!     mtmp->m_ap_type = ap_type;
  1750. X!     mtmp->mappearance = appear;
  1751. X  }
  1752. X+ 
  1753. X+ #endif /* OVLB */
  1754. X*** src/Old/mcastu.c    Mon Feb 19 20:28:15 1990
  1755. X--- src/mcastu.c    Sat Feb  3 11:04:43 1990
  1756. X***************
  1757. X*** 4,9 ****
  1758. X--- 4,12 ----
  1759. X  
  1760. X  #include    "hack.h"
  1761. X  
  1762. X+ #ifdef OVL0
  1763. X+ 
  1764. X+ static void FDECL(cursetxt,(struct monst *));
  1765. X  const char *spelltyp[] = {
  1766. X      "shower of missiles",
  1767. X      "fireball",
  1768. X***************
  1769. X*** 22,33 ****
  1770. X  cursetxt(mtmp)
  1771. X      register struct monst *mtmp;
  1772. X  {
  1773. X!     if(canseemon(mtmp))
  1774. X          pline("%s points at you, then curses.", Monnam(mtmp));
  1775. X!     else if((!(moves%4) || !rn2(4)) && flags.soundok) 
  1776. X          You("hear a mumbled curse.");
  1777. X  }
  1778. X  
  1779. X  int
  1780. X  castmu(mtmp, mattk)    /* monster casts spell at you */
  1781. X      register struct monst *mtmp;
  1782. X--- 25,51 ----
  1783. X  cursetxt(mtmp)
  1784. X      register struct monst *mtmp;
  1785. X  {
  1786. X!     if(canseemon(mtmp)) {
  1787. X!         if ((Invis && !perceives(mtmp->data) &&
  1788. X!                 (mtmp->mux != u.ux || mtmp->muy != u.uy))
  1789. X! #ifdef POLYSELF
  1790. X!             || u.usym == S_MIMIC_DEF || u.uundetected
  1791. X! #endif
  1792. X!                                     )
  1793. X!         pline("%s points and curses in your general direction.",
  1794. X!                 Monnam(mtmp));
  1795. X!         else if (Displaced && (mtmp->mux != u.ux || mtmp->muy != u.uy))
  1796. X!         pline("%s points and curses at your displaced image.",
  1797. X!                 Monnam(mtmp));
  1798. X!         else
  1799. X          pline("%s points at you, then curses.", Monnam(mtmp));
  1800. X!     } else if((!(moves%4) || !rn2(4)) && flags.soundok) 
  1801. X          You("hear a mumbled curse.");
  1802. X  }
  1803. X  
  1804. X+ #endif /* OVL0 */
  1805. X+ #ifdef OVLB
  1806. X+ 
  1807. X  int
  1808. X  castmu(mtmp, mattk)    /* monster casts spell at you */
  1809. X      register struct monst *mtmp;
  1810. X***************
  1811. X*** 41,47 ****
  1812. X      } else {
  1813. X          nomul(0);
  1814. X          if(rn2(ml*10) < (mtmp->mconf ? 100 : 20)) {    /* fumbled attack */
  1815. X!         if(canseemon(mtmp))
  1816. X              pline("The air crackles around %s.", mon_nam(mtmp));
  1817. X          return(0);
  1818. X          }
  1819. X--- 59,69 ----
  1820. X      } else {
  1821. X          nomul(0);
  1822. X          if(rn2(ml*10) < (mtmp->mconf ? 100 : 20)) {    /* fumbled attack */
  1823. X!         if(canseemon(mtmp)
  1824. X! #ifdef SOUNDS
  1825. X!                 && flags.soundok
  1826. X! #endif
  1827. X!                             )
  1828. X              pline("The air crackles around %s.", mon_nam(mtmp));
  1829. X          return(0);
  1830. X          }
  1831. X***************
  1832. X*** 104,109 ****
  1833. X--- 126,132 ----
  1834. X                  if(Hallucination)
  1835. X                  You("have an out of body experience.");
  1836. X                  else  {
  1837. X+                 killer_format = KILLED_BY_AN;
  1838. X                  killer = "touch of death";
  1839. X                  done(DIED);
  1840. X                  }
  1841. X***************
  1842. X*** 300,305 ****
  1843. X--- 323,331 ----
  1844. X      return(1);
  1845. X  }
  1846. X  
  1847. X+ #endif /* OVLB */
  1848. X+ #ifdef OVL0
  1849. X+ 
  1850. X  int
  1851. X  buzzmu(mtmp, mattk)        /* monster uses spell (ranged) */
  1852. X      register struct monst *mtmp;
  1853. X***************
  1854. X*** 321,324 ****
  1855. X--- 347,352 ----
  1856. X      }
  1857. X      return(1);
  1858. X  }
  1859. X+ 
  1860. X+ #endif /* OVL0 */
  1861. X  
  1862. X*** src/Old/mhitm.c    Mon Feb 19 20:28:34 1990
  1863. X--- src/mhitm.c    Sun Feb  4 13:54:28 1990
  1864. X***************
  1865. X*** 1,4 ****
  1866. X! /*    SCCS Id: @(#)mhitm.c    3.0    89/11/15
  1867. X  /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1868. X  /* NetHack may be freely redistributed.  See license for details. */
  1869. X  
  1870. X--- 1,4 ----
  1871. X! /*    SCCS Id: @(#)mhitm.c    3.0    89/11/27
  1872. X  /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1873. X  /* NetHack may be freely redistributed.  See license for details. */
  1874. X  
  1875. X***************
  1876. X*** 7,16 ****
  1877. X--- 7,20 ----
  1878. X  #  include "artifact.h"
  1879. X  #endif
  1880. X  
  1881. X+ #ifdef OVLB
  1882. X+ 
  1883. X  static boolean vis, far_noise;
  1884. X  static long noisetime;
  1885. X  static struct obj *otmp;
  1886. X  
  1887. X+ #endif /* OVLB */
  1888. X+ 
  1889. X  static void FDECL(mrustm, (struct monst *, struct monst *, struct obj *));
  1890. X  static int FDECL(hitmm, (struct monst *,struct monst *,struct attack *));
  1891. X  static int FDECL(gazemm, (struct monst *,struct monst *,struct attack *));
  1892. X***************
  1893. X*** 18,23 ****
  1894. X--- 22,31 ----
  1895. X  static int FDECL(explmm, (struct monst *,struct monst *,struct attack *));
  1896. X  static int FDECL(mdamagem, (struct monst *,struct monst *,struct attack *));
  1897. X  static void FDECL(mswingsm, (struct monst *, struct monst *, struct obj *));
  1898. X+ static void FDECL(noises,(struct monst *,struct attack *));
  1899. X+ static void FDECL(missmm,(struct monst *,struct monst *,struct attack *));
  1900. X+ 
  1901. X+ #ifdef OVLB
  1902. X  
  1903. X  static void
  1904. X  noises(magr, mattk)
  1905. X***************
  1906. X*** 55,69 ****
  1907. X      } else  noises(magr, mattk);
  1908. X  }
  1909. X  
  1910. X  int
  1911. X  fightm(mtmp)        /* have monsters fight each other */
  1912. X      register struct monst *mtmp;
  1913. X  {
  1914. X! register struct monst *mon;
  1915. X! /*    TODO:    this loop needs to be restructured, as we don't know if
  1916. X!  *        either "mon" or "mon->nmon" will exist after the attack.
  1917. X!  */
  1918. X!     for(mon = fmon; mon; mon = mon->nmon)
  1919. X          if(mon != mtmp) {
  1920. X          if(dist2(mon->mx,mon->my,mtmp->mx,mtmp->my) < 3)
  1921. X          /* note: grid bug check needed here as well as in mattackm */
  1922. X--- 63,82 ----
  1923. X      } else  noises(magr, mattk);
  1924. X  }
  1925. X  
  1926. X+ /*
  1927. X+  * fightm returns 3 if no attack, otherwise the results of mattackm
  1928. X+  */
  1929. X  int
  1930. X  fightm(mtmp)        /* have monsters fight each other */
  1931. X      register struct monst *mtmp;
  1932. X  {
  1933. X! register struct monst *mon, *nmon;
  1934. X! #ifdef LINT
  1935. X!     nmon = 0;
  1936. X! #endif
  1937. X!     for(mon = fmon; mon; mon = nmon) {
  1938. X!         nmon = mon->nmon;
  1939. X!         if(nmon == mtmp) nmon = mtmp->nmon;
  1940. X          if(mon != mtmp) {
  1941. X          if(dist2(mon->mx,mon->my,mtmp->mx,mtmp->my) < 3)
  1942. X          /* note: grid bug check needed here as well as in mattackm */
  1943. X***************
  1944. X*** 71,77 ****
  1945. X                  || mtmp->my==mon->my)
  1946. X              return(mattackm(mtmp,mon));
  1947. X          }
  1948. X!     return(-1);
  1949. X  }
  1950. X  
  1951. X  /*
  1952. X--- 84,91 ----
  1953. X                  || mtmp->my==mon->my)
  1954. X              return(mattackm(mtmp,mon));
  1955. X          }
  1956. X!     }
  1957. X!     return(3);
  1958. X  }
  1959. X  
  1960. X  /*
  1961. X***************
  1962. X*** 93,99 ****
  1963. X  
  1964. X      if(!magr || !mdef) return(0);        /* mike@genat */
  1965. X      pa = magr->data; pd = mdef->data;
  1966. X!     if(magr->mfroz) return(0);        /* riv05!a3 */
  1967. X      if(pa==&mons[PM_GRID_BUG] && magr->mx != mdef->mx
  1968. X                          && magr->my != mdef->my)
  1969. X          return(0);
  1970. X--- 107,113 ----
  1971. X  
  1972. X      if(!magr || !mdef) return(0);        /* mike@genat */
  1973. X      pa = magr->data; pd = mdef->data;
  1974. X!     if(!magr->mcanmove) return(0);        /* riv05!a3 */
  1975. X      if(pa==&mons[PM_GRID_BUG] && magr->mx != mdef->mx
  1976. X                          && magr->my != mdef->my)
  1977. X          return(0);
  1978. X***************
  1979. X*** 101,107 ****
  1980. X  /*    Calculate the armour class differential.    */
  1981. X  
  1982. X      tmp = pd->ac + magr->m_lev;
  1983. X!     if(mdef->mconf || mdef->mfroz || mdef->msleep){
  1984. X          tmp += 4;
  1985. X          if(mdef->msleep) mdef->msleep = 0;
  1986. X      }
  1987. X--- 115,121 ----
  1988. X  /*    Calculate the armour class differential.    */
  1989. X  
  1990. X      tmp = pd->ac + magr->m_lev;
  1991. X!     if(mdef->mconf || !mdef->mcanmove || mdef->msleep){
  1992. X          tmp += 4;
  1993. X          if(mdef->msleep) mdef->msleep = 0;
  1994. X      }
  1995. X***************
  1996. X*** 194,200 ****
  1997. X          if(magr->mimic) seemimic(magr);
  1998. X          if((compat = could_seduce(magr,mdef,mattk)) && !magr->mcan) {
  1999. X              Sprintf(buf, "%s %s", Monnam(magr),
  2000. X!                 mdef->mblinded ? "talks to" : "smiles at");
  2001. X              pline("%s %s %s.", buf, mon_nam(mdef),
  2002. X                  compat == 2 ?
  2003. X                      "engagingly" : "seductively");
  2004. X--- 208,214 ----
  2005. X          if(magr->mimic) seemimic(magr);
  2006. X          if((compat = could_seduce(magr,mdef,mattk)) && !magr->mcan) {
  2007. X              Sprintf(buf, "%s %s", Monnam(magr),
  2008. X!                 mdef->mcansee ? "smiles at" : "talks to");
  2009. X              pline("%s %s %s.", buf, mon_nam(mdef),
  2010. X                  compat == 2 ?
  2011. X                      "engagingly" : "seductively");
  2012. X***************
  2013. X*** 238,244 ****
  2014. X          pline("%s %s.", buf, mon_nam(mdef));
  2015. X      }
  2016. X  
  2017. X!     if (mdef->mblinded || mdef->msleep) {
  2018. X  
  2019. X          if(vis) pline("but nothing happens.");
  2020. X          return(0);
  2021. X--- 252,258 ----
  2022. X          pline("%s %s.", buf, mon_nam(mdef));
  2023. X      }
  2024. X  
  2025. X!     if (!mdef->mcansee || mdef->msleep) {
  2026. X  
  2027. X          if(vis) pline("but nothing happens.");
  2028. X          return(0);
  2029. X***************
  2030. X*** 255,260 ****
  2031. X--- 269,276 ----
  2032. X      int    mx, my, tmp;
  2033. X      char buf[BUFSZ];
  2034. X  
  2035. X+     if(mdef->data->msize >= MZ_HUGE) return 0;
  2036. X+ 
  2037. X      if(vis) {
  2038. X          Sprintf(buf,"%s swallows", Monnam(magr));
  2039. X          pline("%s %s.", buf, mon_nam(mdef));
  2040. X***************
  2041. X*** 307,312 ****
  2042. X--- 323,331 ----
  2043. X      return(2);
  2044. X  }
  2045. X  
  2046. X+ static const char psf[] =
  2047. X+     "have a peculiarly sad feeling for a moment, then it passes.";
  2048. X+ 
  2049. X  static int
  2050. X  mdamagem(magr, mdef, mattk)
  2051. X      register struct monst    *magr, *mdef;
  2052. X***************
  2053. X*** 316,324 ****
  2054. X      int    tmp = d((int)mattk->damn,(int)mattk->damd);
  2055. X      char buf[BUFSZ];
  2056. X  
  2057. X      switch(mattk->adtyp) {
  2058. X          case AD_DGST:
  2059. X!         if(flags.verbose && flags.soundok) pline("\"Burrrrp!\"");
  2060. X          tmp = mdef->mhp;
  2061. X          break;
  2062. X          case AD_STUN:
  2063. X--- 335,355 ----
  2064. X      int    tmp = d((int)mattk->damn,(int)mattk->damd);
  2065. X      char buf[BUFSZ];
  2066. X  
  2067. X+     if(mdef->data == &mons[PM_COCKATRICE] && !resists_ston(magr->data) &&
  2068. X+        (mattk->aatyp != AT_WEAP || !otmp) &&
  2069. X+        (mattk->aatyp != AT_GAZE && mattk->aatyp != AT_EXPL) &&
  2070. X+        (!is_mercenary(magr->data) || !m_carrying(magr, LEATHER_GLOVES))) {
  2071. X+        /* Note: other monsters may carry gloves, only soldiers have them */
  2072. X+        /* as their "armor" and can be said to wear them */
  2073. X+         if (vis) pline("%s turns to stone!", Monnam(magr));
  2074. X+         else if (magr->mtame) You(psf);
  2075. X+         monstone(magr);
  2076. X+         return -1;
  2077. X+     }
  2078. X+ 
  2079. X      switch(mattk->adtyp) {
  2080. X          case AD_DGST:
  2081. X!         if(flags.verbose && flags.soundok) verbalize("Burrrrp!");
  2082. X          tmp = mdef->mhp;
  2083. X          break;
  2084. X          case AD_STUN:
  2085. X***************
  2086. X*** 363,369 ****
  2087. X--- 394,402 ----
  2088. X  #ifdef GOLEMS
  2089. X          golemeffects(mdef, AD_FIRE, tmp);
  2090. X  #endif /* GOLEMS */
  2091. X+         if(vis) pline("%s is on fire!", Monnam(mdef));
  2092. X          if(resists_fire(pd)) {
  2093. X+             pline("The fire doesn't seem to burn %s!", mon_nam(mdef));
  2094. X              shieldeff(mdef->mx, mdef->my);
  2095. X              tmp = 0;
  2096. X          } else {
  2097. X***************
  2098. X*** 382,388 ****
  2099. X--- 415,424 ----
  2100. X  #ifdef GOLEMS
  2101. X          golemeffects(mdef, AD_COLD, tmp);
  2102. X  #endif /* GOLEMS */
  2103. X+         if(vis) pline("%s is covered in frost!", Monnam(mdef));
  2104. X          if(resists_cold(pd)) {
  2105. X+             pline("The frost doesn't seem to chill %s!",
  2106. X+             mon_nam(mdef));
  2107. X              shieldeff(mdef->mx, mdef->my);
  2108. X              tmp = 0;
  2109. X          } else tmp += destroy_mitem(mdef, POTION_SYM, AD_COLD);
  2110. X***************
  2111. X*** 395,401 ****
  2112. X--- 431,439 ----
  2113. X  #ifdef GOLEMS
  2114. X          golemeffects(mdef, AD_ELEC, tmp);
  2115. X  #endif /* GOLEMS */
  2116. X+         if(vis) pline("%s gets zapped!", Monnam(mdef));
  2117. X          if(resists_elec(pd)) {
  2118. X+             pline("The zap doesn't shock %s!", mon_nam(mdef));
  2119. X              shieldeff(mdef->mx, mdef->my);
  2120. X              tmp = 0;
  2121. X          }
  2122. X***************
  2123. X*** 405,411 ****
  2124. X              tmp = 0;
  2125. X              break;
  2126. X          }
  2127. X!         if(resists_acid(pd)) tmp = 0;
  2128. X          break;
  2129. X          case AD_RUST:
  2130. X  #ifdef GOLEMS
  2131. X--- 443,456 ----
  2132. X              tmp = 0;
  2133. X              break;
  2134. X          }
  2135. X!         if(resists_acid(pd)) {
  2136. X!             pline("%s is covered in acid, but it seems harmless.",
  2137. X!             Monnam(mdef));
  2138. X!             tmp = 0;
  2139. X!         } else {
  2140. X!             pline("%s is covered in acid!", Monnam(mdef));
  2141. X!             pline("It burns %s!", mon_nam(mdef));
  2142. X!         }
  2143. X          break;
  2144. X          case AD_RUST:
  2145. X  #ifdef GOLEMS
  2146. X***************
  2147. X*** 442,449 ****
  2148. X          if(!resists_ston(pd)) {
  2149. X              magr->mhpmax += 1 + rn2((int)mdef->m_lev+1);
  2150. X              if(vis) pline("%s turns to stone!", Monnam(mdef));
  2151. X!             else if(mdef->mtame)
  2152. X!      You("have a peculiarly sad feeling for a moment, then it passes.");
  2153. X              monstone(mdef);
  2154. X              ptr = grow_up(magr);
  2155. X              if(!ptr) return(-1);
  2156. X--- 487,493 ----
  2157. X          if(!resists_ston(pd)) {
  2158. X              magr->mhpmax += 1 + rn2((int)mdef->m_lev+1);
  2159. X              if(vis) pline("%s turns to stone!", Monnam(mdef));
  2160. X!             else if(mdef->mtame) You(psf);
  2161. X              monstone(mdef);
  2162. X              ptr = grow_up(magr);
  2163. X              if(!ptr) return(-1);
  2164. X***************
  2165. X*** 459,479 ****
  2166. X          }
  2167. X          break;
  2168. X          case AD_SLEE:
  2169. X!         if(!resists_sleep(pd) && !magr->mcan && vis && !mdef->msleep
  2170. X!                             && !mdef->mfroz) {
  2171. X!             pline("%s falls asleep.", Monnam(mdef));
  2172. X!             mdef->msleep = 1;
  2173. X          }
  2174. X          break;
  2175. X          case AD_PLYS:
  2176. X!         if(!magr->mcan && vis && !mdef->mfroz) {
  2177. X!             pline("%s stops moving.", Monnam(mdef));
  2178. X!             mdef->mfroz = 1;
  2179. X          }
  2180. X          break;
  2181. X          case AD_SLOW:
  2182. X          if(!magr->mcan && vis && mdef->mspeed != MSLOW) {
  2183. X!             pline("%s slows down.", Monnam(mdef));
  2184. X              if (mdef->mspeed == MFAST) mdef->mspeed = 0;
  2185. X              else mdef->mspeed = MSLOW;
  2186. X          }
  2187. X--- 503,531 ----
  2188. X          }
  2189. X          break;
  2190. X          case AD_SLEE:
  2191. X!         if(!resists_sleep(pd) && !magr->mcan && !mdef->msleep
  2192. X!                             && mdef->mcanmove) {
  2193. X!             if (vis) {
  2194. X!             Strcpy(buf, Monnam(mdef));
  2195. X!             pline("%s is put to sleep by %s.", buf, mon_nam(magr));
  2196. X!             }
  2197. X!             mdef->mcanmove = 0;
  2198. X!             mdef->mfrozen = rnd(10);
  2199. X          }
  2200. X          break;
  2201. X          case AD_PLYS:
  2202. X!         if(!magr->mcan && mdef->mcanmove) {
  2203. X!             if (vis) {
  2204. X!             Strcpy(buf, Monnam(mdef));
  2205. X!             pline("%s is frozen by %s.", buf, mon_nam(magr));
  2206. X!             }
  2207. X!             mdef->mcanmove = 0;
  2208. X!             mdef->mfrozen = rnd(10);
  2209. X          }
  2210. X          break;
  2211. X          case AD_SLOW:
  2212. X          if(!magr->mcan && vis && mdef->mspeed != MSLOW) {
  2213. X!             if (vis) pline("%s slows down.", Monnam(mdef));
  2214. X              if (mdef->mspeed == MFAST) mdef->mspeed = 0;
  2215. X              else mdef->mspeed = MSLOW;
  2216. X          }
  2217. X***************
  2218. X*** 491,497 ****
  2219. X          case AD_BLND:
  2220. X          if(!magr->mcan && haseyes(pd)) {
  2221. X  
  2222. X!             if(vis && !mdef->mblinded)
  2223. X              pline("%s is blinded.", Monnam(mdef));
  2224. X              {
  2225. X              register unsigned rnd_tmp;
  2226. X--- 543,549 ----
  2227. X          case AD_BLND:
  2228. X          if(!magr->mcan && haseyes(pd)) {
  2229. X  
  2230. X!             if(vis && mdef->mcansee)
  2231. X              pline("%s is blinded.", Monnam(mdef));
  2232. X              {
  2233. X              register unsigned rnd_tmp;
  2234. X***************
  2235. X*** 606,612 ****
  2236. X  
  2237. X      if((mdef->mhp -= tmp) < 1) {
  2238. X          magr->mhpmax += 1 + rn2((int)mdef->m_lev+1);
  2239. X!         if(vis) pline("%s is killed!", Monnam(mdef));
  2240. X          else if(mdef->mtame)
  2241. X          You("have a sad feeling for a moment, then it passes.");
  2242. X          mondied(mdef);
  2243. X--- 658,667 ----
  2244. X  
  2245. X      if((mdef->mhp -= tmp) < 1) {
  2246. X          magr->mhpmax += 1 + rn2((int)mdef->m_lev+1);
  2247. X!         if(vis)
  2248. X!         pline("%s is %s!", Monnam(mdef),
  2249. X!             (is_demon(mdef->data) || is_undead(mdef->data)) ?
  2250. X!              "destroyed" : "killed");
  2251. X          else if(mdef->mtame)
  2252. X          You("have a sad feeling for a moment, then it passes.");
  2253. X          mondied(mdef);
  2254. X***************
  2255. X*** 620,625 ****
  2256. X--- 675,683 ----
  2257. X      return(1);
  2258. X  }
  2259. X  
  2260. X+ #endif /* OVLB */
  2261. X+ #ifdef OVL0
  2262. X+ 
  2263. X  int
  2264. X  noattacks(ptr)            /* returns 1 if monster doesn't attack */
  2265. X      struct    permonst *ptr;
  2266. X***************
  2267. X*** 632,637 ****
  2268. X--- 690,698 ----
  2269. X      return(1);
  2270. X  }
  2271. X  
  2272. X+ #endif /* OVL0 */
  2273. X+ #ifdef OVLB
  2274. X+ 
  2275. X  static void
  2276. X  mrustm(magr, mdef, obj)
  2277. X  register struct monst *magr, *mdef;
  2278. X***************
  2279. X*** 671,673 ****
  2280. X--- 732,736 ----
  2281. X            is_human(magr->data) ? "his" : "its",
  2282. X            xname(otemp), buf);
  2283. X  }
  2284. X+ 
  2285. X+ #endif /* OVLB */
  2286. X
  2287. END_OF_FILE
  2288. if test 54708 -ne `wc -c <'patch7.10'`; then
  2289.     echo shar: \"'patch7.10'\" unpacked with wrong size!
  2290. fi
  2291. # end of 'patch7.10'
  2292. echo shar: End of archive 14 \(of 30\).
  2293. cp /dev/null ark14isdone
  2294. MISSING=""
  2295. 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 ; do
  2296.     if test ! -f ark${I}isdone ; then
  2297.     MISSING="${MISSING} ${I}"
  2298.     fi
  2299. done
  2300. if test "${MISSING}" = "" ; then
  2301.     echo You have unpacked all 30 archives.
  2302.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2303. else
  2304.     echo You still need to unpack the following archives:
  2305.     echo "        " ${MISSING}
  2306. fi
  2307. ##  End of shell archive.
  2308. exit 0
  2309.