home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume7 / nethack3 / part27 < prev    next >
Text File  |  1989-07-31  |  56KB  |  2,428 lines
  1. Path: uunet!zephyr.ens.tek.com!tektronix!tekgen!tekred!saab!billr
  2. From: billr@saab.CNA.TEK.COM (Bill Randle)
  3. Newsgroups: comp.sources.games
  4. Subject: v07i082:  NetHack3 -  display oriented dungeons & dragons (Ver. 3.0), Part27/38
  5. Message-ID: <4339@tekred.CNA.TEK.COM>
  6. Date: 24 Jul 89 19:05:57 GMT
  7. Sender: nobody@tekred.CNA.TEK.COM
  8. Lines: 2417
  9. Approved: billr@saab.CNA.TEK.COM
  10.  
  11. Submitted-by: Izchak Miller <izchak@linc.cis.upenn.edu>
  12. Posting-number: Volume 7, Issue 82
  13. Archive-name: NetHack3/Part27
  14.  
  15.  
  16.  
  17. #! /bin/sh
  18. # This is a shell archive.  Remove anything before this line, then unpack
  19. # it by saving it into a file and typing "sh file".  To overwrite existing
  20. # files, type "sh file -c".  You can also feed this as standard input via
  21. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  22. # will see the following message at the end:
  23. #        "End of archive 27 (of 38)."
  24. # Contents:  others/pcmain.c src/mkmaze.c src/sp_lev.c src/unixmain.c
  25. # Wrapped by billr@saab on Sun Jul 23 21:33:10 1989
  26. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  27. if test -f 'others/pcmain.c' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'others/pcmain.c'\"
  29. else
  30. echo shar: Extracting \"'others/pcmain.c'\" \(12406 characters\)
  31. sed "s/^X//" >'others/pcmain.c' <<'END_OF_FILE'
  32. X/*    SCCS Id: @(#)pcmain.c    3.0    88/11/23
  33. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  34. X/* NetHack may be freely redistributed.  See license for details. */
  35. X/* main.c - (PC, TOS and AMIGA) version */
  36. X
  37. X#ifndef TOS
  38. X#include <signal.h>
  39. X#else
  40. X#define msmsg    cprintf
  41. X#endif
  42. X#include "hack.h"
  43. X
  44. Xchar orgdir[PATHLEN];
  45. X
  46. Xextern struct permonst mons[NUMMONS];
  47. Xextern char plname[PL_NSIZ], pl_character[PL_CSIZ];
  48. X
  49. Xint (*afternmv)(), (*occupation)();
  50. Xstatic void moveloop();    /* a helper function for MSC optimizer */
  51. X
  52. X#if defined(DGK) && !defined(TOS)
  53. Xstruct finfo    zfinfo = ZFINFO;
  54. Xint i;
  55. X#endif /* DGK && !TOS */
  56. X
  57. Xchar SAVEF[FILENAME];
  58. Xchar *hname = "NetHack";    /* used for syntax messages */
  59. Xchar obuf[BUFSIZ];    /* BUFSIZ is defined in stdio.h */
  60. Xint hackpid;        /* not used anymore, but kept in for save files */
  61. X
  62. Xextern char *nomovemsg;
  63. Xextern long wailmsg;
  64. X#ifdef __TURBOC__    /* tell Turbo C to make a bigger stack */
  65. Xextern unsigned _stklen = 0x2000;    /* 8K */
  66. Xextern unsigned char _osmajor;
  67. X#endif
  68. X
  69. X#ifdef TOS
  70. X#define OMASK    0x8000
  71. X#else
  72. X#define OMASK    0
  73. X#endif
  74. X
  75. Xint
  76. Xmain(argc,argv)
  77. Xint argc;
  78. Xchar *argv[];
  79. X{
  80. X    extern int x_maze_max, y_maze_max;
  81. X    register int fd;
  82. X    register char *dir;
  83. X
  84. X#ifdef AMIGA
  85. X    /*
  86. X     *  Make sure screen IO is initialized before anything happens.
  87. X     */
  88. X    gettty();
  89. X    startup();
  90. X#else /* AMIGA */
  91. X    /* Save current directory and make sure it gets restored when
  92. X     * the game is exited.
  93. X     */
  94. X    int (*funcp)();
  95. X
  96. X# ifdef __TURBOC__
  97. X    if (_osmajor >= 3) hname = argv[0];    /* DOS 3.0+ */
  98. X# endif
  99. X    if (getcwd(orgdir, sizeof orgdir) == NULL) {
  100. X        xputs("NetHack: current directory path too long\n");
  101. X        _exit(1);
  102. X    }
  103. X    funcp = exit;    /* Kludge to get around LINT_ARGS of signal.
  104. X             * This will produce a compiler warning, but that's OK.
  105. X             */
  106. X# ifndef TOS
  107. X    signal(SIGINT, (SIG_RET_TYPE) funcp);    /* restore original directory */
  108. X# endif
  109. X#endif /* AMIGA */
  110. X
  111. X    /* Set the default values of the presentation characters */
  112. X    memcpy((genericptr_t) &showsyms, (genericptr_t) &defsyms, sizeof(struct symbols));
  113. X    if ((dir = getenv("HACKDIR")) != NULL) {
  114. X        Strcpy(hackdir, dir);
  115. X#ifdef CHDIR
  116. X        chdirx (dir, 1);
  117. X#endif
  118. X    }
  119. X#if defined(DGK) && !defined(TOS)
  120. X    /* zero "fileinfo" array to prevent crashes on level change */
  121. X    for (i = 0 ; i <= MAXLEVEL + 1; i++)
  122. X        fileinfo[i] = zfinfo;
  123. X#endif /* DGK && !TOS */
  124. X    initoptions();
  125. X    if (!hackdir[0])
  126. X        Strcpy(hackdir, orgdir);
  127. X#ifdef TOS
  128. X    if(argc > 1 && !strncmp(argv[1], "-D", 2)) {
  129. X#else
  130. X    if(argc > 1 && !strncmp(argv[1], "-d", 2)) {
  131. X#endif
  132. X        argc--;
  133. X        argv++;
  134. X        dir = argv[0]+2;
  135. X        if(*dir == '=' || *dir == ':') dir++;
  136. X        if(!*dir && argc > 1) {
  137. X            argc--;
  138. X            argv++;
  139. X            dir = argv[0];
  140. X        }
  141. X        if(!*dir)
  142. X            error("Flag -d must be followed by a directory name.");
  143. X        Strcpy(hackdir, dir);
  144. X    }
  145. X
  146. X    /*
  147. X     * Now we know the directory containing 'record' and
  148. X     * may do a prscore().
  149. X     */
  150. X#ifdef TOS
  151. X    if(argc > 1 && !strncmp(argv[1], "-S", 2)) {
  152. X#else
  153. X    if(argc > 1 && !strncmp(argv[1], "-s", 2)) {
  154. X#endif
  155. X#ifdef CHDIR
  156. X        chdirx(hackdir,0);
  157. X#endif
  158. X        prscore(argc, argv);
  159. X        exit(0);
  160. X    }
  161. X
  162. X#ifndef AMIGA
  163. X    /*
  164. X     * It seems he really wants to play.
  165. X     * Remember tty modes, to be restored on exit.
  166. X     */
  167. X    gettty();
  168. X    setbuf(stdout,obuf);
  169. X    startup();
  170. X#endif
  171. X    setrandom();
  172. X    cls();
  173. X    u.uhp = 1;    /* prevent RIP on early quits */
  174. X    u.ux = FAR;    /* prevent nscr() */
  175. X#ifndef TOS
  176. X    /*
  177. X     * We cannot do chdir earlier, otherwise gethdate will fail.
  178. X     */
  179. X#ifdef CHDIR
  180. X    chdirx(hackdir,1);
  181. X#endif
  182. X#endif
  183. X    /*
  184. X     * Process options.
  185. X     */
  186. X    while(argc > 1 && argv[1][0] == '-'){
  187. X        argv++;
  188. X        argc--;
  189. X        switch(argv[0][1]){
  190. X#if defined(WIZARD) || defined(EXPLORE_MODE)
  191. X#ifndef TOS
  192. X        case 'D':
  193. X#endif    /* TOS */
  194. X        case 'X':
  195. X# ifdef WIZARD
  196. X            /* Must have "name" set correctly by NETHACK.CNF,
  197. X             * NETHACKOPTIONS, or -U
  198. X             * before this flag to enter wizard mode. */
  199. X            if(!strcmp(plname, WIZARD))
  200. X                wizard = TRUE;
  201. X# endif
  202. X# if defined(WIZARD) && defined(EXPLORE_MODE)
  203. X            else
  204. X# endif
  205. X# ifdef EXPLORE_MODE
  206. X                discover = TRUE;
  207. X# endif
  208. X            break;
  209. X#endif
  210. X#ifdef NEWS
  211. X        case 'N':
  212. X            flags.nonews = TRUE;
  213. X            break;
  214. X#endif
  215. X        case 'U':
  216. X            if(argv[0][2])
  217. X              (void) strncpy(plname, argv[0]+2, sizeof(plname)-1);
  218. X            else if(argc > 1) {
  219. X              argc--;
  220. X              argv++;
  221. X              (void) strncpy(plname, argv[0], sizeof(plname)-1);
  222. X            } else
  223. X                Printf("Player name expected after -U\n");
  224. X            break;
  225. X#ifdef DGK
  226. X        /* Person does not want to use a ram disk
  227. X         */
  228. X        case 'R':
  229. X            ramdisk = FALSE;
  230. X            break;
  231. X#endif
  232. X        case 'C':   /* character role is next character */
  233. X            /* allow -T for Tourist, etc. */
  234. X            (void) strncpy(pl_character, argv[0]+2,
  235. X                sizeof(pl_character)-1);
  236. X        default:
  237. X            Printf("Unknown option: %s\n", *argv);
  238. X        }
  239. X    }
  240. X
  241. X#ifdef DGK
  242. X    set_lock_and_bones();
  243. X    copybones(FROMPERM);
  244. X#endif
  245. X#ifdef WIZARD
  246. X    if (wizard)
  247. X        Strcpy(plname, "wizard");
  248. X    else
  249. X#endif
  250. X    if (!*plname)
  251. X        askname();
  252. X    plnamesuffix();        /* strip suffix from name; calls askname() */
  253. X                /* again if suffix was whole name */
  254. X                /* accepts any suffix */
  255. X#ifndef DGK
  256. X    Strcpy(lock,plname);
  257. X    Strcat(lock,".99");
  258. X#endif
  259. X    start_screen();
  260. X
  261. X    /*
  262. X     * Initialisation of the boundaries of the mazes
  263. X     * Both boundaries have to be even.
  264. X     */
  265. X
  266. X    x_maze_max = COLNO-1;
  267. X    if (x_maze_max % 2)
  268. X        x_maze_max--;
  269. X    y_maze_max = ROWNO-1;
  270. X    if (y_maze_max % 2)
  271. X        y_maze_max--;
  272. X
  273. X    /* initialize static monster strength array */
  274. X    init_monstr();
  275. X
  276. X#ifdef AMIGA
  277. X    (void) strncat(SAVEF, plname, 31-4);
  278. X#else
  279. X    (void) strncat(SAVEF, plname, 8);
  280. X#endif
  281. X    Strcat(SAVEF, ".sav");
  282. X    cls();
  283. X    if (
  284. X#ifdef DGK
  285. X        saveDiskPrompt(1) &&
  286. X#endif /* DGK */
  287. X        ((fd = open(SAVEF, OMASK)) >= 0) &&
  288. X        (uptodate(fd) || !unlink(SAVEF))) {
  289. X#ifndef TOS
  290. X        (void) signal(SIGINT, (SIG_RET_TYPE) done1);
  291. X#endif
  292. X        pline("Restoring old save file...");
  293. X        (void) fflush(stdout);
  294. X        if(!dorecover(fd))
  295. X            goto not_recovered;
  296. X        pline("Hello %s, welcome to NetHack!", plname);
  297. X        /* get shopkeeper set properly if restore is in shop */
  298. X        (void) inshop();
  299. X#ifdef EXPLORE_MODE
  300. X        if (discover) {
  301. X            You("are in non-scoring discovery mode.");
  302. X            pline("Do you want to keep the save file? ");
  303. X            if(yn() == 'n')
  304. X                (void) unlink(SAVEF);
  305. X        }
  306. X#endif
  307. X        flags.move = 0;
  308. X    } else {
  309. Xnot_recovered:
  310. X#ifdef DGK
  311. X        gameDiskPrompt();
  312. X#endif
  313. X        fobj = fcobj = invent = 0;
  314. X        fmon = fallen_down = 0;
  315. X        ftrap = 0;
  316. X        fgold = 0;
  317. X        flags.ident = 1;
  318. X        init_objects();
  319. X        u_init();
  320. X#ifndef TOS
  321. X        (void) signal(SIGINT, (SIG_RET_TYPE) done1);
  322. X#endif
  323. X        mklev();
  324. X        u.ux = xupstair;
  325. X        u.uy = yupstair;
  326. X        (void) inshop();
  327. X        setsee();
  328. X        flags.botlx = 1;
  329. X        /* Fix bug with dog not being made because a monster
  330. X         * was on the level 1 staircase
  331. X         */
  332. X        if(levl[u.ux][u.uy].mmask) mnexto(m_at(u.ux, u.uy));
  333. X        (void) makedog();
  334. X        seemons();
  335. X#ifdef NEWS
  336. X        if(flags.nonews || !readnews())
  337. X            /* after reading news we did docrt() already */
  338. X#endif
  339. X            docrt();
  340. X
  341. X        /* give welcome message before pickup messages */
  342. X        pline("Hello %s, welcome to NetHack!", plname);
  343. X        set_wear();
  344. X        pickup(1);
  345. X        read_engr_at(u.ux,u.uy);
  346. X        flags.move = 0;
  347. X    }
  348. X    flags.moonphase = phase_of_the_moon();
  349. X    if(flags.moonphase == FULL_MOON) {
  350. X        You("are lucky!  Full moon tonight.");
  351. X        if(!u.uluck) change_luck(1);
  352. X    } else if(flags.moonphase == NEW_MOON) {
  353. X        pline("Be careful!  New moon tonight.");
  354. X    }
  355. X
  356. X    initrack();
  357. X#ifndef TOS
  358. X    (void) signal(SIGINT, SIG_IGN);
  359. X#endif
  360. X    /* Help for Microsoft optimizer.  Otherwise main is too large -dgk*/
  361. X    moveloop();
  362. X    return 0;
  363. X}
  364. X
  365. Xstatic void
  366. Xmoveloop()
  367. X{
  368. X    char ch;
  369. X    int abort;
  370. X
  371. X    for(;;) {
  372. X        if(flags.move) {    /* actual time passed */
  373. X
  374. X#ifdef SOUNDS
  375. X            dosounds();
  376. X#endif
  377. X            settrack();
  378. X
  379. X            if(moves%2 == 0 ||
  380. X              (!(Fast & ~INTRINSIC) && (!Fast || rn2(3)))) {
  381. X                movemon();
  382. X#ifdef HARD
  383. X                if(!rn2(u.udemigod?25:(dlevel>30)?50:70))
  384. X#else
  385. X                if(!rn2(70))
  386. X#endif
  387. X                    (void) makemon((struct permonst *)0, 0, 0);
  388. X            }
  389. X            if(Glib) glibr();
  390. X            timeout();
  391. X            ++moves;
  392. X#ifdef THEOLOGY
  393. X            if (u.ublesscnt)  u.ublesscnt--;
  394. X#endif
  395. X#ifdef POLYSELF
  396. X            if(u.mtimedone)
  397. X                if(u.mh < 1) rehumanize();
  398. X            else
  399. X#endif
  400. X                if(u.uhp < 1) {
  401. X                You("die...");
  402. X                done("died");
  403. X                }
  404. X#ifdef POLYSELF
  405. X            if (u.mtimedone) {
  406. X                if (u.mh < u.mhmax) {
  407. X                if (Regeneration || !(moves%20)) {
  408. X                    flags.botl = 1;
  409. X                    u.mh++;
  410. X                }
  411. X                }
  412. X            }
  413. X#endif
  414. X            if(u.uhp < u.uhpmax) {
  415. X                if(u.ulevel > 9) {
  416. X                    int heal;
  417. X
  418. X                    if(HRegeneration || !(moves%3)) {
  419. X                    flags.botl = 1;
  420. X                    if (ACURR(A_CON) <= 12) heal = 1;
  421. X                    else heal = rnd((int) ACURR(A_CON)-12);
  422. X                    if (heal > u.ulevel-9) heal = u.ulevel-9;
  423. X                    u.uhp += heal;
  424. X                    if(u.uhp > u.uhpmax)
  425. X                        u.uhp = u.uhpmax;
  426. X                    }
  427. X                } else if(HRegeneration ||
  428. X                    (!(moves%((MAXULEV+12)/(u.ulevel+2)+1)))) {
  429. X                    flags.botl = 1;
  430. X                    u.uhp++;
  431. X                }
  432. X            }
  433. X#ifdef SPELLS
  434. X            if ((u.uen<u.uenmax) && (!(moves%(19-ACURR(A_INT)/2)))) {
  435. X                u.uen += rn2((int)ACURR(A_WIS)/5 + 1) + 1;
  436. X                if (u.uen > u.uenmax)  u.uen = u.uenmax;
  437. X                flags.botl = 1;
  438. X            }
  439. X#endif
  440. X            if(Teleportation && !rn2(85)) tele();
  441. X#ifdef POLYSELF
  442. X            if(Polymorph && !rn2(100))
  443. X                polyself();
  444. X            if(u.ulycn >= 0 && !rn2(80 - (20 * night())))
  445. X                you_were();
  446. X#endif
  447. X            if(Searching && multi >= 0) (void) dosearch0(1);
  448. X            gethungry();
  449. X            hatch_eggs();
  450. X            invault();
  451. X            amulet();
  452. X#ifdef HARD
  453. X            if (!rn2(40+(int)(ACURR(A_DEX)*3))) u_wipe_engr(rnd(3));
  454. X            if (u.udemigod) {
  455. X
  456. X                u.udg_cnt--;
  457. X                if(u.udg_cnt <= 0) {
  458. X
  459. X                    intervene();
  460. X                    u.udg_cnt = rn1(200, 50);
  461. X                }
  462. X            }
  463. X#endif
  464. X            restore_attrib();
  465. X        }
  466. X        if(multi < 0) {
  467. X            if(!++multi){
  468. X                pline(nomovemsg ? nomovemsg :
  469. X                    "You can move again.");
  470. X                nomovemsg = 0;
  471. X                if(afternmv) (*afternmv)();
  472. X                afternmv = 0;
  473. X            }
  474. X        }
  475. X
  476. X        find_ac();
  477. X        if(!flags.mv || Blind)
  478. X        {
  479. X            seeobjs();
  480. X            seemons();
  481. X            seeglds();
  482. X            nscr();
  483. X        }
  484. X        if(flags.time) flags.botl = 1;
  485. X
  486. X        if(flags.botl || flags.botlx) bot();
  487. X
  488. X        flags.move = 1;
  489. X
  490. X        if(multi >= 0 && occupation) {
  491. X            abort = 0;
  492. X            if (kbhit()) {
  493. X                if ((ch = Getchar()) == ABORT)
  494. X                    abort++;
  495. X#ifdef REDO
  496. X                else
  497. X                    pushch(ch);
  498. X#endif /* REDO */
  499. X            }
  500. X            if(abort || monster_nearby())
  501. X                stop_occupation();
  502. X            else if ((*occupation)() == 0)
  503. X                occupation = 0;
  504. X            if (!(++occtime % 7))
  505. X                (void) fflush(stdout);
  506. X            continue;
  507. X        }
  508. X
  509. X        if((u.uhave_amulet || Clairvoyant) && 
  510. X#ifdef ENDGAME
  511. X            dlevel != ENDLEVEL &&
  512. X#endif
  513. X            !(moves%15) && !rn2(2)) do_vicinity_map();
  514. X
  515. X        u.umoved = FALSE;
  516. X        if(multi > 0) {
  517. X            lookaround();
  518. X            if(!multi) {    /* lookaround may clear multi */
  519. X                flags.move = 0;
  520. X                continue;
  521. X            }
  522. X            if(flags.mv) {
  523. X                if(multi < COLNO && !--multi)
  524. X                    flags.mv = flags.run = 0;
  525. X                domove();
  526. X            } else {
  527. X                --multi;
  528. X                rhack(save_cm);
  529. X            }
  530. X        } else if(multi == 0) {
  531. X#ifdef MAIL
  532. X            ckmailstatus();
  533. X#endif
  534. X            rhack(NULL);
  535. X        }
  536. X        if(multi && multi%7 == 0)
  537. X            (void) fflush(stdout);
  538. X    }
  539. X}
  540. X
  541. X/*
  542. X * plname is filled either by an option (-U Player  or  -UPlayer) or
  543. X * explicitly (by being the wizard) or by askname.
  544. X * It may still contain a suffix denoting pl_character.
  545. X */
  546. Xvoid
  547. Xaskname() {
  548. X    register int c, ct;
  549. X
  550. X    Printf("\nWho are you? ");
  551. X    (void) fflush(stdout);
  552. X    ct = 0;
  553. X    while((c = Getchar()) != '\n') {
  554. X        if(c == EOF) error("End of input\n");
  555. X        /* some people get confused when their erase char is not ^H */
  556. X        if(c == '\b') {
  557. X            if(ct) {
  558. X                ct--;
  559. X#ifdef MSDOS
  560. X                msmsg("\b \b");
  561. X#endif
  562. X            }
  563. X            continue;
  564. X        }
  565. X        if(c != '-')
  566. X        if(c < 'A' || (c > 'Z' && c < 'a') || c > 'z') c = '_';
  567. X        if(ct < sizeof(plname)-1) {
  568. X#ifdef MSDOS
  569. X            msmsg("%c", c);
  570. X#endif
  571. X            plname[ct++] = c;
  572. X    }
  573. X    }
  574. X    plname[ct] = 0;
  575. X    if(ct == 0) askname();
  576. X}
  577. X
  578. X/*VARARGS1*/
  579. Xvoid
  580. Ximpossible(s,x1,x2)
  581. X    register char *s, *x1, *x2;
  582. X{
  583. X    pline(s,x1,x2);
  584. X    pline("Program in disorder - perhaps you'd better Quit.");
  585. X}
  586. X
  587. X#ifdef CHDIR
  588. Xvoid
  589. Xchdirx(dir, wr)
  590. Xchar *dir;
  591. Xboolean wr;
  592. X{
  593. X
  594. X    if(dir && chdir(dir) < 0) {
  595. X        error("Cannot chdir to %s.", dir);
  596. X    }
  597. X
  598. X    /* Change the default drive as well.
  599. X     */
  600. X#ifndef AMIGA
  601. X    chdrive(dir);
  602. X#endif
  603. X
  604. X    /* warn the player if he cannot write the record file */
  605. X    /* perhaps we should also test whether . is writable */
  606. X    /* unfortunately the access systemcall is worthless */
  607. X    if(wr) {
  608. X        register int fd;
  609. X
  610. X        if(dir == NULL)
  611. X#ifdef AMIGA
  612. X        dir = "";
  613. X#else
  614. X        dir = ".";
  615. X#endif
  616. X        if((fd = open(RECORD, 2)) < 0) {
  617. X#ifdef DGK
  618. X        char tmp[PATHLEN];
  619. X
  620. X        Strcpy(tmp, dir);
  621. X        append_slash(tmp);
  622. X        msmsg("Warning: cannot write %s%s\n", tmp, RECORD);
  623. X        getreturn("to continue");
  624. X#else
  625. X        Printf("Warning: cannot write %s/%s", dir, RECORD);
  626. X        getret();
  627. X#endif
  628. X        } else
  629. X        (void) close(fd);
  630. X    }
  631. X}
  632. X#endif /* CHDIR /**/
  633. X
  634. Xvoid
  635. Xstop_occupation()
  636. X{
  637. X    if(occupation) {
  638. X        You("stop %s.", occtxt);
  639. X        occupation = 0;
  640. X#ifdef REDO
  641. X        multi = 0;
  642. X        pushch(0);
  643. X#endif
  644. X    }
  645. X}
  646. END_OF_FILE
  647. if test 12406 -ne `wc -c <'others/pcmain.c'`; then
  648.     echo shar: \"'others/pcmain.c'\" unpacked with wrong size!
  649. fi
  650. # end of 'others/pcmain.c'
  651. fi
  652. if test -f 'src/mkmaze.c' -a "${1}" != "-c" ; then 
  653.   echo shar: Will not clobber existing file \"'src/mkmaze.c'\"
  654. else
  655. echo shar: Extracting \"'src/mkmaze.c'\" \(12398 characters\)
  656. sed "s/^X//" >'src/mkmaze.c' <<'END_OF_FILE'
  657. X/*    SCCS Id: @(#)mkmaze.c    3.0    88/10/25
  658. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  659. X/* NetHack may be freely redistributed.  See license for details. */
  660. X
  661. X#include "hack.h"
  662. X
  663. Xextern int x_maze_max, y_maze_max;
  664. X
  665. X#if defined(WALLIFIED_MAZE) || defined(STRONGHOLD)
  666. Xstatic int
  667. Xiswall(x,y)
  668. Xint x,y;
  669. X{
  670. X# ifndef WALLIFIED_MAZE
  671. X    if (x<0 || y<0 || x>COLNO-1 || y>ROWNO-1)
  672. X# else
  673. X    if (x<0 || y<0 || x>COLNO || y>ROWNO)
  674. X# endif
  675. X        return 0;
  676. X    return (IS_WALL(levl[x][y].typ) || IS_DOOR(levl[x][y].typ)
  677. X        || levl[x][y].typ == SDOOR);
  678. X}
  679. X
  680. Xvoid
  681. Xwallification(x1, y1, x2, y2, see)
  682. Xint x1, y1, x2, y2;
  683. Xboolean see;
  684. X{
  685. X    char type;
  686. X    short x,y;
  687. X    register struct rm *room;
  688. X
  689. X    if (x1 < 0) x1 = 0;
  690. X    if (x2 < x1) x2 = x1;
  691. X    if (x2 > COLNO-1) x2 = COLNO-1;
  692. X    if (x1 > x2) x1 = x2;
  693. X    if (y1 < 0) y1 = 0;
  694. X    if (y2 < y1) y2 = y1;
  695. X    if (y2 > COLNO-1) y2 = ROWNO-1;
  696. X    if (y1 > y2) y1 = y2;
  697. X    for(x = x1; x <= x2; x++)
  698. X        for(y = y1; y <= y2; y++) {
  699. X        room = &levl[x][y];
  700. X        type = room->typ;
  701. X        if (iswall(x,y)) {
  702. X            if (IS_DOOR(type)) {
  703. X            room->scrsym = DOOR_SYM;
  704. X            continue;
  705. X            } else
  706. X            if (iswall(x,y-1))
  707. X            if (iswall(x,y+1))
  708. X                if (iswall(x-1,y))
  709. X                if (iswall(x+1,y)) {
  710. X                    room->scrsym = CRWALL_SYM; /* -+- */
  711. X                    room->typ = CROSSWALL;
  712. X                } else {
  713. X                    room->scrsym = TLWALL_SYM; /* -| */
  714. X                    room->typ = TLWALL;
  715. X                }
  716. X                else
  717. X                if (iswall(x+1,y)) {
  718. X                    room->scrsym = TRWALL_SYM; /* |- */
  719. X                    room->typ = TRWALL;
  720. X                } else {
  721. X                    room->typ = VWALL;
  722. X#ifdef STRONGHOLD
  723. X                    if (is_drawbridge_wall(x,y) >= 0)
  724. X                        room->scrsym = DB_VWALL_SYM;
  725. X                    else
  726. X#endif
  727. X                        room->scrsym = VWALL_SYM; /* | */
  728. X                }
  729. X            else
  730. X                if (iswall(x-1,y))
  731. X                if (iswall(x+1,y)) {              
  732. X                    room->scrsym = TUWALL_SYM;  /*  |  */
  733. X                    room->typ = TUWALL;        /* -+- */
  734. X                } else {
  735. X                    room->scrsym = BRCORN_SYM;  /*    | */
  736. X                    room->typ = BRCORNER;        /* -+ */
  737. X                }
  738. X                else
  739. X                if (iswall(x+1,y)) {            
  740. X                    room->scrsym = BLCORN_SYM;  /* |  */
  741. X                    room->typ = BLCORNER;        /* +- */
  742. X                } else {
  743. X                    room->typ = VWALL;
  744. X#ifdef STRONGHOLD
  745. X                    if (is_drawbridge_wall(x,y) >= 0)
  746. X                        room->scrsym = DB_VWALL_SYM;
  747. X                    else
  748. X#endif
  749. X                        room->scrsym = VWALL_SYM; /* | */
  750. X                }
  751. X            else
  752. X            if (iswall(x,y+1))
  753. X                if (iswall(x-1,y))
  754. X                if (iswall(x+1,y)) {
  755. X                    room->scrsym = TDWALL_SYM;  /* -+- */
  756. X                    room->typ = TDWALL;        /*    | */
  757. X                } else {
  758. X                    room->scrsym = TRCORN_SYM;  /* -+ */
  759. X                    room->typ = TRCORNER;        /*    | */
  760. X                }
  761. X                else
  762. X                if (iswall(x+1,y)) {
  763. X                    room->scrsym = TLCORN_SYM;  /* +- */
  764. X                    room->typ = TLCORNER;        /* |  */
  765. X                } else {
  766. X                    room->typ = VWALL;
  767. X#ifdef STRONGHOLD
  768. X                    if (is_drawbridge_wall(x,y) >= 0)
  769. X                        room->scrsym = DB_VWALL_SYM;
  770. X                    else
  771. X#endif
  772. X                        room->scrsym = VWALL_SYM; /* | */
  773. X                }
  774. X            else {
  775. X                room->typ = HWALL;
  776. X#ifdef STRONGHOLD
  777. X                if (is_drawbridge_wall(x,y) >= 0)
  778. X                    room->scrsym = DB_HWALL_SYM;
  779. X                else
  780. X#endif
  781. X                    room->scrsym = HWALL_SYM;
  782. X            }
  783. X            if (type == SDOOR) room->typ = type;
  784. X            if (see) room->seen = 0;
  785. X        } else {
  786. X            switch(room->typ) {
  787. X            case STONE:
  788. X                room->scrsym = STONE_SYM;
  789. X                break;
  790. X            case CORR:
  791. X                room->scrsym = CORR_SYM;
  792. X                break;
  793. X            case ROOM:
  794. X                room->scrsym = ROOM_SYM;
  795. X            }
  796. X            if (see) room->seen = 0;
  797. X        }
  798. X        }
  799. X}
  800. X#endif /* WALLIFIED_MAZE /**/
  801. X
  802. Xstatic boolean
  803. Xokay(x,y,dir)
  804. Xint x,y;
  805. Xregister int dir;
  806. X{
  807. X    move(&x,&y,dir);
  808. X    move(&x,&y,dir);
  809. X    if(x<3 || y<3 || x>x_maze_max || y>y_maze_max || levl[x][y].typ != 0)
  810. X        return(FALSE);
  811. X    return(TRUE);
  812. X}
  813. X
  814. Xstatic void
  815. Xmaze0xy(cc)    /* find random starting point for maze generation */
  816. X    coord    *cc;
  817. X{
  818. X    cc->x = 3 + 2*rn2((x_maze_max>>1) - 1);
  819. X    cc->y = 3 + 2*rn2((y_maze_max>>1) - 1);
  820. X    return;
  821. X}
  822. X
  823. Xstatic const uchar tower[] = {
  824. X    MOAT,      MOAT,     MOAT,     MOAT,    MOAT,      MOAT,     MOAT,
  825. X    MOAT,      MOAT,     TLCORNER, HWALL,    TRCORNER, MOAT,     MOAT,
  826. X    MOAT,      TLCORNER, BRCORNER, ROOM,    BLCORNER, TRCORNER, MOAT,
  827. X    MOAT,      VWALL,    ROOM,     ROOM,    ROOM,      VWALL,    MOAT,
  828. X    MOAT,      BLCORNER, TRCORNER, ROOM,    TLCORNER, BRCORNER, MOAT,
  829. X    MOAT,      MOAT,     BLCORNER, HWALL,    BRCORNER, MOAT,     MOAT,
  830. X    MOAT,      MOAT,     MOAT,     MOAT,    MOAT,      MOAT,     MOAT,
  831. X};
  832. X 
  833. Xvoid
  834. Xmakemaz()
  835. X{
  836. X    int x,y;
  837. X    register int zx,zy;
  838. X    coord mm;
  839. X    int i;
  840. X
  841. X    is_maze_lev = TRUE;
  842. X#ifdef STRONGHOLD
  843. X    xdnladder = ydnladder = xupladder = yupladder = 0;
  844. X    if (dlevel == stronghold_level) {
  845. X        if (load_special("castle")) {
  846. X            xupstair = yupstair = 3;
  847. X            levl[xupstair][yupstair].scrsym = UP_SYM;
  848. X            levl[xupstair][yupstair].typ = STAIRS;
  849. X            return;
  850. X        }
  851. X        impossible("Cannot build the STRONGHOLD!");
  852. X    }
  853. X    if (dlevel == tower_level) {
  854. X        if (load_special("tower1")) {
  855. X            xupstair = yupstair = 3;
  856. X            levl[xupstair][yupstair].scrsym = UP_SYM;
  857. X            levl[xupstair][yupstair].typ = STAIRS;
  858. X            return;
  859. X        }
  860. X        impossible("Cannot build the TOWER!");
  861. X    }
  862. X    if (dlevel == tower_level+1) {
  863. X        if (load_special("tower2")) {
  864. X            xupstair = yupstair = 3;
  865. X            levl[xupstair][yupstair].scrsym = UP_SYM;
  866. X            levl[xupstair][yupstair].typ = STAIRS;
  867. X            return;
  868. X        }
  869. X        impossible("Cannot build the TOWER!");
  870. X    }
  871. X    if (dlevel == tower_level+2) {
  872. X        if (load_special("tower3")) {
  873. X            xupstair = yupstair = 3;
  874. X            levl[xupstair][yupstair].scrsym = UP_SYM;
  875. X            levl[xupstair][yupstair].typ = STAIRS;
  876. X            return;
  877. X        }
  878. X        impossible("Cannot build the TOWER!");
  879. X    }
  880. X# ifdef ENDGAME
  881. X    if (dlevel == ENDLEVEL) {    /* EndGame level */
  882. X        if (load_special("endgame")) {
  883. X            pline("Well done, mortal!");
  884. X            pline("But now thou must face the final Test...");
  885. X            pline("Prove thyself worthy or perish!");
  886. X            u.ux = x_maze_max - 1;
  887. X            u.uy = y_maze_max - 1;
  888. X            xupstair = yupstair = 0;
  889. X            return;
  890. X        }
  891. X        impossible("Cannot build the EndGame Level!");
  892. X        done("escaped");
  893. X    }
  894. X# endif
  895. X#endif
  896. X#ifndef WALLIFIED_MAZE
  897. X    for(x = 2; x < x_maze_max; x++)
  898. X        for(y = 2; y < y_maze_max; y++)
  899. X            levl[x][y].typ = STONE;
  900. X#else
  901. X    for(x = 2; x <= x_maze_max; x++)
  902. X        for(y = 2; y <= y_maze_max; y++)
  903. X            levl[x][y].typ = ((x % 2) && (y % 2)) ? STONE : HWALL;
  904. X#endif
  905. X
  906. X    /* make decoy wizard levels */
  907. X    if((dlevel == wiz_level) ||
  908. X#ifdef STRONGHOLD
  909. X       (!rn2(3) && (dlevel > stronghold_level+1))) {
  910. X#else
  911. X       (!rn2(3) && (dlevel > medusa_level+1))) {
  912. X#endif
  913. X
  914. X        register struct monst *mtmp;
  915. X
  916. X        zx = x_maze_max / 2;
  917. X        zy = y_maze_max / 2;
  918. X        if (!(zx % 2)) zx++;
  919. X        if (!(zy % 2)) zy++;
  920. X        for(y = zy-3, i=0; y <= zy+3; y++)
  921. X        for(x = zx-3; x <= zx+3; x++)
  922. X            levl[x][y].typ = tower[i++];
  923. X        walkfrom(zx+4, zy);
  924. X        if(mtmp = makemon(&mons[PM_HELL_HOUND], zx+1, zy))
  925. X        mtmp->msleep = 1;
  926. X        (void) makemon(&mons[PM_KRAKEN], zx+2, zy+2);
  927. X        if (dlevel == wiz_level) {
  928. X
  929. X        (void) mksobj_at(AMULET_OF_YENDOR, zx, zy);
  930. X        flags.made_amulet = 1;
  931. X#ifndef STRONGHOLD
  932. X        if(mtmp = makemon(&mons[PM_VLAD_THE_IMPALER], zx-1, zy))
  933. X            mtmp->msleep = 1;
  934. X#endif
  935. X        if(mtmp = makemon(&mons[PM_WIZARD_OF_YENDOR], zx, zy))
  936. X            mtmp->msleep = 1;
  937. X        } else {
  938. X        struct obj *ot;
  939. X            /* make a cheap plastic imitation */
  940. X        if (ot = mksobj_at(AMULET_OF_YENDOR, zx, zy))
  941. X            ot-> spe = -1;
  942. X#ifndef STRONGHOLD
  943. X        if (mtmp = makemon(&mons[PM_VAMPIRE_LORD], zx-1, zy))
  944. X            mtmp->msleep = 1;
  945. X#endif
  946. X        (void) makemon(&mons[dprince()], zx, zy);
  947. X        }
  948. X        /* they should wake up when we intrude */
  949. X        (void) maketrap(zx-1, zy, SQBRD);
  950. X        (void) maketrap(zx+1, zy, SQBRD);
  951. X        (void) maketrap(zx, zy-1, SQBRD);
  952. X        (void) maketrap(zx, zy+1, SQBRD);
  953. X    } else {
  954. X        maze0xy(&mm);
  955. X        zx = mm.x;
  956. X        zy = mm.y;
  957. X        walkfrom(zx,zy);
  958. X#ifndef STRONGHOLD    /* it's in the castle */
  959. X# ifdef HARD        /* only one wand of wishing created */
  960. X        if(!rn2(10) || (dlevel == medusa_level + 1))
  961. X# endif
  962. X        (void) mksobj_at(WAN_WISHING, zx, zy);
  963. X#endif
  964. X        (void) mksobj_at(BOULDER, zx, zy);  /* put a boulder on top of it */
  965. X    }
  966. X
  967. X#ifdef WALLIFIED_MAZE
  968. X    wallification(2, 2, x_maze_max, y_maze_max, TRUE);
  969. X#else
  970. X    for(x = 2; x < x_maze_max; x++)
  971. X        for(y = 2; y < y_maze_max; y++) {
  972. X            switch(levl[x][y].typ) {
  973. X            case STONE:
  974. X                levl[x][y].scrsym = STONE_SYM;
  975. X                break;
  976. X            case CORR:
  977. X                levl[x][y].scrsym = CORR_SYM;
  978. X                break;
  979. X            case ROOM:
  980. X                levl[x][y].scrsym = ROOM_SYM;
  981. X                break;
  982. X            case HWALL:
  983. X                levl[x][y].scrsym = HWALL_SYM;
  984. X                break;
  985. X            case VWALL:
  986. X                levl[x][y].scrsym = VWALL_SYM;
  987. X                break;
  988. X            case TLCORNER:
  989. X                levl[x][y].scrsym = TLCORN_SYM;
  990. X                break;
  991. X            case TRCORNER:
  992. X                levl[x][y].scrsym = TRCORN_SYM;
  993. X                break;
  994. X            case BLCORNER:
  995. X                levl[x][y].scrsym = BLCORN_SYM;
  996. X                break;
  997. X            case BRCORNER:
  998. X                levl[x][y].scrsym = BRCORN_SYM;
  999. X                break;
  1000. X            }
  1001. X        }
  1002. X#endif
  1003. X    mazexy(&mm);
  1004. X    levl[(xupstair = mm.x)][(yupstair = mm.y)].scrsym = UP_SYM;
  1005. X    levl[xupstair][yupstair].typ = STAIRS;
  1006. X    xdnstair = ydnstair = 0;
  1007. X#ifdef STRONGHOLD
  1008. X    if (dlevel < stronghold_level) {
  1009. X        mazexy(&mm);
  1010. X        levl[(xdnstair = mm.x)][(ydnstair = mm.y)].scrsym = DN_SYM;
  1011. X        levl[xdnstair][ydnstair].typ = STAIRS;
  1012. X    }
  1013. X#endif
  1014. X    for(x = rn1(8,11); x; x--) {
  1015. X        mazexy(&mm);
  1016. X        (void) mkobj_at(rn2(2) ? GEM_SYM : 0, mm.x, mm.y);
  1017. X    }
  1018. X    for(x = rn1(10,2); x; x--) {
  1019. X        mazexy(&mm);
  1020. X        (void) mksobj_at(BOULDER, mm.x, mm.y);
  1021. X    }
  1022. X    mazexy(&mm);
  1023. X    (void) makemon(&mons[PM_MINOTAUR], mm.x, mm.y);
  1024. X    for(x = rn1(5,7); x; x--) {
  1025. X        mazexy(&mm);
  1026. X        (void) makemon((struct permonst *) 0, mm.x, mm.y);
  1027. X    }
  1028. X    for(x = rn1(6,7); x; x--) {
  1029. X        mazexy(&mm);
  1030. X        mkgold(0L,mm.x,mm.y);
  1031. X    }
  1032. X    for(x = rn1(6,7); x; x--)
  1033. X        mktrap(0,1,(struct mkroom *) 0);
  1034. X}
  1035. X
  1036. X#ifdef MSDOS
  1037. X/* Make the mazewalk iterative by faking a stack.  This is needed to
  1038. X * ensure the mazewalk is successful in the limited stack space of
  1039. X * the program.  This iterative version uses the mimumum amount of stack
  1040. X * that is totally safe.
  1041. X */
  1042. Xvoid
  1043. Xwalkfrom(x,y)
  1044. Xint x,y;
  1045. X{
  1046. X#define CELLS (ROWNO * COLNO) / 4        /* a maze cell is 4 squares */
  1047. X    char mazex[CELLS + 1], mazey[CELLS + 1];    /* char's are OK */
  1048. X    int q, a, dir, pos;
  1049. X    int dirs[4];
  1050. X
  1051. X    pos = 1;
  1052. X    mazex[pos] = (char) x;
  1053. X    mazey[pos] = (char) y;
  1054. X    while (pos) {
  1055. X        x = (int) mazex[pos];
  1056. X        y = (int) mazey[pos];
  1057. X#ifndef WALLIFIED_MAZE
  1058. X        levl[x][y].typ = CORR;
  1059. X#else
  1060. X        levl[x][y].typ = ROOM;
  1061. X#endif
  1062. X        q = 0;
  1063. X        for (a = 0; a < 4; a++)
  1064. X            if(okay(x, y, a)) dirs[q++]= a;
  1065. X        if (!q)
  1066. X            pos--;
  1067. X        else {
  1068. X            dir = dirs[rn2(q)];
  1069. X            move(&x, &y, dir);
  1070. X#ifndef WALLIFIED_MAZE
  1071. X            levl[x][y].typ = CORR;
  1072. X#else
  1073. X            levl[x][y].typ = ROOM;
  1074. X#endif
  1075. X            move(&x, &y, dir);
  1076. X            pos++;
  1077. X            if (pos > CELLS)
  1078. X                panic("Overflow in walkfrom");
  1079. X            mazex[pos] = (char) x;
  1080. X            mazey[pos] = (char) y;
  1081. X        }
  1082. X    }
  1083. X}
  1084. X#else
  1085. X
  1086. Xvoid
  1087. Xwalkfrom(x,y) int x,y; {
  1088. Xregister int q,a,dir;
  1089. Xint dirs[4];
  1090. X#ifndef WALLIFIED_MAZE
  1091. X    levl[x][y].typ = CORR;
  1092. X#else
  1093. X    levl[x][y].typ = ROOM;
  1094. X#endif
  1095. X    while(1) {
  1096. X        q = 0;
  1097. X        for(a = 0; a < 4; a++)
  1098. X            if(okay(x,y,a)) dirs[q++]= a;
  1099. X        if(!q) return;
  1100. X        dir = dirs[rn2(q)];
  1101. X        move(&x,&y,dir);
  1102. X#ifndef WALLIFIED_MAZE
  1103. X        levl[x][y].typ = CORR;
  1104. X#else
  1105. X        levl[x][y].typ = ROOM;
  1106. X#endif
  1107. X        move(&x,&y,dir);
  1108. X        walkfrom(x,y);
  1109. X    }
  1110. X}
  1111. X#endif /* MSDOS */
  1112. X
  1113. Xvoid
  1114. Xmove(x,y,dir)
  1115. Xregister int *x, *y;
  1116. Xregister int dir;
  1117. X{
  1118. X    switch(dir){
  1119. X        case 0: --(*y); break;
  1120. X        case 1: (*x)++; break;
  1121. X        case 2: (*y)++; break;
  1122. X        case 3: --(*x); break;
  1123. X    }
  1124. X}
  1125. X
  1126. Xvoid
  1127. Xmazexy(cc)    /* find random point in generated corridors
  1128. X           i.e., don't create items in moats, bunkers, or walls */
  1129. X    coord    *cc;
  1130. X{
  1131. X    int cpt=0;
  1132. X
  1133. X    do {
  1134. X        cc->x = 3 + 2*rn2((x_maze_max>>1) - 1);
  1135. X        cc->y = 3 + 2*rn2((y_maze_max>>1) - 1);
  1136. X        cpt++;
  1137. X#ifndef WALLIFIED_MAZE
  1138. X    } while (cpt < 100 && levl[cc->x][cc->y].typ != CORR);
  1139. X#else
  1140. X    } while (cpt < 100 && levl[cc->x][cc->y].typ != ROOM);
  1141. X#endif
  1142. X    if (cpt >= 100) panic("mazexy: can't find a place!");
  1143. X    return;
  1144. X}
  1145. X
  1146. Xvoid
  1147. Xbound_digging()
  1148. X/* put a non-diggable boundary around the initial portion of a level map.
  1149. X * assumes that no level will initially put things beyond the isok() range.
  1150. X */
  1151. X{
  1152. X    register int x,y;
  1153. X    register boolean found;
  1154. X    int xmin,xmax,ymin,ymax;
  1155. X
  1156. X    found = FALSE;
  1157. X    for(xmin=1; !found; xmin++)
  1158. X        for(y=0; y<=ROWNO-1; y++)
  1159. X            if(levl[xmin][y].typ != STONE) found = TRUE;
  1160. X    xmin -= 2;
  1161. X
  1162. X    found = FALSE;
  1163. X    for(xmax=COLNO-2; !found; xmax--)
  1164. X        for(y=0; y<=ROWNO-1; y++)
  1165. X            if(levl[xmax][y].typ != STONE) found = TRUE;
  1166. X    xmax += 2;
  1167. X
  1168. X    found = FALSE;
  1169. X    for(ymin=1; !found; ymin++)
  1170. X        for(x=xmin; x<=xmax; x++)
  1171. X            if(levl[x][ymin].typ != STONE) found = TRUE;
  1172. X    ymin -= 2;
  1173. X
  1174. X    found = FALSE;
  1175. X    for(ymax=ROWNO-2; !found; ymax--)
  1176. X        for(x=xmin; x<=xmax; x++)
  1177. X            if(levl[x][ymax].typ != STONE) found = TRUE;
  1178. X    ymax += 2;
  1179. X
  1180. X    for(x=xmin; x<=xmax; x++) {
  1181. X        levl[x][ymin].diggable = W_NONDIGGABLE;
  1182. X        levl[x][ymax].diggable = W_NONDIGGABLE;
  1183. X    }
  1184. X
  1185. X    for(y=ymin; y<=ymax; y++) {
  1186. X        levl[xmin][y].diggable = W_NONDIGGABLE;
  1187. X        levl[xmax][y].diggable = W_NONDIGGABLE;
  1188. X    }
  1189. X}
  1190. END_OF_FILE
  1191. if test 12398 -ne `wc -c <'src/mkmaze.c'`; then
  1192.     echo shar: \"'src/mkmaze.c'\" unpacked with wrong size!
  1193. fi
  1194. # end of 'src/mkmaze.c'
  1195. fi
  1196. if test -f 'src/sp_lev.c' -a "${1}" != "-c" ; then 
  1197.   echo shar: Will not clobber existing file \"'src/sp_lev.c'\"
  1198. else
  1199. echo shar: Extracting \"'src/sp_lev.c'\" \(12800 characters\)
  1200. sed "s/^X//" >'src/sp_lev.c' <<'END_OF_FILE'
  1201. X/*    SCCS Id: @(#)sp_lev.c    3.0    89/01/11
  1202. X/*    Copyright (c) 1989 by Jean-Christophe Collet */
  1203. X/* NetHack may be freely redistributed.  See license for details. */
  1204. X
  1205. X/*
  1206. X * This file contains the various functions that are related to the special
  1207. X * levels.
  1208. X * It contains also the special level loader.
  1209. X *
  1210. X */
  1211. X
  1212. X#include "hack.h"
  1213. X
  1214. X#ifdef STRONGHOLD
  1215. X#include "sp_lev.h"
  1216. X
  1217. X#if defined(MSDOS) && !defined(AMIGA)
  1218. X# define RDMODE "rb"
  1219. X#else
  1220. X# define RDMODE "r"
  1221. X#endif
  1222. X
  1223. X#define LEFT    1
  1224. X#define CENTER    2
  1225. X#define RIGHT    3
  1226. X#define TOP    1
  1227. X#define BOTTOM    3
  1228. X
  1229. Xstatic walk walklist[50];
  1230. Xextern int x_maze_max, y_maze_max;
  1231. X
  1232. Xstatic char Map[COLNO][ROWNO];
  1233. Xstatic char robjects[10], rloc_x[10], rloc_y[10], rmonst[10],
  1234. X    ralign[3] = { A_CHAOS, A_NEUTRAL, A_LAW };
  1235. Xstatic xchar xstart, ystart, xsize, ysize;
  1236. X
  1237. X/*
  1238. X * Make walls of the area (x1, y1, x2, y2) non diggable
  1239. X */
  1240. X
  1241. Xstatic void
  1242. Xmake_walls_nondiggable(x1,y1,x2,y2)
  1243. Xxchar x1, y1, x2, y2;
  1244. X{
  1245. X    register xchar x, y;
  1246. X
  1247. X    for(y = y1; y <= y2; y++)
  1248. X        for(x = x1; x <= x2; x++)
  1249. X        if(IS_WALL(levl[x][y].typ))
  1250. X            levl[x][y].diggable |= W_NONDIGGABLE;
  1251. X}
  1252. X
  1253. X/*
  1254. X * Choose randomly the state (nodoor, open, closed or locked) for a door
  1255. X */
  1256. X
  1257. Xstatic int
  1258. Xrnddoor()
  1259. X{
  1260. X    int i;
  1261. X    
  1262. X    i = 1 << rn2(5);
  1263. X    i >>= 1;
  1264. X    return i;
  1265. X}
  1266. X
  1267. X/* 
  1268. X * Select a random trap
  1269. X */
  1270. X
  1271. Xstatic int
  1272. Xrndtrap()
  1273. X{
  1274. X    return(rnd(TRAPNUM-1));
  1275. X}
  1276. X
  1277. X/* 
  1278. X * Coordinates in special level files are handled specially:
  1279. X *
  1280. X *    if x or y is -11, we generate a random coordinate.
  1281. X *    if x or y is between -1 and -10, we read one from the corresponding
  1282. X *    register (x0, x1, ... x9).
  1283. X *    if x or y is nonnegative, we convert it from relative to the local map
  1284. X *    to global coordinates.
  1285. X */
  1286. X
  1287. Xstatic void
  1288. Xget_location(x, y)
  1289. Xschar *x, *y;
  1290. X{
  1291. X    int cpt = 0;
  1292. X
  1293. X    if (*x >= 0) {            /* normal locations */
  1294. X        *x += xstart;
  1295. X        *y += ystart;
  1296. X    } else if (*x > -11) {        /* special locations */
  1297. X        *y = ystart + rloc_y[ - *y - 1];
  1298. X        *x = xstart + rloc_x[ - *x - 1];
  1299. X    } else {            /* random location */
  1300. X        do {
  1301. X            *x = xstart + rn2((int)xsize);
  1302. X            *y = ystart + rn2((int)ysize);
  1303. X        } while (cpt < 100 &&
  1304. X             levl[*x][*y].typ != ROOM &&
  1305. X             levl[*x][*y].typ != CORR);
  1306. X        if(cpt >= 100)
  1307. X            panic("get_location: can't find a place!");
  1308. X    }
  1309. X
  1310. X    if (*x < 0 || *x > x_maze_max || *y < 0 || *y > y_maze_max) {
  1311. X        impossible("get_location: (%d,%d) out of bounds", *x, *y);
  1312. X        *x = x_maze_max; *y = y_maze_max;
  1313. X    }
  1314. X}
  1315. X
  1316. X/*
  1317. X * Shuffle the registers for locations, objects or monsters
  1318. X */
  1319. X
  1320. Xstatic void
  1321. Xshuffle(list, n)
  1322. Xchar list[];
  1323. Xxchar n;
  1324. X{
  1325. X    int i, j;
  1326. X    char k;
  1327. X
  1328. X    for(i = n-1; i; i--) {
  1329. X        j = rn2(i);
  1330. X
  1331. X        k = list[j];
  1332. X        list[j] = list[i];
  1333. X        list[i] = k;
  1334. X    }
  1335. X}
  1336. X
  1337. X/* 
  1338. X * Shuffle two arrays in the same order (for rloc_x & rloc_y)
  1339. X */
  1340. X
  1341. Xstatic void
  1342. Xshuffle2(list1, list2, n)
  1343. Xchar list1[], list2[];
  1344. Xxchar n;
  1345. X{
  1346. X    int i, j;
  1347. X    char k1, k2;
  1348. X
  1349. X    for(i = n-1; i; i--) {
  1350. X        j = rn2(i);
  1351. X
  1352. X        k1 = list1[j];
  1353. X        k2 = list2[j];
  1354. X
  1355. X        list1[j] = list1[i];
  1356. X        list2[j] = list2[i];
  1357. X
  1358. X        list1[i] = k1;
  1359. X        list2[i] = k2;
  1360. X    }
  1361. X}
  1362. X
  1363. X/* 
  1364. X * NOT YET IMPLEMENTED!!!
  1365. X */
  1366. X
  1367. Xstatic boolean
  1368. Xload_rooms(fd)
  1369. XFILE *fd;
  1370. X{
  1371. X    return FALSE;
  1372. X}
  1373. X
  1374. X/*
  1375. X * Select a random coordinate in the maze.
  1376. X *
  1377. X * We want a place not 'touched' by the loader.  That is, a place in
  1378. X * the maze outside every part of the special level.
  1379. X */
  1380. X
  1381. Xstatic void
  1382. Xmaze1xy(m)
  1383. Xcoord *m;
  1384. X{
  1385. X    do {
  1386. X        m->x = rn1(x_maze_max - 3, 3);
  1387. X        m->y = rn1(y_maze_max - 3, 3);
  1388. X    } while (!(m->x % 2) || !(m->y % 2) || Map[m->x][m->y]);
  1389. X}
  1390. X
  1391. X/* 
  1392. X * The Big Thing: special maze loader
  1393. X *
  1394. X * Could be cleaner, but it works.
  1395. X */
  1396. X
  1397. Xstatic boolean
  1398. Xload_maze(fd)
  1399. XFILE *fd;
  1400. X{
  1401. X    xchar   x, y, n, typ;
  1402. X    char    c;
  1403. X
  1404. X    xchar   numpart = 0, nwalk = 0;
  1405. X    uchar   halign, valign;
  1406. X
  1407. X    int     xi, yi, dir;
  1408. X    coord   mm;
  1409. X    int     mapcount, mapcountmax, mapfact;
  1410. X
  1411. X    region  tmpregion;
  1412. X    door    tmpdoor;
  1413. X    trap    tmptrap;
  1414. X    monster tmpmons;
  1415. X    object  tmpobj;
  1416. X    drawbridge tmpdb;
  1417. X    walk    tmpwalk;
  1418. X    dig     tmpdig;
  1419. X    lad     tmplad;
  1420. X#ifdef ALTARS
  1421. X    altar   tmpaltar;
  1422. X#endif
  1423. X
  1424. X    /* shuffle alignments */
  1425. X    shuffle(ralign,3);
  1426. X
  1427. X    /* Initialize map */
  1428. X    xupstair = yupstair = xdnstair = ydnstair = doorindex = 0;
  1429. X    for(x = 2; x <= x_maze_max; x++)
  1430. X    for(y = 2; y <= y_maze_max; y++) {
  1431. X#ifndef WALLIFIED_MAZE
  1432. X        levl[x][y].typ = STONE;
  1433. X#else
  1434. X        levl[x][y].typ = ((x % 2) && (y % 2)) ? STONE : HWALL;
  1435. X#endif
  1436. X        Map[x][y] = 0;
  1437. X    }
  1438. X
  1439. X    /* Start reading the file */
  1440. X    numpart = fgetc(fd); /* Number of parts */
  1441. X    if (!numpart || numpart > 9)
  1442. X    panic("load_maze error: numpart = %d", (int) numpart);
  1443. X
  1444. X    while (numpart--) {
  1445. X    halign = fgetc(fd); /* Horizontal alignment */
  1446. X    valign = fgetc(fd); /* Vertical alignment */
  1447. X    xsize  = fgetc(fd); /* size in X */
  1448. X    ysize  = fgetc(fd); /* size in Y */
  1449. X
  1450. X    switch((int) halign) {
  1451. X        case LEFT:        xstart = 3;                 break;
  1452. X        case CENTER:    xstart = 2+((x_maze_max-2-xsize)/2);    break;
  1453. X        case RIGHT:     xstart = x_maze_max-xsize-1;        break;
  1454. X    }
  1455. X    switch((int) valign) {
  1456. X        case TOP:        ystart = 3;                 break;
  1457. X        case CENTER:    ystart = 2+((y_maze_max-2-ysize)/2);    break;
  1458. X        case BOTTOM:    ystart = y_maze_max-ysize-1;        break;
  1459. X    }
  1460. X    if (!(xstart % 2)) xstart++;
  1461. X    if (!(ystart % 2)) ystart++;
  1462. X
  1463. X    /* Load the map */
  1464. X    for(y = ystart; y < ystart+ysize; y++)
  1465. X        for(x = xstart; x < xstart+xsize; x++) {
  1466. X        levl[x][y].typ = fgetc(fd);
  1467. X        initsym(x,y);
  1468. X        /* secret doors default closed */
  1469. X        if (levl[x][y].typ == SDOOR)
  1470. X          levl[x][y].doormask = D_CLOSED;
  1471. X        Map[x][y] = 1;
  1472. X        }
  1473. X
  1474. X    n = fgetc(fd); /* Random objects */
  1475. X    if(n) {
  1476. X        (void) fread((genericptr_t)robjects, 1, (int) n, fd);
  1477. X        shuffle(robjects, n);
  1478. X    }
  1479. X
  1480. X    n = fgetc(fd); /* Random locations */
  1481. X    if(n) {
  1482. X        (void) fread((genericptr_t)rloc_x, 1, (int) n, fd);
  1483. X        (void) fread((genericptr_t)rloc_y, 1, (int) n, fd);
  1484. X        shuffle2(rloc_x, rloc_y, n);
  1485. X    }
  1486. X
  1487. X    n = fgetc(fd); /* Random monsters */
  1488. X    if(n) {
  1489. X        (void) fread((genericptr_t)rmonst, 1, (int) n, fd);
  1490. X        shuffle(rmonst, n);
  1491. X    }
  1492. X
  1493. X    n = fgetc(fd); /* Number of subrooms */
  1494. X    while(n--) {
  1495. X        (void) fread((genericptr_t)&tmpregion, sizeof(tmpregion), 1, fd);
  1496. X        if (nroom >= MAXNROFROOMS) continue;
  1497. X
  1498. X        get_location(&tmpregion.x1, &tmpregion.y1);
  1499. X        get_location(&tmpregion.x2, &tmpregion.y2);
  1500. X
  1501. X        rooms[nroom].lx = tmpregion.x1;
  1502. X        rooms[nroom].ly = tmpregion.y1;
  1503. X        rooms[nroom].hx = tmpregion.x2;
  1504. X        rooms[nroom].hy = tmpregion.y2;
  1505. X        rooms[nroom].rtype = tmpregion.rtype;
  1506. X        rooms[nroom].rlit = tmpregion.rlit;
  1507. X        if (tmpregion.rlit == 1)
  1508. X            for(x = rooms[nroom].lx-1; x <= rooms[nroom].hx+1; x++)
  1509. X                for(y = rooms[nroom].ly-1; y <= rooms[nroom].hy+1; y++)
  1510. X                    levl[x][y].lit = 1;
  1511. X
  1512. X        rooms[nroom].fdoor = rooms[nroom].doorct = 0;
  1513. X
  1514. X        ++nroom;
  1515. X        rooms[nroom].hx = -1;
  1516. X    }
  1517. X
  1518. X    n = fgetc(fd); /* Number of doors */
  1519. X    while(n--) {
  1520. X        struct mkroom *croom = &rooms[0], *broom;
  1521. X        int tmp;
  1522. X
  1523. X        (void) fread((genericptr_t)&tmpdoor, sizeof(tmpdoor), 1, fd);
  1524. X
  1525. X        x = tmpdoor.x;    y = tmpdoor.y;
  1526. X        typ = tmpdoor.mask == -1 ? rnddoor() : tmpdoor.mask;
  1527. X
  1528. X        get_location(&x, &y);
  1529. X        levl[x][y].doormask = typ;
  1530. X
  1531. X        /* Now the complicated part, list it with each subroom */
  1532. X        /* The dog move and mail daemon routines use this */
  1533. X        while(croom->hx >= 0 && doorindex < DOORMAX) {
  1534. X            if(croom->hx >= x-1 && croom->lx <= x+1 &&
  1535. X               croom->hy >= y-1 && croom->ly <= y+1) {
  1536. X            /* Found it */
  1537. X            croom->doorct++;
  1538. X
  1539. X            /* Append or insert into doors[] */
  1540. X            broom = croom+1;
  1541. X            if(broom->hx < 0) tmp = doorindex;
  1542. X            else
  1543. X                for(tmp = doorindex; tmp > broom->fdoor; tmp--)
  1544. X                doors[tmp] = doors[tmp-1];
  1545. X
  1546. X            doors[tmp].x = x;
  1547. X            doors[tmp].y = y;
  1548. X            doorindex++;
  1549. X
  1550. X            for( ; broom->hx >= 0; broom++) broom->fdoor++;
  1551. X            }
  1552. X            croom++;
  1553. X        }
  1554. X    }
  1555. X
  1556. X    n = fgetc(fd); /* Number of traps */
  1557. X    while(n--) {
  1558. X        (void) fread((genericptr_t)&tmptrap, sizeof(tmptrap), 1, fd);
  1559. X
  1560. X        x = tmptrap.x;    y = tmptrap.y;
  1561. X        typ = (tmptrap.type == -1 ? rndtrap() : tmptrap.type);
  1562. X
  1563. X        get_location(&x, &y);
  1564. X        (void) maketrap(x, y, typ);
  1565. X    }
  1566. X
  1567. X    n = fgetc(fd);    /* Number of monsters */
  1568. X    while(n--) {
  1569. X        (void) fread((genericptr_t)&tmpmons, sizeof(tmpmons), 1, fd);
  1570. X
  1571. X        x = tmpmons.x;    y = tmpmons.y;
  1572. X        get_location(&x, &y);
  1573. X
  1574. X        if    (tmpmons.class >= 0)
  1575. X            c = tmpmons.class;
  1576. X        else if (tmpmons.class > -11)
  1577. X            c = rmonst[-tmpmons.class - 1];
  1578. X        else
  1579. X            c = 0;
  1580. X
  1581. X        if (!c)
  1582. X            (void) makemon((struct permonst *) 0, x, y);
  1583. X        else if (tmpmons.id != -1)
  1584. X            (void) makemon(&mons[tmpmons.id], x, y);
  1585. X        else
  1586. X            (void) makemon(mkclass(c), x, y);
  1587. X    }
  1588. X
  1589. X    n = fgetc(fd); /* Number of objects */
  1590. X    while(n--) {
  1591. X        (void) fread((genericptr_t) &tmpobj, sizeof(object),1, fd);
  1592. X
  1593. X        x = tmpobj.x;  y = tmpobj.y;
  1594. X        get_location(&x, &y);
  1595. X
  1596. X        if    (tmpobj.class >= 0)
  1597. X            c = tmpobj.class;
  1598. X        else if (tmpobj.class > -11)
  1599. X            c = robjects[-tmpobj.class - 1];
  1600. X        else
  1601. X            c = 0;
  1602. X
  1603. X        if (!c)
  1604. X            (void) mkobj_at(0, x, y);
  1605. X        else if (tmpobj.id != -1)
  1606. X            (void) mksobj_at(tmpobj.id, x, y);
  1607. X        else
  1608. X            (void) mkobj_at(c, x, y);
  1609. X    }
  1610. X
  1611. X    n = fgetc(fd); /* Number of drawbridges */
  1612. X    while(n--) {
  1613. X        (void) fread((genericptr_t)&tmpdb, sizeof(tmpdb), 1, fd);
  1614. X
  1615. X        x = tmpdb.x;  y = tmpdb.y;
  1616. X        get_location(&x, &y);
  1617. X
  1618. X        if (!create_drawbridge(x, y, tmpdb.dir, tmpdb.open))
  1619. X            impossible("Cannot create drawbridge.");
  1620. X    }
  1621. X
  1622. X    n = fgetc(fd); /* Number of mazewalks */
  1623. X    while(n--) {
  1624. X        (void) fread((genericptr_t)&tmpwalk, sizeof(tmpwalk), 1, fd);
  1625. X
  1626. X        get_location(&tmpwalk.x, &tmpwalk.y);
  1627. X
  1628. X        walklist[nwalk++] = tmpwalk;
  1629. X    }
  1630. X
  1631. X    n = fgetc(fd); /* Number of non_diggables */
  1632. X    while(n--) {
  1633. X        (void) fread((genericptr_t)&tmpdig, sizeof(tmpdig), 1, fd);
  1634. X
  1635. X        get_location(&tmpdig.x1, &tmpdig.y1);
  1636. X        get_location(&tmpdig.x2, &tmpdig.y2);
  1637. X
  1638. X        make_walls_nondiggable(tmpdig.x1, tmpdig.y1,
  1639. X                       tmpdig.x2, tmpdig.y2);
  1640. X    }
  1641. X
  1642. X    n = fgetc(fd); /* Number of ladders */
  1643. X    while(n--) {
  1644. X        (void) fread((genericptr_t)&tmplad, sizeof(tmplad), 1, fd);
  1645. X
  1646. X        x = tmplad.x;  y = tmplad.y;
  1647. X        get_location(&x, &y);
  1648. X
  1649. X        levl[x][y].typ = LADDER;
  1650. X        if (tmplad.up == 1) {
  1651. X            xupladder = x;    yupladder = y;
  1652. X            levl[x][y].ladder = LA_UP;
  1653. X        } else {
  1654. X            xdnladder = x;    ydnladder = y;
  1655. X            levl[x][y].ladder = LA_DOWN;
  1656. X        }
  1657. X    }
  1658. X
  1659. X#ifdef ALTARS
  1660. X    n = fgetc(fd); /* Number of altars */
  1661. X    while(n--) {
  1662. X        (void) fread((genericptr_t)&tmpaltar, sizeof(tmpaltar), 1, fd);
  1663. X
  1664. X        x = tmpaltar.x;  y = tmpaltar.y;
  1665. X        get_location(&x, &y);
  1666. X
  1667. X        typ = tmpaltar.align == -11 ? rn2(3) :
  1668. X              tmpaltar.align < 0    ? ralign[-tmpaltar.align-1] :
  1669. X                          tmpaltar.align;
  1670. X        if (tmpaltar.shrine)
  1671. X            typ |= A_SHRINE;
  1672. X
  1673. X        levl[x][y].typ = ALTAR;
  1674. X        levl[x][y].altarmask = typ;
  1675. X    }
  1676. X#endif /* ALTARS /**/
  1677. X    }
  1678. X
  1679. X    while(nwalk--) {
  1680. X        xi = walklist[nwalk].x;
  1681. X        yi = walklist[nwalk].y;
  1682. X        dir = walklist[nwalk].dir;
  1683. X
  1684. X        move(&xi, &yi, dir);
  1685. X        x = xi;
  1686. X        y = yi;
  1687. X
  1688. X#ifndef WALLIFIED_MAZE
  1689. X        levl[x][y].typ = CORR;
  1690. X#else
  1691. X        levl[x][y].typ = ROOM;
  1692. X#endif
  1693. X
  1694. X        /*
  1695. X         * We must be sure that the parity of the coordinates for
  1696. X         * walkfrom() is odd.  But we must also take into account
  1697. X         * what direction was chosen.
  1698. X         */
  1699. X        if(!(x % 2))
  1700. X        if (dir == W_EAST)
  1701. X            x++;
  1702. X        else
  1703. X            x--;
  1704. X
  1705. X#ifndef WALLIFIED_MAZE
  1706. X        levl[x][y].typ = CORR;
  1707. X#else
  1708. X        levl[x][y].typ = ROOM;
  1709. X#endif
  1710. X
  1711. X        if (!(y % 2))
  1712. X        if (dir == W_SOUTH)
  1713. X            y++;
  1714. X        else
  1715. X            y--;
  1716. X
  1717. X        walkfrom(x, y);
  1718. X    }
  1719. X    wallification(2, 2, x_maze_max, y_maze_max, TRUE);
  1720. X
  1721. X    /*
  1722. X     * If there's a significant portion of maze unused by the special level,
  1723. X     * we don't want it empty.
  1724. X     *
  1725. X     * Makes the number of traps, monsters, etc. proportional
  1726. X     * to the size of the maze.
  1727. X     */
  1728. X    mapcountmax = mapcount = (x_maze_max - 2) * (y_maze_max - 2);
  1729. X
  1730. X    for(x = 2; x < x_maze_max; x++)
  1731. X    for(y = 2; y < y_maze_max; y++)
  1732. X        if(Map[x][y]) mapcount--;
  1733. X
  1734. X    if (mapcount > (int) (mapcountmax / 10)) {
  1735. X        mapfact = (int) ((mapcount * 100L) / mapcountmax);
  1736. X        for(x = rnd((int) (20 * mapfact) / 100); x; x--) {
  1737. X            maze1xy(&mm);
  1738. X            (void) mkobj_at(rn2(2) ? GEM_SYM : 0, mm.x, mm.y);
  1739. X        }
  1740. X        for(x = rnd((int) (12 * mapfact) / 100); x; x--) {
  1741. X            maze1xy(&mm);
  1742. X            (void) mksobj_at(BOULDER, mm.x, mm.y);
  1743. X        }
  1744. X        maze1xy(&mm);
  1745. X        (void) makemon(&mons[PM_MINOTAUR], mm.x, mm.y);
  1746. X        for(x = rnd((int) (12 * mapfact) / 100); x; x--) {
  1747. X            maze1xy(&mm);
  1748. X            (void) makemon((struct permonst *) 0, mm.x, mm.y);
  1749. X        }
  1750. X        for(x = rn2((int) (15 * mapfact) / 100); x; x--) {
  1751. X            maze1xy(&mm);
  1752. X            mkgold(0L,mm.x,mm.y);
  1753. X        }
  1754. X        for(x = rn2((int) (15 * mapfact) / 100); x; x--) {
  1755. X            maze1xy(&mm);
  1756. X            (void) maketrap(mm.x, mm.y,rndtrap());
  1757. X        }
  1758. X    }
  1759. X    return TRUE;
  1760. X}
  1761. X
  1762. X/*
  1763. X * General loader
  1764. X */
  1765. X
  1766. Xboolean
  1767. Xload_special(name)
  1768. Xchar *name;
  1769. X{
  1770. X    FILE *fd;
  1771. X    boolean result;
  1772. X    schar c;
  1773. X
  1774. X    fd = fopen(name, RDMODE);
  1775. X    if (!fd) return FALSE;
  1776. X
  1777. X    if ((c = fgetc(fd)) == EOF) {
  1778. X        (void)fclose(fd);
  1779. X        return FALSE;
  1780. X    }
  1781. X
  1782. X    switch (c) {
  1783. X        case 1:     /* Alas, this is not yet implemented. */
  1784. X            result = load_rooms(fd);
  1785. X            break;
  1786. X        case 2:     /* But this is implemented :-) */
  1787. X            result = load_maze(fd);
  1788. X            break;
  1789. X        default:    /* ??? */
  1790. X            result = FALSE;
  1791. X    }
  1792. X    (void)fclose(fd);
  1793. X    return result;
  1794. X}
  1795. X#endif /* STRONGHOLD /**/
  1796. END_OF_FILE
  1797. if test 12800 -ne `wc -c <'src/sp_lev.c'`; then
  1798.     echo shar: \"'src/sp_lev.c'\" unpacked with wrong size!
  1799. fi
  1800. # end of 'src/sp_lev.c'
  1801. fi
  1802. if test -f 'src/unixmain.c' -a "${1}" != "-c" ; then 
  1803.   echo shar: Will not clobber existing file \"'src/unixmain.c'\"
  1804. else
  1805. echo shar: Extracting \"'src/unixmain.c'\" \(12696 characters\)
  1806. sed "s/^X//" >'src/unixmain.c' <<'END_OF_FILE'
  1807. X/*    SCCS Id: @(#)unixmain.c    3.0    89/01/13
  1808. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1809. X/* NetHack may be freely redistributed.  See license for details. */
  1810. X/* main.c - (Unix) version */
  1811. X
  1812. X#include <signal.h>
  1813. X#include <pwd.h>
  1814. X
  1815. X#include "hack.h"
  1816. X
  1817. Xint hackpid = 0;                /* current pid */
  1818. Xint locknum = 0;                /* max num of players */
  1819. X#ifdef DEF_PAGER
  1820. Xchar *catmore = 0;                /* default pager */
  1821. X#endif
  1822. Xchar SAVEF[PL_NSIZ + 11] = "save/";    /* save/99999player */
  1823. Xchar *hname = 0;        /* name of the game (argv[0] of call) */
  1824. Xchar obuf[BUFSIZ];    /* BUFSIZ is defined in stdio.h */
  1825. X
  1826. Xint (*occupation)() = DUMMY;
  1827. Xint (*afternmv)() = DUMMY;
  1828. X#ifdef CHDIR
  1829. Xstatic void chdirx();
  1830. X#endif /* CHDIR */
  1831. Xstatic void whoami(), newgame();
  1832. X
  1833. Xmain(argc,argv)
  1834. Xint argc;
  1835. Xchar *argv[];
  1836. X{
  1837. X    struct passwd *pw;
  1838. X    extern struct passwd *getpwuid();
  1839. X    extern int x_maze_max, y_maze_max;
  1840. X    register int fd;
  1841. X#ifdef CHDIR
  1842. X    register char *dir;
  1843. X#endif
  1844. X#ifdef COMPRESS
  1845. X    char    cmd[80], old[80];
  1846. X#endif
  1847. X    hname = argv[0];
  1848. X    hackpid = getpid();
  1849. X    (void) umask(0);
  1850. X
  1851. X#ifdef CHDIR            /* otherwise no chdir() */
  1852. X    /*
  1853. X     * See if we must change directory to the playground.
  1854. X     * (Perhaps hack runs suid and playground is inaccessible
  1855. X     *  for the player.)
  1856. X     * The environment variable HACKDIR is overridden by a
  1857. X     *  -d command line option (must be the first option given)
  1858. X     */
  1859. X
  1860. X    dir = getenv("HACKDIR");
  1861. X    if(argc > 1 && !strncmp(argv[1], "-d", 2)) {
  1862. X        argc--;
  1863. X        argv++;
  1864. X        dir = argv[0]+2;
  1865. X        if(*dir == '=' || *dir == ':') dir++;
  1866. X        if(!*dir && argc > 1) {
  1867. X            argc--;
  1868. X            argv++;
  1869. X            dir = argv[0];
  1870. X        }
  1871. X        if(!*dir)
  1872. X            error("Flag -d must be followed by a directory name.");
  1873. X    }
  1874. X#endif /* CHDIR /**/
  1875. X    /* Set the default values of the presentation characters */
  1876. X    (void) memcpy((char *) &showsyms, 
  1877. X        (char *) &defsyms, sizeof(struct symbols));
  1878. X    initoptions();
  1879. X    whoami();
  1880. X    /*
  1881. X     * Now we know the directory containing 'record' and
  1882. X     * may do a prscore().
  1883. X     */
  1884. X    if(argc > 1 && !strncmp(argv[1], "-s", 2)) {
  1885. X#ifdef CHDIR
  1886. X        chdirx(dir,0);
  1887. X#endif
  1888. X        prscore(argc, argv);
  1889. X        exit(0);
  1890. X    }
  1891. X
  1892. X    /*
  1893. X     * It seems he really wants to play.
  1894. X     * Remember tty modes, to be restored on exit.
  1895. X     */
  1896. X    gettty();
  1897. X    setbuf(stdout,obuf);
  1898. X    setrandom();
  1899. X    startup();
  1900. X    cls();
  1901. X    u.uhp = 1;    /* prevent RIP on early quits */
  1902. X    u.ux = FAR;    /* prevent nscr() */
  1903. X    (void) signal(SIGHUP, (SIG_RET_TYPE) hangup);
  1904. X
  1905. X    /*
  1906. X     * Find the creation date of this game,
  1907. X     * so as to avoid restoring outdated savefiles.
  1908. X     */
  1909. X    gethdate(hname);
  1910. X
  1911. X    /*
  1912. X     * We cannot do chdir earlier, otherwise gethdate will fail.
  1913. X     */
  1914. X#ifdef CHDIR
  1915. X    chdirx(dir,1);
  1916. X#endif
  1917. X
  1918. X    /*
  1919. X     * Process options.
  1920. X     */
  1921. X    while(argc > 1 && argv[1][0] == '-'){
  1922. X        argv++;
  1923. X        argc--;
  1924. X        switch(argv[0][1]){
  1925. X#if defined(WIZARD) || defined(EXPLORE_MODE)
  1926. X        case 'D':
  1927. X        case 'X':
  1928. X            pw = getpwuid(getuid());
  1929. X# ifdef WIZARD
  1930. X            if(!strcmp(pw->pw_name, WIZARD))
  1931. X                wizard = TRUE;
  1932. X# endif
  1933. X# if defined(WIZARD) && defined(EXPLORE_MODE)
  1934. X            else
  1935. X# endif
  1936. X# ifdef EXPLORE_MODE
  1937. X                discover = TRUE;
  1938. X# endif
  1939. X            break;
  1940. X#endif
  1941. X#ifdef NEWS
  1942. X        case 'n':
  1943. X            flags.nonews = TRUE;
  1944. X            break;
  1945. X#endif
  1946. X        case 'u':
  1947. X            if(argv[0][2])
  1948. X              (void) strncpy(plname, argv[0]+2, sizeof(plname)-1);
  1949. X            else if(argc > 1) {
  1950. X              argc--;
  1951. X              argv++;
  1952. X              (void) strncpy(plname, argv[0], sizeof(plname)-1);
  1953. X            } else
  1954. X                Printf("Player name expected after -u\n");
  1955. X            break;
  1956. X        default:
  1957. X            /* allow -T for Tourist, etc. */
  1958. X            (void) strncpy(pl_character, argv[0]+1,
  1959. X                sizeof(pl_character)-1);
  1960. X
  1961. X            /* Printf("Unknown option: %s\n", *argv); */
  1962. X        }
  1963. X    }
  1964. X
  1965. X    if(argc > 1)
  1966. X        locknum = atoi(argv[1]);
  1967. X#ifdef MAX_NR_OF_PLAYERS
  1968. X    if(!locknum || locknum > MAX_NR_OF_PLAYERS)
  1969. X        locknum = MAX_NR_OF_PLAYERS;
  1970. X#endif
  1971. X#ifdef DEF_PAGER
  1972. X    if(!(catmore = getenv("HACKPAGER")) && !(catmore = getenv("PAGER")))
  1973. X        catmore = DEF_PAGER;
  1974. X#endif
  1975. X#ifdef MAIL
  1976. X    getmailstatus();
  1977. X#endif
  1978. X#ifdef WIZARD
  1979. X    if(wizard) Strcpy(plname, "wizard"); else
  1980. X#endif
  1981. X    if(!*plname || !strncmp(plname, "player", 4)
  1982. X            || !strncmp(plname, "games", 4))
  1983. X        askname();
  1984. X    plnamesuffix();        /* strip suffix from name; calls askname() */
  1985. X                /* again if suffix was whole name */
  1986. X                /* accepts any suffix */
  1987. X#ifdef WIZARD
  1988. X    if(!wizard) {
  1989. X#endif
  1990. X        /*
  1991. X         * check for multiple games under the same name
  1992. X         * (if !locknum) or check max nr of players (otherwise)
  1993. X         */
  1994. X        (void) signal(SIGQUIT,SIG_IGN);
  1995. X        (void) signal(SIGINT,SIG_IGN);
  1996. X        if(!locknum)
  1997. X            Strcpy(lock,plname);
  1998. X        getlock();    /* sets lock if locknum != 0 */
  1999. X#ifdef WIZARD
  2000. X    } else
  2001. X        Strcpy(lock,plname);
  2002. X#endif /* WIZARD /**/
  2003. X    setftty();
  2004. X
  2005. X    /* 
  2006. X     * Initialisation of the boundaries of the mazes
  2007. X     * Both boundaries have to be even.
  2008. X     */
  2009. X     
  2010. X    x_maze_max = COLNO-1;
  2011. X    if (x_maze_max % 2) 
  2012. X        x_maze_max--;
  2013. X    y_maze_max = ROWNO-1;
  2014. X    if (y_maze_max % 2) 
  2015. X        y_maze_max--;
  2016. X
  2017. X    /* initialize static monster strength array */
  2018. X    init_monstr();
  2019. X
  2020. X    Sprintf(SAVEF, "save/%d%s", getuid(), plname);
  2021. X    regularize(SAVEF+5);        /* avoid . or / in name */
  2022. X#ifdef COMPRESS
  2023. X    Strcpy(old,SAVEF);
  2024. X    Strcat(SAVEF,".Z");
  2025. X    if((fd = open(SAVEF,0)) >= 0) {
  2026. X         (void) close(fd);
  2027. X        Strcpy(cmd, COMPRESS);
  2028. X        Strcat(cmd, " -d ");    /* uncompress */
  2029. X# ifdef COMPRESS_OPTIONS
  2030. X        Strcat(cmd, COMPRESS_OPTIONS);
  2031. X        Strcat(cmd, " ");
  2032. X# endif
  2033. X        Strcat(cmd,SAVEF);
  2034. X        (void) system(cmd);
  2035. X    }
  2036. X    Strcpy(SAVEF,old);
  2037. X#endif
  2038. X    if((fd = open(SAVEF,0)) >= 0 &&
  2039. X       (uptodate(fd) || unlink(SAVEF) == 666)) {
  2040. X        (void) signal(SIGINT, (SIG_RET_TYPE) done1);
  2041. X        pline("Restoring old save file...");
  2042. X        (void) fflush(stdout);
  2043. X        if(!dorecover(fd))
  2044. X            goto not_recovered;
  2045. X        pline("Hello %s, welcome to NetHack!", plname);
  2046. X        /* get shopkeeper set properly if restore is in shop */
  2047. X        (void) inshop();
  2048. X#ifdef EXPLORE_MODE
  2049. X        if (discover) {
  2050. X            You("are in non-scoring discovery mode.");
  2051. X            pline("Do you want to keep the save file? ");
  2052. X            if(yn() == 'n')
  2053. X                (void) unlink(SAVEF);
  2054. X        }
  2055. X#endif
  2056. X        flags.move = 0;
  2057. X    } else {
  2058. Xnot_recovered:
  2059. X        newgame();
  2060. X        /* give welcome message before pickup messages */
  2061. X        pline("Hello %s, welcome to NetHack!", plname);
  2062. X#ifdef EXPLORE_MODE
  2063. X        if (discover)
  2064. X            You("are in non-scoring discovery mode.");
  2065. X#endif
  2066. X        flags.move = 0;
  2067. X        set_wear();
  2068. X        pickup(1);
  2069. X        read_engr_at(u.ux,u.uy);
  2070. X    }
  2071. X
  2072. X    flags.moonphase = phase_of_the_moon();
  2073. X    if(flags.moonphase == FULL_MOON) {
  2074. X        You("are lucky!  Full moon tonight.");
  2075. X        if(!u.uluck) change_luck(1);
  2076. X    } else if(flags.moonphase == NEW_MOON) {
  2077. X        pline("Be careful!  New moon tonight.");
  2078. X    }
  2079. X
  2080. X    initrack();
  2081. X
  2082. X    for(;;) {
  2083. X        if(flags.move) {    /* actual time passed */
  2084. X
  2085. X#ifdef SOUNDS
  2086. X            dosounds();
  2087. X#endif
  2088. X            settrack();
  2089. X
  2090. X            if(moves%2 == 0 ||
  2091. X              (!(Fast & ~INTRINSIC) && (!Fast || rn2(3)))) {
  2092. X                movemon();
  2093. X#ifdef HARD
  2094. X                if(!rn2(u.udemigod?25:(dlevel>30)?50:70))
  2095. X#else
  2096. X                if(!rn2(70))
  2097. X#endif
  2098. X                    (void) makemon((struct permonst *)0, 0, 0);
  2099. X            }
  2100. X            if(Glib) glibr();
  2101. X            timeout();
  2102. X            ++moves;
  2103. X#ifdef THEOLOGY
  2104. X            if (u.ublesscnt)  u.ublesscnt--;
  2105. X#endif
  2106. X            if(flags.time) flags.botl = 1;
  2107. X#ifdef POLYSELF
  2108. X            if(u.mtimedone)
  2109. X                if(u.mh < 1) rehumanize();
  2110. X            else
  2111. X#endif
  2112. X                if(u.uhp < 1) {
  2113. X                You("die...");
  2114. X                done("died");
  2115. X                }
  2116. X#ifdef POLYSELF
  2117. X            if (u.mtimedone) {
  2118. X                if (u.mh < u.mhmax) {
  2119. X                if (Regeneration || !(moves%20)) {
  2120. X                    flags.botl = 1;
  2121. X                    u.mh++;
  2122. X                }
  2123. X                }
  2124. X            }
  2125. X#endif
  2126. X            if(u.uhp < u.uhpmax) {
  2127. X                if(u.ulevel > 9) {
  2128. X                    int heal;
  2129. X
  2130. X                    if(HRegeneration || !(moves%3)) {
  2131. X                    flags.botl = 1;
  2132. X                    if (ACURR(A_CON) <= 12) heal = 1;
  2133. X                    else heal = rnd((int) ACURR(A_CON)-12);
  2134. X                    if (heal > u.ulevel-9) heal = u.ulevel-9;
  2135. X                    u.uhp += heal;
  2136. X                    if(u.uhp > u.uhpmax)
  2137. X                        u.uhp = u.uhpmax;
  2138. X                    }
  2139. X                } else if(HRegeneration ||
  2140. X                      (!(moves%((MAXULEV+12)/(u.ulevel+2)+1)))) {
  2141. X                    flags.botl = 1;
  2142. X                    u.uhp++;
  2143. X                }
  2144. X            }
  2145. X#ifdef SPELLS
  2146. X            if ((u.uen<u.uenmax) && (!(moves%(19-ACURR(A_INT)/2)))) {
  2147. X                u.uen += rn2((int)ACURR(A_WIS)/5 + 1) + 1;
  2148. X                if (u.uen > u.uenmax)  u.uen = u.uenmax;
  2149. X                flags.botl = 1;
  2150. X            }
  2151. X#endif
  2152. X            if(Teleportation && !rn2(85)) tele();
  2153. X#ifdef POLYSELF
  2154. X            if(Polymorph && !rn2(100)) polyself();
  2155. X            if(u.ulycn >= 0 && !rn2(80 - (20 * night())))
  2156. X                you_were();
  2157. X#endif
  2158. X            if(Searching && multi >= 0) (void) dosearch0(1);
  2159. X            hatch_eggs();
  2160. X            gethungry();
  2161. X            invault();
  2162. X            amulet();
  2163. X#ifdef HARD
  2164. X            if (!rn2(40+(int)(ACURR(A_DEX)*3))) u_wipe_engr(rnd(3));
  2165. X            if (u.udemigod) {
  2166. X
  2167. X                if(u.udg_cnt) u.udg_cnt--;
  2168. X                if(!u.udg_cnt) {
  2169. X
  2170. X                    intervene();
  2171. X                    u.udg_cnt = rn1(200, 50);
  2172. X                }
  2173. X            }
  2174. X#endif
  2175. X            restore_attrib();
  2176. X        }
  2177. X        if(multi < 0) {
  2178. X            if(!++multi){
  2179. X                pline(nomovemsg ? nomovemsg :
  2180. X                    "You can move again.");
  2181. X                nomovemsg = 0;
  2182. X                if(afternmv) (*afternmv)();
  2183. X                afternmv = 0;
  2184. X            }
  2185. X        }
  2186. X
  2187. X        find_ac();
  2188. X        if(!flags.mv || Blind)
  2189. X        {
  2190. X            seeobjs();
  2191. X            seemons();
  2192. X            seeglds();
  2193. X            nscr();
  2194. X        }
  2195. X        if(flags.botl || flags.botlx) bot();
  2196. X
  2197. X        flags.move = 1;
  2198. X
  2199. X        if(multi >= 0 && occupation) {
  2200. X
  2201. X            if(monster_nearby())
  2202. X                stop_occupation();
  2203. X            else if ((*occupation)() == 0)
  2204. X                occupation = 0;
  2205. X            continue;
  2206. X        }
  2207. X
  2208. X        if((u.uhave_amulet || Clairvoyant) && 
  2209. X#ifdef ENDGAME
  2210. X            dlevel != ENDLEVEL &&
  2211. X#endif
  2212. X            !(moves%15) && !rn2(2)) do_vicinity_map();
  2213. X
  2214. X        u.umoved = FALSE;
  2215. X        if(multi > 0) {
  2216. X            lookaround();
  2217. X            if(!multi) {    /* lookaround may clear multi */
  2218. X                flags.move = 0;
  2219. X                continue;
  2220. X            }
  2221. X            if(flags.mv) {
  2222. X                if(multi < COLNO && !--multi)
  2223. X                    flags.mv = flags.run = 0;
  2224. X                domove();
  2225. X            } else {
  2226. X                --multi;
  2227. X                rhack(save_cm);
  2228. X            }
  2229. X        } else if(multi == 0) {
  2230. X#ifdef MAIL
  2231. X            ckmailstatus();
  2232. X#endif
  2233. X            rhack(NULL);
  2234. X        }
  2235. X        if(multi && multi%7 == 0)
  2236. X            (void) fflush(stdout);
  2237. X    }
  2238. X}
  2239. X
  2240. Xvoid
  2241. Xglo(foo)
  2242. Xregister int foo;
  2243. X{
  2244. X    /* construct the string  xlock.n  */
  2245. X    register char *tf;
  2246. X
  2247. X    tf = lock;
  2248. X    while(*tf && *tf != '.') tf++;
  2249. X    Sprintf(tf, ".%d", foo);
  2250. X}
  2251. X
  2252. X/*
  2253. X * plname is filled either by an option (-u Player  or  -uPlayer) or
  2254. X * explicitly (by being the wizard) or by askname.
  2255. X * It may still contain a suffix denoting pl_character.
  2256. X */
  2257. Xvoid
  2258. Xaskname(){
  2259. Xregister int c,ct;
  2260. X    Printf("\nWho are you? ");
  2261. X    (void) fflush(stdout);
  2262. X    ct = 0;
  2263. X    while((c = Getchar()) != '\n'){
  2264. X        if(c == EOF) error("End of input\n");
  2265. X        /* some people get confused when their erase char is not ^H */
  2266. X        if(c == '\010') {
  2267. X            if(ct) ct--;
  2268. X            continue;
  2269. X        }
  2270. X        if(c != '-')
  2271. X        if(c < 'A' || (c > 'Z' && c < 'a') || c > 'z') c = '_';
  2272. X        if(ct < sizeof(plname)-1) plname[ct++] = c;
  2273. X    }
  2274. X    plname[ct] = 0;
  2275. X    if(ct == 0) askname();
  2276. X}
  2277. X
  2278. X/*VARARGS1*/
  2279. Xvoid
  2280. Ximpossible(s,x1,x2)
  2281. Xregister char *s, *x1, *x2;
  2282. X{
  2283. X    pline(s,x1,x2);
  2284. X    pline("Program in disorder - perhaps you'd better Quit.");
  2285. X}
  2286. X
  2287. X#ifdef CHDIR
  2288. Xstatic void
  2289. Xchdirx(dir, wr)
  2290. Xchar *dir;
  2291. Xboolean wr;
  2292. X{
  2293. X
  2294. X# ifdef SECURE
  2295. X    if(dir                    /* User specified directory? */
  2296. X#  ifdef HACKDIR
  2297. X           && strcmp(dir, HACKDIR)        /* and not the default? */
  2298. X#  endif
  2299. X        ) {
  2300. X        (void) setgid(getgid());
  2301. X        (void) setuid(getuid());        /* Ron Wessels */
  2302. X    }
  2303. X# endif
  2304. X
  2305. X# ifdef HACKDIR
  2306. X    if(dir == NULL)
  2307. X        dir = HACKDIR;
  2308. X# endif
  2309. X
  2310. X    if(dir && chdir(dir) < 0) {
  2311. X        perror(dir);
  2312. X        error("Cannot chdir to %s.", dir);
  2313. X    }
  2314. X
  2315. X    /* warn the player if he cannot write the record file */
  2316. X    /* perhaps we should also test whether . is writable */
  2317. X    /* unfortunately the access systemcall is worthless */
  2318. X    if(wr) {
  2319. X        register int fd;
  2320. X
  2321. X        if(dir == NULL)
  2322. X        dir = ".";
  2323. X        if((fd = open(RECORD, 2)) < 0) {
  2324. X        Printf("Warning: cannot write %s/%s", dir, RECORD);
  2325. X        getret();
  2326. X        } else
  2327. X        (void) close(fd);
  2328. X    }
  2329. X}
  2330. X#endif /* CHDIR /**/
  2331. X
  2332. Xvoid
  2333. Xstop_occupation()
  2334. X{
  2335. X    if(occupation) {
  2336. X        You("stop %s.", occtxt);
  2337. X        occupation = 0;
  2338. X#ifdef REDO
  2339. X        multi = 0;
  2340. X        pushch(0);        
  2341. X#endif
  2342. X    }
  2343. X}
  2344. X
  2345. Xstatic void
  2346. Xwhoami() {
  2347. X    /*
  2348. X     * Who am i? Algorithm: 1. Use name as specified in NETHACKOPTIONS
  2349. X     *            2. Use $USER or $LOGNAME    (if 1. fails)
  2350. X     *            3. Use getlogin()        (if 2. fails)
  2351. X     * The resulting name is overridden by command line options.
  2352. X     * If everything fails, or if the resulting name is some generic
  2353. X     * account like "games", "play", "player", "hack" then eventually
  2354. X     * we'll ask him.
  2355. X     * Note that we trust him here; it is possible to play under
  2356. X     * somebody else's name.
  2357. X     */
  2358. X    register char *s;
  2359. X
  2360. X    if(!*plname && (s = getenv("USER")))
  2361. X        (void) strncpy(plname, s, sizeof(plname)-1);
  2362. X    if(!*plname && (s = getenv("LOGNAME")))
  2363. X        (void) strncpy(plname, s, sizeof(plname)-1);
  2364. X    if(!*plname && (s = getlogin()))
  2365. X        (void) strncpy(plname, s, sizeof(plname)-1);
  2366. X}
  2367. X
  2368. Xstatic void
  2369. Xnewgame() {
  2370. X    fobj = fcobj = invent = 0;
  2371. X    fmon = fallen_down = 0;
  2372. X    ftrap = 0;
  2373. X    fgold = 0;
  2374. X    flags.ident = 1;
  2375. X
  2376. X    init_objects();
  2377. X    u_init();
  2378. X
  2379. X    (void) signal(SIGINT, (SIG_RET_TYPE) done1);
  2380. X
  2381. X    mklev();
  2382. X    u.ux = xupstair;
  2383. X    u.uy = yupstair;
  2384. X    (void) inshop();
  2385. X
  2386. X    setsee();
  2387. X    flags.botlx = 1;
  2388. X
  2389. X    /* Move the monster from under you or else
  2390. X     * makedog() will fail when it calls makemon().
  2391. X     *             - ucsfcgl!kneller
  2392. X     */
  2393. X    if(levl[u.ux][u.uy].mmask) mnexto(m_at(u.ux, u.uy));
  2394. X
  2395. X    (void) makedog();
  2396. X    seemons();
  2397. X#ifdef NEWS
  2398. X    if(flags.nonews || !readnews())
  2399. X        /* after reading news we did docrt() already */
  2400. X#endif
  2401. X        docrt();
  2402. X
  2403. X    return;
  2404. X}
  2405. END_OF_FILE
  2406. if test 12696 -ne `wc -c <'src/unixmain.c'`; then
  2407.     echo shar: \"'src/unixmain.c'\" unpacked with wrong size!
  2408. fi
  2409. # end of 'src/unixmain.c'
  2410. fi
  2411. echo shar: End of archive 27 \(of 38\).
  2412. cp /dev/null ark27isdone
  2413. MISSING=""
  2414. 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 34 35 36 37 38 ; do
  2415.     if test ! -f ark${I}isdone ; then
  2416.     MISSING="${MISSING} ${I}"
  2417.     fi
  2418. done
  2419. if test "${MISSING}" = "" ; then
  2420.     echo You have unpacked all 38 archives.
  2421.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2422. else
  2423.     echo You still need to unpack the following archives:
  2424.     echo "        " ${MISSING}
  2425. fi
  2426. ##  End of shell archive.
  2427. exit 0
  2428.