home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume16 / nethack31 / part43 < prev    next >
Internet Message Format  |  1993-02-01  |  33KB
  1. Path: uunet!news.tek.com!master!saab!billr
  2. From: billr@saab.CNA.TEK.COM (Bill Randle)
  3. Newsgroups: comp.sources.games
  4. Subject: v16i051:  nethack31 - display oriented dungeons & dragons (Ver. 3.1), Part43/108
  5. Message-ID: <4345@master.CNA.TEK.COM>
  6. Date: 30 Jan 93 01:13:24 GMT
  7. Sender: news@master.CNA.TEK.COM
  8. Lines: 940
  9. Approved: billr@saab.CNA.TEK.COM
  10. Xref: uunet comp.sources.games:1600
  11.  
  12. Submitted-by: izchak@linc.cis.upenn.edu (Izchak Miller)
  13. Posting-number: Volume 16, Issue 51
  14. Archive-name: nethack31/Part43
  15. Supersedes: nethack3p9: Volume 10, Issue 46-102
  16. Environment: Amiga, Atari, Mac, MS-DOS, OS2, Unix, VMS, X11
  17.  
  18.  
  19.  
  20. #! /bin/sh
  21. # This is a shell archive.  Remove anything before this line, then unpack
  22. # it by saving it into a file and typing "sh file".  To overwrite existing
  23. # files, type "sh file -c".  You can also feed this as standard input via
  24. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  25. # will see the following message at the end:
  26. #        "End of archive 43 (of 108)."
  27. # Contents:  src/shknam.c sys/amiga/scroll.uu util/lev_cmp.l
  28. #   win/X11/nethack.rc win/X11/nh56icon
  29. # Wrapped by billr@saab on Wed Jan 27 16:09:03 1993
  30. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  31. if test -f 'src/shknam.c' -a "${1}" != "-c" ; then 
  32.   echo shar: Will not clobber existing file \"'src/shknam.c'\"
  33. else
  34. echo shar: Extracting \"'src/shknam.c'\" \(14990 characters\)
  35. sed "s/^X//" >'src/shknam.c' <<'END_OF_FILE'
  36. X/*    SCCS Id: @(#)shknam.c    3.1    92/11/14    */
  37. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  38. X/* NetHack may be freely redistributed.  See license for details. */
  39. X
  40. X/* shknam.c -- initialize a shop */
  41. X
  42. X#include "hack.h"
  43. X#include "eshk.h"
  44. X
  45. X#ifdef OVLB
  46. X
  47. Xstatic void FDECL(mkshobj_at, (const struct shclass *,int,int));
  48. Xstatic void FDECL(findname, (char *,const char **));
  49. Xstatic int  FDECL(shkinit, (const struct shclass *,struct mkroom *));
  50. X
  51. Xstatic const char *shkliquors[] = {
  52. X    /* Ukraine */
  53. X    "Njezjin", "Tsjernigof", "Gomel", "Ossipewsk", "Gorlowka",
  54. X    /* N. Russia */
  55. X    "Konosja", "Weliki Oestjoeg", "Syktywkar", "Sablja",
  56. X    "Narodnaja", "Kyzyl",
  57. X    /* Silezie */
  58. X    "Walbrzych", "Swidnica", "Klodzko", "Raciborz", "Gliwice",
  59. X    "Brzeg", "Krnov", "Hradec Kralove",
  60. X    /* Schweiz */
  61. X    "Leuk", "Brig", "Brienz", "Thun", "Sarnen", "Burglen", "Elm",
  62. X    "Flims", "Vals", "Schuls", "Zum Loch",
  63. X    ""
  64. X};
  65. X
  66. Xstatic const char *shkbooks[] = {
  67. X    /* Eire */
  68. X    "Skibbereen", "Kanturk", "Rath Luirc", "Ennistymon", "Lahinch",
  69. X    "Kinnegad", "Lugnaquillia", "Enniscorthy", "Gweebarra",
  70. X    "Kittamagh", "Nenagh", "Sneem", "Ballingeary", "Kilgarvan",
  71. X    "Cahersiveen", "Glenbeigh", "Kilmihil", "Kiltamagh",
  72. X    "Droichead Atha", "Inniscrone", "Clonegal", "Lisnaskea",
  73. X    "Culdaff", "Dunfanaghy", "Inishbofin", "Kesh",
  74. X    ""
  75. X};
  76. X
  77. Xstatic const char *shkarmors[] = {
  78. X    /* Turquie */
  79. X    "Demirci", "Kalecik", "Boyabai", "Yildizeli", "Gaziantep",
  80. X    "Siirt", "Akhalataki", "Tirebolu", "Aksaray", "Ermenak",
  81. X    "Iskenderun", "Kadirli", "Siverek", "Pervari", "Malasgirt",
  82. X    "Bayburt", "Ayancik", "Zonguldak", "Balya", "Tefenni",
  83. X    "Artvin", "Kars", "Makharadze", "Malazgirt", "Midyat",
  84. X    "Birecik", "Kirikkale", "Alaca", "Polatli", "Nallihan",
  85. X    ""
  86. X};
  87. X
  88. Xstatic const char *shkwands[] = {
  89. X    /* Wales */
  90. X    "Yr Wyddgrug", "Trallwng", "Mallwyd", "Pontarfynach",
  91. X    "Rhaeader", "Llandrindod", "Llanfair-ym-muallt",
  92. X    "Y-Fenni", "Measteg", "Rhydaman", "Beddgelert",
  93. X    "Curig", "Llanrwst", "Llanerchymedd", "Caergybi",
  94. X    /* Scotland */
  95. X    "Nairn", "Turriff", "Inverurie", "Braemar", "Lochnagar",
  96. X    "Kerloch", "Beinn a Ghlo", "Drumnadrochit", "Morven",
  97. X    "Uist", "Storr", "Sgurr na Ciche", "Cannich", "Gairloch",
  98. X    "Kyleakin", "Dunvegan",
  99. X    ""
  100. X};
  101. X
  102. Xstatic const char *shkrings[] = {
  103. X    /* Hollandse familienamen */
  104. X    "Feyfer", "Flugi", "Gheel", "Havic", "Haynin", "Hoboken",
  105. X    "Imbyze", "Juyn", "Kinsky", "Massis", "Matray", "Moy",
  106. X    "Olycan", "Sadelin", "Svaving", "Tapper", "Terwen", "Wirix",
  107. X    "Ypey",
  108. X    /* Skandinaviske navne */
  109. X    "Rastegaisa", "Varjag Njarga", "Kautekeino", "Abisko",
  110. X    "Enontekis", "Rovaniemi", "Avasaksa", "Haparanda",
  111. X    "Lulea", "Gellivare", "Oeloe", "Kajaani", "Fauske",
  112. X    ""
  113. X};
  114. X
  115. Xstatic const char *shkfoods[] = {
  116. X    /* Indonesia */
  117. X    "Djasinga", "Tjibarusa", "Tjiwidej", "Pengalengan",
  118. X    "Bandjar", "Parbalingga", "Bojolali", "Sarangan",
  119. X    "Ngebel", "Djombang", "Ardjawinangun", "Berbek",
  120. X    "Papar", "Baliga", "Tjisolok", "Siboga", "Banjoewangi",
  121. X    "Trenggalek", "Karangkobar", "Njalindoeng", "Pasawahan",
  122. X    "Pameunpeuk", "Patjitan", "Kediri", "Pemboeang", "Tringanoe",
  123. X    "Makin", "Tipor", "Semai", "Berhala", "Tegal", "Samoe",
  124. X    ""
  125. X};
  126. X
  127. Xstatic const char *shkweapons[] = {
  128. X    /* Perigord */
  129. X    "Voulgezac", "Rouffiac", "Lerignac", "Touverac", "Guizengeard",
  130. X    "Melac", "Neuvicq", "Vanzac", "Picq", "Urignac", "Corignac",
  131. X    "Fleac", "Lonzac", "Vergt", "Queyssac", "Liorac", "Echourgnac",
  132. X    "Cazelon", "Eypau", "Carignan", "Monbazillac", "Jonzac",
  133. X    "Pons", "Jumilhac", "Fenouilledes", "Laguiolet", "Saujon",
  134. X    "Eymoutiers", "Eygurande", "Eauze", "Labouheyre",
  135. X    ""
  136. X};
  137. X
  138. Xstatic const char *shktools[] = {
  139. X    /* Spmi */
  140. X    "Ymla", "Eed-morra", "Cubask", "Nieb", "Bnowr Falr", "Telloc Cyaj",
  141. X    "Sperc", "Noskcirdneh", "Yawolloh", "Hyeghu", "Niskal", "Trahnil",
  142. X    "Htargcm", "Enrobwem", "Kachzi Rellim", "Regien", "Donmyar",
  143. X    "Yelpur", "Nosnehpets", "Stewe", "Renrut", "_Zlaw", "Nosalnef",
  144. X    "Rewuorb", "Rellenk", "Yad", "Cire Htims", "Y-crad", "Nenilukah",
  145. X#ifdef OVERLAY
  146. X    "Erreip", "Nehpets", "Mron", "Snivek",
  147. X#endif
  148. X#ifdef MAC
  149. X    "Nhoj-lee", "Evad\'kh", "Ettaw-noj", "Tsew-mot", "Ydna-s",
  150. X#endif
  151. X#ifdef AMIGA
  152. X    "Falo", "Nosid-da\'r", "Ekim-p", "Rebrol-nek", "Noslo", "Yl-rednow",
  153. X    "Mured-oog",
  154. X#endif
  155. X#ifdef VMS
  156. X    "Lez-tneg", "Ytnu-haled", "Niknar",
  157. X#endif
  158. X    ""
  159. X};
  160. X
  161. Xstatic const char *shkgeneral[] = {
  162. X    /* Suriname */
  163. X    "Hebiwerie", "Possogroenoe", "Asidonhopo", "Manlobbi",
  164. X    "Adjama", "Pakka Pakka", "Kabalebo", "Wonotobo",
  165. X    "Akalapi", "Sipaliwini",
  166. X    /* Greenland */
  167. X    "Annootok", "Upernavik", "Angmagssalik",
  168. X    /* N. Canada */
  169. X    "Aklavik", "Inuvik", "Tuktoyaktuk",
  170. X    "Chicoutimi", "Ouiatchouane", "Chibougamau",
  171. X    "Matagami", "Kipawa", "Kinojevis",
  172. X    "Abitibi", "Maganasipi",
  173. X    /* Iceland */
  174. X    "Akureyri", "Kopasker", "Budereyri", "Akranes", "Bordeyri",
  175. X    "Holmavik",
  176. X    ""
  177. X};
  178. X
  179. X/*
  180. X * To add new shop types, all that is necessary is to edit the shtypes[] array.
  181. X * See mkroom.h for the structure definition.  Typically, you'll have to lower
  182. X * some or all of the probability fields in old entries to free up some
  183. X * percentage for the new type.
  184. X *
  185. X * The placement type field is not yet used but will be in the near future.
  186. X *
  187. X * The iprobs array in each entry defines the probabilities for various kinds
  188. X * of objects to be present in the given shop type.  You can associate with
  189. X * each percentage either a generic object type (represented by one of the
  190. X * *_CLASS macros) or a specific object (represented by an onames.h define).
  191. X * In the latter case, prepend it with a unary minus so the code can know
  192. X * (by testing the sign) whether to use mkobj() or mksobj().
  193. X */
  194. X
  195. Xconst struct shclass shtypes[] = {
  196. X    {"general store", RANDOM_CLASS, 44,
  197. X        D_SHOP, {{100, RANDOM_CLASS}, {0, 0}, {0, 0}}, shkgeneral},
  198. X    {"used armor dealership", ARMOR_CLASS, 14,
  199. X        D_SHOP, {{90, ARMOR_CLASS}, {10, WEAPON_CLASS}, {0, 0}},
  200. X         shkarmors},
  201. X    {"second hand bookstore", SCROLL_CLASS, 10, D_SHOP,
  202. X        {{90, SCROLL_CLASS}, {10, SPBOOK_CLASS}, {0, 0}}, shkbooks},
  203. X    {"liquor emporium", POTION_CLASS, 10, D_SHOP,
  204. X        {{100, POTION_CLASS}, {0, 0}, {0, 0}}, shkliquors},
  205. X    {"antique weapons outlet", WEAPON_CLASS, 5, D_SHOP,
  206. X        {{90, WEAPON_CLASS}, {10, ARMOR_CLASS}, {0, 0}}, shkweapons},
  207. X    {"delicatessen", FOOD_CLASS, 5, D_SHOP,
  208. X        {{95, FOOD_CLASS}, {5, POTION_CLASS}, {0, 0}}, shkfoods},
  209. X    {"jewelers", RING_CLASS, 3, D_SHOP,
  210. X        {{85, RING_CLASS}, {10, GEM_CLASS}, {5, AMULET_CLASS}, {0, 0}},
  211. X        shkrings},
  212. X    {"quality apparel and accessories", WAND_CLASS, 3, D_SHOP,
  213. X        {{90, WAND_CLASS}, {5, -LEATHER_GLOVES}, {5, -ELVEN_CLOAK}, {0, 0}},
  214. X         shkwands},
  215. X    {"hardware store", TOOL_CLASS, 3, D_SHOP,
  216. X        {{100, TOOL_CLASS}, {0, 0}, {0, 0}}, shktools},
  217. X    /* Actually shktools is ignored; the code specifically chooses a
  218. X     * random implementor name (along with candle shops having
  219. X     * random shopkeepers)
  220. X     */
  221. X    {"rare books", SPBOOK_CLASS, 3, D_SHOP,
  222. X        {{90, SPBOOK_CLASS}, {10, SCROLL_CLASS}, {0, 0}}, shkbooks},
  223. X    /* Shops below this point are "unique".  That is they must all have a
  224. X     * probability of zero.  They are only created via the special level
  225. X     * loader.
  226. X     */
  227. X    {"lighting store", TOOL_CLASS, 0, D_SHOP,
  228. X        {{32, -WAX_CANDLE}, {50, -TALLOW_CANDLE},
  229. X         {5, -BRASS_LANTERN}, {10, -OIL_LAMP}, {3, -MAGIC_LAMP}},shktools},
  230. X    {NULL, 0, 0, 0, {{0, 0}, {0, 0}, {0, 0}}, 0}
  231. X};
  232. X
  233. X#else    /* OVLB */
  234. X
  235. Xextern const struct shclass shtypes[];
  236. X
  237. X#endif    /* OVLB */
  238. X
  239. X#ifdef OVLB
  240. X
  241. X#if 0
  242. X/* validate shop probabilities; otherwise incorrect local changes could
  243. X   end up provoking infinite loops or wild subscripts fetching garbage */
  244. Xvoid
  245. Xinit_shop_selection()
  246. X{
  247. X    register int i, j, item_prob, shop_prob;
  248. X
  249. X    for (shop_prob = 0, i = 0; i < SIZE(shtypes); i++) {
  250. X        shop_prob += shtypes[i].prob;
  251. X        for (item_prob = 0, j = 0; j < SIZE(shtypes[0].iprobs); j++)
  252. X            item_prob += shtypes[i].iprobs[j].iprob;
  253. X        if (item_prob != 100)
  254. X            panic("item probabilities total to %d for %s shops!",
  255. X                item_prob, shtypes[i].name);
  256. X    }
  257. X    if (shop_prob != 100)
  258. X        panic("shop probabilities total to %d!", shop_prob);
  259. X}
  260. X#endif /*0*/
  261. X
  262. Xstatic void
  263. Xmkshobj_at(shp, sx, sy)
  264. X/* make an object of the appropriate type for a shop square */
  265. Xconst struct shclass *shp;
  266. Xint sx, sy;
  267. X{
  268. X    register struct monst *mtmp;
  269. X    int atype;
  270. X    struct permonst *ptr;
  271. X
  272. X    if (rn2(100) < depth(&u.uz) &&
  273. X        !MON_AT(sx, sy) && (ptr = mkclass(S_MIMIC,0)) &&
  274. X        (mtmp=makemon(ptr,sx,sy))) {
  275. X        /* note: makemon will set the mimic symbol to a shop item */
  276. X        if (rn2(10) >= depth(&u.uz)) {
  277. X            mtmp->m_ap_type = M_AP_OBJECT;
  278. X            mtmp->mappearance = STRANGE_OBJECT;
  279. X        }
  280. X    } else if ((atype = get_shop_item(shp - shtypes)) < 0)
  281. X        (void) mksobj_at(-atype, sx, sy, TRUE);
  282. X    else (void) mkobj_at(atype, sx, sy, TRUE);
  283. X}
  284. X
  285. Xstatic void
  286. Xfindname(nampt, nlp)
  287. X/* extract a shopkeeper name for the given shop type */
  288. X    char *nampt;
  289. X    const char *nlp[];
  290. X{
  291. X    register int i;
  292. X
  293. X    for(i = 0; i < ledger_no(&u.uz); i++) /* Note: _not_ depth */
  294. X    if (!*nlp[i]) {
  295. X        /* Not enough names, try random/general name */
  296. X        if((i = rn2(i)))
  297. X        break;
  298. X        else if (nlp != shkgeneral)
  299. X        findname(nampt, shkgeneral);
  300. X        else
  301. X        Strcpy(nampt, "Dirk");
  302. X        return;
  303. X    }
  304. X    (void) strncpy(nampt, nlp[i-1], PL_NSIZ);
  305. X    nampt[PL_NSIZ-1] = 0;
  306. X}
  307. X
  308. Xstatic int
  309. Xshkinit(shp, sroom)    /* create a new shopkeeper in the given room */
  310. Xconst struct shclass    *shp;
  311. Xstruct mkroom    *sroom;
  312. X{
  313. X    register int sh, sx, sy;
  314. X    struct monst *shk;
  315. X
  316. X    /* place the shopkeeper in the given room */
  317. X    sh = sroom->fdoor;
  318. X    sx = doors[sh].x;
  319. X    sy = doors[sh].y;
  320. X
  321. X    /* check that the shopkeeper placement is sane */
  322. X    if(sroom->irregular) {
  323. X        int rmno = (sroom - rooms) + ROOMOFFSET;
  324. X        if(isok(sx-1,sy) &&
  325. X           levl[sx-1][sy].roomno == rmno && !levl[sx-1][sy].edge) sx--;
  326. X        else if(isok(sx+1,sy) &&
  327. X           levl[sx+1][sy].roomno == rmno && !levl[sx+1][sy].edge) sx++;
  328. X        else if(isok(sx,sy-1) &&
  329. X           levl[sx][sy-1].roomno == rmno && !levl[sx][sy-1].edge) sy--;
  330. X        else if(isok(sx,sy+1) &&
  331. X           levl[sx][sy+1].roomno == rmno && !levl[sx][sy+1].edge) sx++;
  332. X        else goto shk_failed;
  333. X    }
  334. X    else if(sx == sroom->lx-1) sx++;
  335. X    else if(sx == sroom->hx+1) sx--;
  336. X    else if(sy == sroom->ly-1) sy++;
  337. X    else if(sy == sroom->hy+1) sy--; else {
  338. X    shk_failed:
  339. X#ifdef DEBUG
  340. X# ifdef WIZARD
  341. X        /* Said to happen sometimes, but I have never seen it. */
  342. X        /* Supposedly fixed by fdoor change in mklev.c */
  343. X        if(wizard) {
  344. X        register int j = sroom->doorct;
  345. X
  346. X        pline("Where is shopdoor?");
  347. X        pline("Room at (%d,%d),(%d,%d).",
  348. X              sroom->lx, sroom->ly, sroom->hx, sroom->hy);
  349. X        pline("doormax=%d doorct=%d fdoor=%d",
  350. X              doorindex, sroom->doorct, sh);
  351. X        while(j--) {
  352. X            pline("door [%d,%d]", doors[sh].x, doors[sh].y);
  353. X            sh++;
  354. X        }
  355. X        display_nhwindow(WIN_MESSAGE, FALSE);
  356. X        }
  357. X# endif
  358. X#endif
  359. X        return(-1);
  360. X    }
  361. X
  362. X    if(MON_AT(sx, sy)) rloc(m_at(sx, sy)); /* insurance */
  363. X
  364. X    /* now initialize the shopkeeper monster structure */
  365. X    if(!(shk = makemon(&mons[PM_SHOPKEEPER], sx, sy))) return(-1);
  366. X    shk->isshk = shk->mpeaceful = 1;
  367. X    set_malign(shk);
  368. X    shk->msleep = 0;
  369. X    shk->mtrapseen = ~0;    /* we know all the traps already */
  370. X    ESHK(shk)->shoproom = (sroom - rooms) + ROOMOFFSET;
  371. X    sroom->resident = shk;
  372. X    ESHK(shk)->shoptype = sroom->rtype;
  373. X    assign_level(&(ESHK(shk)->shoplevel), &u.uz);
  374. X    ESHK(shk)->shd = doors[sh];
  375. X    ESHK(shk)->shk.x = sx;
  376. X    ESHK(shk)->shk.y = sy;
  377. X    ESHK(shk)->robbed = 0L;
  378. X    ESHK(shk)->credit = 0L;
  379. X    ESHK(shk)->debit = 0L;
  380. X    ESHK(shk)->loan = 0L;
  381. X    ESHK(shk)->visitct = 0;
  382. X    ESHK(shk)->following = 0;
  383. X    ESHK(shk)->billct = 0;
  384. X    shk->mgold = 1000L + 30L*(long)rnd(100);    /* initial capital */
  385. X    if (shp->shknms == shktools) {
  386. X        int who = rn2(SIZE(shktools) - 1);
  387. X        const char *shname = shp->shknms[who];
  388. X        if (shk->female = (*shname == '_')) shname++;
  389. X        (void) strncpy(ESHK(shk)->shknam, shname, PL_NSIZ);
  390. X        ESHK(shk)->shknam[PL_NSIZ-1] = 0;
  391. X    } else {
  392. X        shk->female = ledger_no(&u.uz)%2;
  393. X        findname(ESHK(shk)->shknam, shp->shknms);
  394. X    }
  395. X
  396. X    return(sh);
  397. X}
  398. X
  399. X/* stock a newly-created room with objects */
  400. Xvoid
  401. Xstock_room(shp_indx, sroom)
  402. Xint shp_indx;
  403. Xregister struct mkroom *sroom;
  404. X{
  405. X    /*
  406. X     * Someday soon we'll dispatch on the shdist field of shclass to do
  407. X     * different placements in this routine. Currently it only supports
  408. X     * shop-style placement (all squares except a row nearest the first
  409. X     * door get objects).
  410. X     */
  411. X    register int sx, sy, sh;
  412. X    char buf[BUFSZ];
  413. X    int rmno = (sroom - rooms) + ROOMOFFSET;
  414. X    const struct shclass *shp = &shtypes[shp_indx];
  415. X
  416. X    /* first, try to place a shopkeeper in the room */
  417. X    if ((sh = shkinit(shp, sroom)) < 0)
  418. X    return;
  419. X
  420. X    /* make sure no doorways without doors, and no */
  421. X    /* trapped doors, in shops.               */
  422. X    sx = doors[sroom->fdoor].x;
  423. X    sy = doors[sroom->fdoor].y;
  424. X
  425. X    if(levl[sx][sy].doormask == D_NODOOR) {
  426. X        levl[sx][sy].doormask = D_ISOPEN;
  427. X        newsym(sx,sy);
  428. X    }
  429. X    if(levl[sx][sy].typ == SDOOR) {
  430. X        levl[sx][sy].typ = DOOR;
  431. X        newsym(sx,sy);
  432. X    }
  433. X    if(levl[sx][sy].doormask & D_TRAPPED)
  434. X        levl[sx][sy].doormask = D_LOCKED;
  435. X
  436. X    if(levl[sx][sy].doormask == D_LOCKED) {
  437. X        register int m = sx, n = sy;
  438. X
  439. X        if(inside_shop(sx+1,sy)) m--;
  440. X        else if(inside_shop(sx-1,sy)) m++;
  441. X        if(inside_shop(sx,sy+1)) n--;
  442. X        else if(inside_shop(sx,sy-1)) n++;
  443. X        Sprintf(buf, "Closed for inventory");
  444. X        make_engr_at(m, n, buf, 0L, DUST);
  445. X    }
  446. X
  447. X    for(sx = sroom->lx; sx <= sroom->hx; sx++)
  448. X    for(sy = sroom->ly; sy <= sroom->hy; sy++) {
  449. X        if(sroom->irregular) {
  450. X        if(levl[sx][sy].edge || levl[sx][sy].roomno != rmno ||
  451. X           distmin(sx, sy, doors[sh].x, doors[sh].y) <= 1)
  452. X            continue;
  453. X        } else if((sx == sroom->lx && doors[sh].x == sx-1) ||
  454. X              (sx == sroom->hx && doors[sh].x == sx+1) ||
  455. X              (sy == sroom->ly && doors[sh].y == sy-1) ||
  456. X              (sy == sroom->hy && doors[sh].y == sy+1)) continue;
  457. X        mkshobj_at(shp, sx, sy);
  458. X    }
  459. X
  460. X    /*
  461. X     * Special monster placements (if any) should go here: that way,
  462. X     * monsters will sit on top of objects and not the other way around.
  463. X     */
  464. X
  465. X    level.flags.has_shop = 1;
  466. X}
  467. X
  468. X#endif /* OVLB */
  469. X#ifdef OVL0
  470. X
  471. X/* does "shop" stock this item type? */
  472. Xboolean
  473. Xsaleable(shp_indx, obj)
  474. Xregister int shp_indx;
  475. Xregister struct    obj *obj;
  476. X{
  477. X    register int i;
  478. X    register const struct shclass *shp = &shtypes[shp_indx];
  479. X
  480. X    if (shp->symb == RANDOM_CLASS) return TRUE;
  481. X    else for (i = 0; i < SIZE(shtypes[0].iprobs) && shp->iprobs[i].iprob; i++)
  482. X        if (shp->iprobs[i].itype < 0 ?
  483. X            shp->iprobs[i].itype == - obj->otyp :
  484. X            shp->iprobs[i].itype == obj->oclass) return TRUE;
  485. X    /* not found */
  486. X    return FALSE;
  487. X}
  488. X
  489. X/* positive value: class; negative value: specific object type */
  490. Xint
  491. Xget_shop_item(type)
  492. Xint type;
  493. X{
  494. X    const struct shclass *shp = shtypes+type;
  495. X    register int i,j;
  496. X
  497. X    /* select an appropriate object type at random */
  498. X    for(j = rnd(100), i = 0; (j -= shp->iprobs[i].iprob) > 0; i++)
  499. X        continue;
  500. X
  501. X    return shp->iprobs[i].itype;
  502. X}
  503. X
  504. X#endif /* OVL0 */
  505. X
  506. X/*shknam.c*/
  507. END_OF_FILE
  508. if test 14990 -ne `wc -c <'src/shknam.c'`; then
  509.     echo shar: \"'src/shknam.c'\" unpacked with wrong size!
  510. fi
  511. # end of 'src/shknam.c'
  512. fi
  513. if test -f 'sys/amiga/scroll.uu' -a "${1}" != "-c" ; then 
  514.   echo shar: Will not clobber existing file \"'sys/amiga/scroll.uu'\"
  515. else
  516. echo shar: Extracting \"'sys/amiga/scroll.uu'\" \(536 characters\)
  517. sed "s/^X//" >'sys/amiga/scroll.uu' <<'END_OF_FILE'
  518. Xbegin 777 scroll.pw
  519. XM4&]W97)7:6YD;W=S('8R+C5C(*DQ.3@W+"`Q.3@X(&)Y($E.3U9!5%)/3DE#
  520. XM4RP@24Y#+B`@("`@("`@("`@("`@("`@("`@("`@```"K`````E``8#_````
  521. XM`0`````!``````=B87)F+F,```````````$``A`+```"6@`%``7_____````
  522. XM``````````````````````````````$`(86````````!```!`,\`$0$``'T`
  523. XM!0`%_____P````$``````/_Q``H`#__M`%```P`#`"&'T```````````````
  524. XM```AB"```P`AB.C_____`P``!0`NKQ0````````````0````$`!K````:P``
  525. XM``````````<`9@`````````````````````!!?__________````"@!0``D`
  526. XM(8E``"*KR``BL:@`(^]0`"/P0``C\L`````!``````$``````0`````!````
  527. X(``$``````0`B
  528. X`
  529. Xend
  530. END_OF_FILE
  531. if test 536 -ne `wc -c <'sys/amiga/scroll.uu'`; then
  532.     echo shar: \"'sys/amiga/scroll.uu'\" unpacked with wrong size!
  533. fi
  534. # end of 'sys/amiga/scroll.uu'
  535. fi
  536. if test -f 'util/lev_comp.l' -a "${1}" != "-c" ; then 
  537.   echo shar: Will not clobber existing file \"'util/lev_comp.l'\"
  538. else
  539. echo shar: Extracting \"'util/lev_comp.l'\" \(7556 characters\)
  540. sed "s/^X//" >'util/lev_comp.l' <<'END_OF_FILE'
  541. X%{
  542. X/*    SCCS Id: @(#)lev_lex.c    3.1    92/07/12    */
  543. X/*    Copyright (c) 1989 by Jean-Christophe Collet */
  544. X/* NetHack may be freely redistributed.  See license for details. */
  545. X
  546. X#define LEV_LEX_C
  547. X
  548. X#include "hack.h"
  549. X#include "lev_comp.h"
  550. X#include "sp_lev.h"
  551. X
  552. X/* Most of these don't exist in flex, yywrap is macro and
  553. X * yyunput is properly declared in flex.skel.
  554. X */
  555. X#ifndef FLEX_SCANNER
  556. Xint FDECL (yyback, (int *, int));
  557. Xint NDECL (yylook);
  558. Xint NDECL (yyinput);
  559. Xint NDECL (yywrap);
  560. Xint NDECL (yylex);
  561. X    /* Traditional lexes let yyunput() and yyoutput() default to int;
  562. X     * newer ones may declare them as void since they don't return
  563. X     * values.  For even more fun, the lex supplied as part of the
  564. X     * newer unbundled compiler for SunOS 4.x adds the void declarations
  565. X     * (under __STDC__ or _cplusplus ifdefs -- otherwise they remain
  566. X     * int) while the bundled lex and the one with the older unbundled
  567. X     * compiler do not.  To detect this, we need help from outside --
  568. X     * sys/unix/Makefile.utl.
  569. X     */
  570. X# if defined(NeXT) || defined(SVR4)
  571. X#  define VOIDYYPUT
  572. X# endif
  573. X# if !defined(VOIDYYPUT)
  574. X#  if defined(POSIX_TYPES) && !defined(BOS) && !defined(HISX)
  575. X#   define VOIDYYPUT
  576. X#  endif
  577. X# endif
  578. X# if !defined(VOIDYYPUT) && defined(WEIRD_LEX)
  579. X#  if defined(SUNOS4) && defined(__STDC__) && (WEIRD_LEX != 0) 
  580. X#   define VOIDYYPUT
  581. X#  endif
  582. X# endif
  583. X# ifdef VOIDYYPUT
  584. Xvoid FDECL (yyunput, (int));
  585. Xvoid FDECL (yyoutput, (int));
  586. X# else
  587. Xint FDECL (yyunput, (int));
  588. Xint FDECL (yyoutput, (int));
  589. X# endif
  590. X#endif    /* FLEX_SCANNER */
  591. X
  592. Xvoid FDECL (init_yyin, (FILE *));
  593. Xvoid FDECL (init_yyout, (FILE *));
  594. X
  595. X#ifdef MICRO
  596. X#undef exit
  597. Xextern void FDECL(exit, (int));
  598. X#endif
  599. X
  600. X/* this doesn't always get put in lev_comp.h
  601. X * (esp. when using older versions of bison)
  602. X */
  603. X
  604. Xextern YYSTYPE yylval;
  605. X
  606. Xint line_number = 1, colon_line_number = 1;
  607. X
  608. X/* This is *** UGLY *** but I can't think a better way to do it
  609. X * I really need a huge buffer to scan maps...
  610. X */
  611. X
  612. X#undef YYLMAX
  613. X#define YYLMAX    2048
  614. X
  615. X/*
  616. X *    This is a hack required by Michael Hamel to get things
  617. X *    working on the Mac.
  618. X */
  619. X#if defined(applec) && !defined(FLEX_SCANNER)
  620. X#undef input
  621. X#undef unput
  622. X#define unput(c) { yytchar = (c); if (yytchar == 10) yylineno--; *yysptr++ = yytchar; }
  623. X# ifndef YYNEWLINE
  624. X# define YYNEWLINE 10
  625. X# endif
  626. X
  627. Xchar
  628. Xinput() {    /* Under MPW \n is chr(13)! Compensate for this. */
  629. X
  630. X    if (yysptr > yysbuf) return(*--yysptr);
  631. X    else {
  632. X        yytchar = getc(yyin);
  633. X        if (yytchar == '\n') {
  634. X            yylineno++;
  635. X            return(YYNEWLINE);
  636. X        }
  637. X        if (yytchar == EOF) return(0);
  638. X        else            return(yytchar);
  639. X    }
  640. X}
  641. X#endif    /* applec && !FLEX_SCANNER */
  642. X
  643. X%}
  644. X%e 1500
  645. X%p 5000
  646. X%n 600
  647. X%s MAPC
  648. X%%
  649. X<MAPC>ENDMAP    {
  650. X#ifdef FLEX_SCANNER
  651. X          /*
  652. X           * There is a bug in Flex 2.3 patch level < 6
  653. X           * (absent in previous versions)
  654. X           * that results in the following behaviour :
  655. X           * Once you enter an yymore(), you never exit from it.
  656. X           * This should do the trick!
  657. X           */
  658. X          extern int yy_more_len;
  659. X
  660. X          yy_more_len = 0;
  661. X#endif
  662. X          BEGIN(INITIAL);
  663. X          yylval.map = (char *) alloc(yyleng-5);
  664. X          strncpy(yylval.map, yytext,yyleng-6);
  665. X          yylval.map[yyleng-6] = 0;
  666. X          return MAP_ID;
  667. X        }
  668. X<MAPC>[-|}{+ABCISKPLW\\#. ]*\n    { line_number++; yymore(); }
  669. X^#.*\n        { line_number++; }
  670. X:        { colon_line_number = line_number; return ':'; }
  671. XMESSAGE        return MESSAGE_ID;
  672. XMAZE        return MAZE_ID;
  673. XNOMAP        return NOMAP_ID;
  674. XLEVEL        return LEVEL_ID;
  675. XINIT_MAP    return LEV_INIT_ID;
  676. XFLAGS        return FLAGS_ID;
  677. XGEOMETRY    return GEOMETRY_ID;
  678. X^MAP\n        { BEGIN(MAPC); line_number++; }
  679. XOBJECT        return OBJECT_ID;
  680. XMONSTER        return MONSTER_ID;
  681. XTRAP        return TRAP_ID;
  682. XDOOR        return DOOR_ID;
  683. XDRAWBRIDGE    return DRAWBRIDGE_ID;
  684. XMAZEWALK    return MAZEWALK_ID;
  685. XWALLIFY        return WALLIFY_ID;
  686. XREGION        return REGION_ID;
  687. XRANDOM_OBJECTS    return RANDOM_OBJECTS_ID;
  688. XRANDOM_MONSTERS    return RANDOM_MONSTERS_ID;
  689. XRANDOM_PLACES    return RANDOM_PLACES_ID;
  690. XALTAR        return ALTAR_ID;
  691. XLADDER        return LADDER_ID;
  692. XSTAIR        return STAIR_ID;
  693. XPORTAL        return PORTAL_ID;
  694. XTELEPORT_REGION    return TELEPRT_ID;
  695. XBRANCH        return BRANCH_ID;
  696. XFOUNTAIN    return FOUNTAIN_ID;
  697. XSINK        return SINK_ID;
  698. XPOOL        return POOL_ID;
  699. XNON_DIGGABLE    return NON_DIGGABLE_ID;
  700. XROOM        return ROOM_ID;
  701. XSUBROOM        return SUBROOM_ID;
  702. XRANDOM_CORRIDORS    return RAND_CORRIDOR_ID;
  703. XCORRIDOR    return CORRIDOR_ID;
  704. XGOLD        return GOLD_ID;
  705. XENGRAVING    return ENGRAVING_ID;
  706. XNAME        return NAME_ID;
  707. XCHANCE        return CHANCE_ID;
  708. Xlevregion    return LEV;
  709. Xopen        { yylval.i=D_ISOPEN; return DOOR_STATE; }
  710. Xclosed        { yylval.i=D_CLOSED; return DOOR_STATE; }
  711. Xlocked        { yylval.i=D_LOCKED; return DOOR_STATE; }
  712. Xnodoor        { yylval.i=D_NODOOR; return DOOR_STATE; }
  713. Xbroken        { yylval.i=D_BROKEN; return DOOR_STATE; }
  714. Xnorth        { yylval.i=W_NORTH; return DIRECTION; }
  715. Xeast        { yylval.i=W_EAST; return DIRECTION; }
  716. Xsouth        { yylval.i=W_SOUTH; return DIRECTION; }
  717. Xwest        { yylval.i=W_WEST; return DIRECTION; }
  718. Xrandom        { yylval.i = -1; return RANDOM_TYPE; }
  719. Xnone        { yylval.i = -2; return NONE; }
  720. Xobject        return O_REGISTER;
  721. Xmonster        return M_REGISTER;
  722. Xplace        return P_REGISTER;
  723. Xalign        return A_REGISTER;
  724. Xleft        { yylval.i=1; return LEFT_OR_RIGHT; }
  725. Xhalf-left    { yylval.i=2; return LEFT_OR_RIGHT; }
  726. Xcenter        { yylval.i=3; return CENTER; }
  727. Xhalf-right    { yylval.i=4; return LEFT_OR_RIGHT; }
  728. Xright        { yylval.i=5; return LEFT_OR_RIGHT; }
  729. Xtop        { yylval.i=1; return TOP_OR_BOT; }
  730. Xbottom        { yylval.i=5; return TOP_OR_BOT; }
  731. Xlit        { yylval.i=1; return LIGHT_STATE; }
  732. Xunlit        { yylval.i=0; return LIGHT_STATE; }
  733. Xfilled        { yylval.i=0; return FILLING; }
  734. Xunfilled    { yylval.i=1; return FILLING; }
  735. Xnoalign        { yylval.i= AM_NONE; return ALIGNMENT; }
  736. Xlaw        { yylval.i= AM_LAWFUL; return ALIGNMENT; }
  737. Xneutral        { yylval.i= AM_NEUTRAL; return ALIGNMENT; }
  738. Xchaos        { yylval.i= AM_CHAOTIC; return ALIGNMENT; }
  739. Xpeaceful    { yylval.i=1; return MON_ATTITUDE; }
  740. Xhostile        { yylval.i=0; return MON_ATTITUDE; }
  741. Xasleep        { yylval.i=1; return MON_ALERTNESS; }
  742. Xawake        { yylval.i=0; return MON_ALERTNESS; }
  743. Xm_feature    { yylval.i= M_AP_FURNITURE; return MON_APPEARANCE; }
  744. Xm_monster    { yylval.i= M_AP_MONSTER;   return MON_APPEARANCE; }
  745. Xm_object    { yylval.i= M_AP_OBJECT;    return MON_APPEARANCE; }
  746. Xsanctum        { yylval.i=2; return ALTAR_TYPE; }
  747. Xshrine        { yylval.i=1; return ALTAR_TYPE; }
  748. Xaltar        { yylval.i=0; return ALTAR_TYPE; }
  749. Xup        { yylval.i=1; return UP_OR_DOWN; }
  750. Xdown        { yylval.i=0; return UP_OR_DOWN; }
  751. Xfalse        { yylval.i=0; return BOOLEAN; }
  752. Xtrue        { yylval.i=1; return BOOLEAN; }
  753. Xdust        { yylval.i=DUST; return ENGRAVING_TYPE; }
  754. Xengrave        { yylval.i=ENGRAVE; return ENGRAVING_TYPE; }
  755. Xburn        { yylval.i=BURN; return ENGRAVING_TYPE; }
  756. Xmark        { yylval.i=MARK; return ENGRAVING_TYPE; }
  757. Xblessed        { yylval.i=1; return CURSE_TYPE; }
  758. Xuncursed    { yylval.i=2; return CURSE_TYPE; }
  759. Xcursed        { yylval.i=3; return CURSE_TYPE; }
  760. Xnoteleport    { yylval.i=NOTELEPORT; return FLAG_TYPE; }
  761. Xhardfloor    { yylval.i=HARDFLOOR; return FLAG_TYPE; }
  762. Xnommap        { yylval.i=NOMMAP; return FLAG_TYPE; }
  763. Xshortsighted    { yylval.i=SHORTSIGHTED; return FLAG_TYPE; }
  764. X[+\-]?[0-9]+    { yylval.i=atoi(yytext); return INTEGER; }
  765. X\"[^"]*\"    { yytext[yyleng-1] = 0; /* Discard the trailing \" */
  766. X          yylval.map = (char *) alloc(strlen(yytext+1)+1);
  767. X          strcpy(yylval.map, yytext+1); /* Discard the first \" */
  768. X          return STRING; }
  769. X\n        { line_number++; }
  770. X[ \t]+        ;
  771. X'.'        { yylval.i = yytext[1]; return CHAR; }
  772. X.        { return yytext[0]; }
  773. X%%
  774. X#ifdef    AMIGA
  775. Xlong *alloc(n)
  776. X    unsigned n;
  777. X{
  778. X    return ((long *)malloc (n));
  779. X}
  780. X#endif
  781. X
  782. X/* routine to switch to another input file; needed for flex */
  783. Xvoid init_yyin( input_f )
  784. XFILE *input_f;
  785. X{
  786. X#ifdef FLEX_SCANNER
  787. X    if (yyin)
  788. X        yyrestart(input_f);
  789. X    else
  790. X#endif
  791. X        yyin = input_f;
  792. X}
  793. X/* analogous routine (for completeness) */
  794. Xvoid init_yyout( output_f )
  795. XFILE *output_f;
  796. X{
  797. X    yyout = output_f;
  798. X}
  799. X
  800. END_OF_FILE
  801. if test 7556 -ne `wc -c <'util/lev_comp.l'`; then
  802.     echo shar: \"'util/lev_comp.l'\" unpacked with wrong size!
  803. fi
  804. # end of 'util/lev_comp.l'
  805. fi
  806. if test -f 'win/X11/nethack.rc' -a "${1}" != "-c" ; then 
  807.   echo shar: Will not clobber existing file \"'win/X11/nethack.rc'\"
  808. else
  809. echo shar: Extracting \"'win/X11/nethack.rc'\" \(1877 characters\)
  810. sed "s/^X//" >'win/X11/nethack.rc' <<'END_OF_FILE'
  811. X#
  812. X# Nethack configuration file.
  813. X#
  814. X# Naming this file $(HOME)/.nethackrc (for UNIX) or setting the environment
  815. X# variable NETHACKOPTIONS to point to its full path name elsewhere tells
  816. X# NetHack to use X11 windowing and fonts (provided the executable was
  817. X# compiled with that ability).
  818. X#
  819. X#
  820. XOPTIONS=windowtype:x11
  821. XOPTIONS=confirm,male,fixinv,nopickup,safe_pet,sortpack,tombstone,verbose,news
  822. XOPTIONS=fruit:pineapple
  823. XOPTIONS=dogname:Dhairrhuwyth
  824. XOPTIONS=catname:Ghisteslwchlohm
  825. X#
  826. X# There are 17 object symbols and 69 graphics symbols.
  827. X# The descriptions of these symbols can be found in dat/opthelp.
  828. X#
  829. X#
  830. X# Font: nh10 (10x20)
  831. X#
  832. XOBJECTS= 180 183 188 192 181 184 182 189 190 196 \
  833. X     191 194 193 187 185 186 195
  834. X#
  835. XGRAPHICS= 032 025 018 013 012 014 011 015 023 024 \
  836. X      022 021 128 129 130 131 132 133 134 135 \
  837. X      136 137 145 146 138 139 144 143 142 141 \
  838. X      140 149 150 031 031 147 148 031 161 140 \
  839. X      151 152 153 154 155 156 157 158      \
  840. X      159 160 161 162              \
  841. X      163 164 165 166 167 168 169 170      \
  842. X      171 172 173 174 175 176 177 178 179
  843. X#
  844. X#
  845. X# Font: ibm (8x14)
  846. X#
  847. X#OBJECTS= 207 210 215 219 208 211 209 216 217 223 \
  848. X#     218 221 220 214 212 213 222
  849. X#
  850. X#GRAPHICS= 032 128 129 130 131 132 133 134 135 136 \
  851. X#      137 138 139 045 124 142 143 144 145 146 \
  852. X#      147 148 155 156 149 150 227 154 153 152 \
  853. X#      151 159 160 200 200 157 158 250 170 151 \
  854. X#      161 162 163 164 165 166 167 168      \
  855. X#      169 170 171 172              \
  856. X#      173 174 175 176 177 178 179 180      \
  857. X#      181 182 183 184 185 186 187 188 189
  858. X#
  859. X#
  860. X# Font: a "standard" font like 6x13
  861. X#
  862. X#GRAPHICS = 032 025 018 013 012 014 011 015 023 024 \
  863. X#       022 021 031 045 124 043 043 031 035 001 \
  864. X#       060 062 060 062 094 002 019 092 035 123 \
  865. X#       125 031 125 046 046 035 035 046 127 125 \
  866. X#       124 045 092 047 042 033 041 040       \
  867. X#       048 035 064 042               \
  868. X#       047 045 092 124 124 092 045 047         \
  869. X#       047 064 092 064 064 064 092 064 047
  870. END_OF_FILE
  871. if test 1877 -ne `wc -c <'win/X11/nethack.rc'`; then
  872.     echo shar: \"'win/X11/nethack.rc'\" unpacked with wrong size!
  873. fi
  874. # end of 'win/X11/nethack.rc'
  875. fi
  876. if test -f 'win/X11/nh56icon' -a "${1}" != "-c" ; then 
  877.   echo shar: Will not clobber existing file \"'win/X11/nh56icon'\"
  878. else
  879. echo shar: Extracting \"'win/X11/nh56icon'\" \(2734 characters\)
  880. sed "s/^X//" >'win/X11/nh56icon' <<'END_OF_FILE'
  881. X/*    SCCS Id: @(#)nh56icon    3.1    93/01/21            */
  882. X/*    Copyright (c) 1993 by M. Stephenson                */
  883. X/* NetHack may be freely redistributed.  See license for details.    */
  884. X
  885. X/*    56x56 X11 icon for NetHack.                    */
  886. X
  887. X#define nh56icon_width 56
  888. X#define nh56icon_height 56
  889. Xstatic char nh56icon_bits[] = {
  890. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  891. X   0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00,
  892. X   0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03,
  893. X   0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
  894. X   0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x30, 0x38,
  895. X   0x18, 0x00, 0xc0, 0x03, 0x00, 0x78, 0x28, 0x3c, 0x00, 0xc0, 0x03, 0x00,
  896. X   0xf8, 0x6c, 0x3e, 0x00, 0xc0, 0x03, 0x00, 0xf8, 0x55, 0x3f, 0x00, 0xc0,
  897. X   0x23, 0x22, 0xfc, 0xc7, 0x7f, 0x88, 0xc8, 0x43, 0x10, 0xfc, 0xd7, 0x7f,
  898. X   0x10, 0xc4, 0x03, 0x07, 0xfe, 0xc7, 0xff, 0xc0, 0xc1, 0x83, 0x0d, 0xfe,
  899. X   0xd7, 0xff, 0x60, 0xc3, 0xa3, 0x28, 0xfe, 0xc7, 0xff, 0x28, 0xca, 0x83,
  900. X   0x0d, 0xfe, 0xd7, 0xff, 0x60, 0xc3, 0x03, 0x07, 0xfe, 0xc7, 0xff, 0xc0,
  901. X   0xc1, 0x43, 0x10, 0xfc, 0xd7, 0x7f, 0x10, 0xc4, 0x23, 0x22, 0xfc, 0xc7,
  902. X   0x7f, 0x88, 0xc8, 0x03, 0x00, 0xf8, 0x55, 0x3f, 0x00, 0xc0, 0x03, 0x00,
  903. X   0xf8, 0x44, 0x3e, 0x00, 0xc0, 0x03, 0x00, 0x78, 0x54, 0x3c, 0x00, 0xc0,
  904. X   0x03, 0x00, 0x30, 0x6c, 0x18, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x6c, 0x00,
  905. X   0x00, 0xc0, 0x03, 0x00, 0x00, 0x38, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00,
  906. X   0x38, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x38, 0x00, 0x00, 0xc0, 0x03,
  907. X   0x00, 0x00, 0x38, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x38, 0x00, 0x00,
  908. X   0xc0, 0x03, 0x00, 0x00, 0x38, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x38,
  909. X   0x00, 0x00, 0xc0, 0x43, 0x10, 0x21, 0x38, 0x70, 0x80, 0xc0, 0xc3, 0x10,
  910. X   0x21, 0x38, 0x88, 0xc0, 0xc0, 0xc3, 0x10, 0x21, 0x38, 0x80, 0x80, 0xc0,
  911. X   0x43, 0x11, 0x21, 0x38, 0x80, 0x80, 0xc0, 0x43, 0x12, 0x3f, 0x38, 0x70,
  912. X   0x80, 0xc0, 0x43, 0x12, 0x21, 0x38, 0x80, 0x80, 0xc0, 0x43, 0x14, 0x21,
  913. X   0x38, 0x80, 0x80, 0xc0, 0x43, 0x18, 0x21, 0x38, 0x80, 0x80, 0xc0, 0x43,
  914. X   0x18, 0x21, 0x38, 0x88, 0x8c, 0xc0, 0x43, 0x10, 0x21, 0x38, 0x70, 0xcc,
  915. X   0xc1, 0x03, 0x00, 0x00, 0x38, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x38,
  916. X   0x00, 0x00, 0xc0, 0xfb, 0xff, 0xff, 0x39, 0xff, 0xff, 0xdf, 0x0b, 0x00,
  917. X   0x80, 0x7c, 0x02, 0x00, 0xd0, 0x0b, 0x00, 0x80, 0xee, 0x02, 0x00, 0xd0,
  918. X   0xfb, 0xff, 0xff, 0xd6, 0xfe, 0xff, 0xdf, 0x0b, 0x00, 0x80, 0xaa, 0x02,
  919. X   0x00, 0xd0, 0x0b, 0x00, 0x80, 0x54, 0x02, 0x00, 0xd0, 0xfb, 0xff, 0xff,
  920. X   0x39, 0xff, 0xff, 0xdf, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03,
  921. X   0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  922. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  923. END_OF_FILE
  924. if test 2734 -ne `wc -c <'win/X11/nh56icon'`; then
  925.     echo shar: \"'win/X11/nh56icon'\" unpacked with wrong size!
  926. fi
  927. # end of 'win/X11/nh56icon'
  928. fi
  929. echo shar: End of archive 43 \(of 108\).
  930. cp /dev/null ark43isdone
  931. MISSING=""
  932. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 \
  933. 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 \
  934. 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 \
  935. 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 \
  936. 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 \
  937. 101 102 103 104 105 106 107 108 ; do
  938.     if test ! -f ark${I}isdone ; then
  939.     MISSING="${MISSING} ${I}"
  940.     fi
  941. done
  942. if test "${MISSING}" = "" ; then
  943.     echo You have unpacked all 108 archives.
  944.     echo "Now execute 'rebuild.sh'"
  945.     rm -f ark10[0-8]isdone ark[1-9]isdone ark[1-9][0-9]isdone
  946. else
  947.     echo You still need to unpack the following archives:
  948.     echo "        " ${MISSING}
  949. fi
  950. ##  End of shell archive.
  951. exit 0
  952.