home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume16 / nethack31 / part96 < prev    next >
Internet Message Format  |  1993-02-06  |  59KB
  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: v16i104:  nethack31 - display oriented dungeons & dragons (Ver. 3.1), Part96/108
  5. Message-ID: <4469@master.CNA.TEK.COM>
  6. Date: 5 Feb 93 22:03:06 GMT
  7. Sender: news@master.CNA.TEK.COM
  8. Lines: 1986
  9. Approved: billr@saab.CNA.TEK.COM
  10. Xref: uunet comp.sources.games:1655
  11.  
  12. Submitted-by: izchak@linc.cis.upenn.edu (Izchak Miller)
  13. Posting-number: Volume 16, Issue 104
  14. Archive-name: nethack31/Part96
  15. Supersedes: nethack3p9: Volume 10, Issue 46-108
  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 96 (of 108)."
  27. # Contents:  dat/help include/decl.h src/extralev.c src/mplayer.c
  28. #   src/wield.c sys/share/pcunix.c win/tty/topl.c
  29. # Wrapped by billr@saab on Wed Jan 27 16:09:27 1993
  30. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  31. if test -f 'dat/help' -a "${1}" != "-c" ; then 
  32.   echo shar: Will not clobber existing file \"'dat/help'\"
  33. else
  34. echo shar: Extracting \"'dat/help'\" \(8454 characters\)
  35. sed "s/^X//" >'dat/help' <<'END_OF_FILE'
  36. X        Welcome to NetHack!                ( description of version 3.1 )
  37. X
  38. X        NetHack is a Dungeons and Dragons like game where you (the adventurer)
  39. Xdescend into the depths of the dungeon in search of the Amulet of Yendor
  40. X(reputed to be hidden somewhere below the twentieth level).  You are
  41. Xaccompanied by a dog or cat that can help you in many ways and can be trained
  42. Xto do all sorts of things.  On the way you will find useful (or useless)
  43. Xitems (quite possibly with magic properties), and assorted monsters.  You
  44. Xattack a monster by trying to move into the space a monster is in (but often
  45. Xit is much wiser to leave it alone).
  46. X
  47. X        Unlike most adventure games, which give you a verbal description of
  48. Xyour location, NetHack gives you a visual image of the dungeon level you are
  49. Xon.
  50. X
  51. X        NetHack uses the following symbols:
  52. X
  53. X        - and |  The walls of a room, also open doors.
  54. X        .        The floor of a room or a doorway.
  55. X        #        A corridor, a kitchen sink (if your dungeon has sinks), or
  56. X                 a drawbridge.
  57. X        >        A way to the next level.
  58. X        <        A way to the previous level.
  59. X        @        You (usually) or another human.
  60. X        )        A weapon of some sort.
  61. X        [        A suit or piece of armor.
  62. X        %        A piece of food (not necessarily healthy).
  63. X        /        A wand.
  64. X        =        A ring.
  65. X        ?        A scroll.
  66. X        !        A potion.
  67. X        (        Some other useful object (pick-axe, key, lamp...)
  68. X        $        A pile of gold.
  69. X        *        A gem or rock (possibly valuable, possibly worthless).
  70. X        +        A closed door, or a spell book containing a spell
  71. X                 you can learn.
  72. X        ^        A trap (once you detect it).
  73. X        "        An amulet, or a spider web.
  74. X        0        An iron ball.
  75. X        _        An altar, or an iron chain.
  76. X        }        A pool of water or moat or a pool of lava.
  77. X        {        A fountain.
  78. X        \        An opulent throne.
  79. X        `        A boulder or statue.
  80. X        A to Z, a to z, and several others:  Monsters.
  81. X
  82. X                 You can find out what a character represents by typing
  83. X                 '/' followed by the character, as in "/A", which will
  84. X                 tell you that 'A' is an Ape.
  85. X
  86. X
  87. Xy k u   7 8 9   Move commands:
  88. X \|/     \|/            yuhjklbn: go one step in specified direction
  89. Xh-.-l   4-.-6           YUHJKLBN: go in specified direction until you
  90. X /|\     /|\                        hit a wall or run into something
  91. Xb j n   1 2 3           g<dir>:   run in direction <dir> until something
  92. X      numberpad                     interesting is seen
  93. X                        G<dir>,   same, except a branching corridor isn't
  94. X                        ^<dir>:     considered interesting
  95. X                        m<dir>:   move without picking up objects
  96. X                If the numberpad option is set, the number keys move instead.
  97. X
  98. XCommands:
  99. X        NetHack knows the following commands:
  100. X        ?       Help menu.
  101. X        /       (followed by any symbol):  tell what this symbol represents.
  102. X                You may choose to specify a location or give a symbol argument.
  103. X        &       Tell what a command does.
  104. X        <       Go up a staircase (if you are standing on it).
  105. X        >       Go down a staircase (if you are standing on it).
  106. X        .       Rest, do nothing for one turn.
  107. X        a       Apply (use) an tool (pick-axe, key, lamp...)
  108. X        A       Remove all armor.
  109. X        ^A      Redo the previous command
  110. X        c       Close a door.
  111. X        C       Call (name) an individual monster.
  112. X        d       Drop something.  d7a:  drop seven items of object a.
  113. X        D       Drop several things.  In answer to the question
  114. X                "What kinds of things do you want to drop? [!%= au]"
  115. X                you should type zero or more object symbols possibly
  116. X                followed by 'a' and/or 'u'.
  117. X                Da - drop all objects, without asking for confirmation.
  118. X                Du - drop only unpaid objects (when in a shop).
  119. X                D%u - drop only unpaid food.
  120. X        ^D      Kick (for doors, usually).
  121. X        e       Eat food.
  122. X        E       Engrave a message on the floor.
  123. X                E- - write in the dust with your fingers.
  124. X
  125. X
  126. X
  127. X        i       Print your inventory.
  128. X        I       Print selected parts of your inventory, as in
  129. X                I* - list all gems in inventory.
  130. X                Iu - list all unpaid items.
  131. X                Ix - list all used up items that are on your shopping bill.
  132. X                I$ - count your money.
  133. X        o       Open a door.
  134. X        O       Set options.  You will be asked to enter an option line.
  135. X                If the line is empty, the current options are reported.
  136. X                Descriptions of possible options and their formats can be
  137. X                obtained by entering "?".  Options are usually set before
  138. X                the game with a NETHACKOPTIONS environment variable, not
  139. X                with the 'O' command.
  140. X        p       Pay your shopping bill.
  141. X        P       Put on an accessory (ring, amulet, etc).
  142. X        ^P      Repeat last message (subsequent ^P's repeat earlier messages).
  143. X        q       Drink (quaff) a potion.
  144. X        Q       Quit the game.
  145. X        r       Read a scroll or spell book.
  146. X        R       Remove an accessory (ring, amulet, etc).
  147. X        ^R      Redraw the screen.
  148. X        s       Search for secret doors and traps around you.
  149. X        S       Save the game.
  150. X        t       Throw an object or shoot a projectile.
  151. X        T       Take off armor.
  152. X        ^T      Teleport, if you are able.
  153. X        v       Prints the version number.
  154. X        V       Prints a longer identification of the version, including the
  155. X                history of the game.
  156. X        w       Wield weapon.  w- means wield nothing, use bare hands.
  157. X        W       Wear armor.
  158. X        x       List the spells you know (same as '+').
  159. X        X       Switch the game to explore (discovery) mode.
  160. X        z       Zap a wand.
  161. X        Z       Cast a spell.
  162. X        ^Z      Suspend the game.
  163. X        :       Look at what is here.
  164. X        ;       Look at what is somewhere else.
  165. X        ,       Pick up some things.
  166. X        @       Toggle the pickup option.
  167. X        ^       Ask for the type of a trap you found earlier.
  168. X        )       Tell what weapon you are wielding.
  169. X        [       Tell what armor you are wearing.
  170. X        =       Tell what rings you are wearing.
  171. X        "       Tell what amulet you are wearing.
  172. X        (       Tell what tools you are using.
  173. X        $       Count your gold pieces.
  174. X        +       List the spells you know (same as 'x').
  175. X        \       Show what types of objects have been discovered.
  176. X        !       Escape to a shell.
  177. X        #       Introduces one of the "extended" commands.  To get a list of
  178. X                the commands you can use with "#" type "#?".  The extended
  179. X                commands you can use depends upon what options the game was
  180. X                compiled with, along with your class and what type of monster
  181. X                you most closely resemble at a given moment.  If your keyboard
  182. X                has a meta key (which, when pressed in combination with another
  183. X                key, modifies it by setting the 'meta' (8th, or 'high') bit),
  184. X                these extended commands can be invoked by meta-ing the first
  185. X                letter of the command.
  186. X
  187. X        If the "number_pad" option is on, some additional letter commands
  188. X        are available:
  189. X
  190. X        j       Jump to another location.
  191. X        k       Kick (for doors, usually).
  192. X        l       Loot a box on the floor.
  193. X        n       Name an object or type of object.
  194. X        u       Untrap a trapped object or door.
  195. X
  196. X        You can put a number before a command to repeat it that many times,
  197. X        as in "40." or "20s.".  If you have the number_pad option set, you
  198. X        must type 'n' to prefix the count, as in "n40." or "n20s".
  199. X
  200. X 
  201. X        Some information is displayed on the bottom line.  You see your
  202. X        attributes, your alignment, what dungeon level you are on, how many
  203. X        hit points you have now (and will have when fully recovered), what
  204. X        your armor class is (the lower the better), your experience level,
  205. X        and the state of your stomach.  Optionally, you may or may not see
  206. X        other information such as spell points, how much gold you have, etc.
  207. X
  208. X        Have Fun, and Happy Hacking!
  209. END_OF_FILE
  210. if test 8454 -ne `wc -c <'dat/help'`; then
  211.     echo shar: \"'dat/help'\" unpacked with wrong size!
  212. fi
  213. # end of 'dat/help'
  214. fi
  215. if test -f 'include/decl.h' -a "${1}" != "-c" ; then 
  216.   echo shar: Will not clobber existing file \"'include/decl.h'\"
  217. else
  218. echo shar: Extracting \"'include/decl.h'\" \(8850 characters\)
  219. sed "s/^X//" >'include/decl.h' <<'END_OF_FILE'
  220. X/*    SCCS Id: @(#)decl.h    3.1    92/12/11    */
  221. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  222. X/* NetHack may be freely redistributed.  See license for details. */
  223. X
  224. X#ifndef DECL_H
  225. X#define DECL_H
  226. X
  227. X#define E extern
  228. X
  229. XE int NDECL((*occupation));
  230. XE int NDECL((*afternmv));
  231. X
  232. XE const char *hname;
  233. XE int hackpid;
  234. X#if defined(UNIX) || defined(VMS)
  235. XE int locknum;
  236. X#endif
  237. X#ifdef DEF_PAGER
  238. XE char *catmore;
  239. X#endif    /* DEF_PAGER */
  240. X
  241. XE char SAVEF[];
  242. X#ifdef MICRO
  243. XE char SAVEP[];
  244. X#endif
  245. X
  246. XE int NEARDATA bases[];
  247. X
  248. XE int NEARDATA multi;
  249. XE int NEARDATA warnlevel;
  250. XE int NEARDATA nroom;
  251. XE int NEARDATA nsubroom;
  252. XE int NEARDATA occtime;
  253. X
  254. XE int x_maze_max, y_maze_max;
  255. XE int otg_temp;
  256. X
  257. X#ifdef REDO
  258. XE int NEARDATA in_doagain;
  259. X#endif
  260. X
  261. XE struct dgn_topology {    /* special dungeon levels for speed */
  262. X    d_level    d_oracle_level;
  263. X    d_level    d_bigroom_level;    /* unused */
  264. X#ifdef REINCARNATION
  265. X    d_level    d_rogue_level;
  266. X#endif
  267. X    d_level    d_medusa_level;
  268. X    d_level    d_stronghold_level;
  269. X    d_level    d_valley_level;
  270. X    d_level    d_wiz1_level;
  271. X    d_level    d_wiz2_level;
  272. X    d_level    d_wiz3_level;
  273. X    d_level     d_juiblex_level;
  274. X    d_level     d_orcus_level;
  275. X    d_level    d_baalzebub_level;    /* unused */
  276. X    d_level    d_asmodeus_level;    /* unused */
  277. X    d_level    d_portal_level;        /* only in goto_level() [do.c] */
  278. X    d_level    d_sanctum_level;
  279. X    d_level    d_earth_level;
  280. X    d_level    d_water_level;
  281. X    d_level    d_fire_level;
  282. X    d_level    d_air_level;
  283. X    d_level    d_astral_level;
  284. X    xchar    d_tower_dnum;
  285. X#ifdef MULDGN
  286. X    xchar    d_mines_dnum, d_quest_dnum;
  287. X    d_level    d_qstart_level, d_qlocate_level, d_nemesis_level;
  288. X    d_level    d_knox_level;
  289. X#endif
  290. X} dungeon_topology;
  291. X/* macros for accesing the dungeon levels by their old names */
  292. X#define oracle_level        (dungeon_topology.d_oracle_level)
  293. X#define bigroom_level        (dungeon_topology.d_bigroom_level)
  294. X#ifdef REINCARNATION
  295. X#define rogue_level        (dungeon_topology.d_rogue_level)
  296. X#endif
  297. X#define medusa_level        (dungeon_topology.d_medusa_level)
  298. X#define stronghold_level    (dungeon_topology.d_stronghold_level)
  299. X#define valley_level        (dungeon_topology.d_valley_level)
  300. X#define wiz1_level        (dungeon_topology.d_wiz1_level)
  301. X#define wiz2_level        (dungeon_topology.d_wiz2_level)
  302. X#define wiz3_level        (dungeon_topology.d_wiz3_level)
  303. X#define juiblex_level        (dungeon_topology.d_juiblex_level)
  304. X#define orcus_level        (dungeon_topology.d_orcus_level)
  305. X#define baalzebub_level        (dungeon_topology.d_baalzebub_level)
  306. X#define asmodeus_level        (dungeon_topology.d_asmodeus_level)
  307. X#define portal_level        (dungeon_topology.d_portal_level)
  308. X#define sanctum_level        (dungeon_topology.d_sanctum_level)
  309. X#define earth_level        (dungeon_topology.d_earth_level)
  310. X#define water_level        (dungeon_topology.d_water_level)
  311. X#define fire_level        (dungeon_topology.d_fire_level)
  312. X#define air_level        (dungeon_topology.d_air_level)
  313. X#define astral_level        (dungeon_topology.d_astral_level)
  314. X#define tower_dnum        (dungeon_topology.d_tower_dnum)
  315. X#ifdef MULDGN
  316. X#define mines_dnum        (dungeon_topology.d_mines_dnum)
  317. X#define quest_dnum        (dungeon_topology.d_quest_dnum)
  318. X#define qstart_level        (dungeon_topology.d_qstart_level)
  319. X#define qlocate_level        (dungeon_topology.d_qlocate_level)
  320. X#define nemesis_level        (dungeon_topology.d_nemesis_level)
  321. X#define knox_level        (dungeon_topology.d_knox_level)
  322. X#endif
  323. X
  324. XE stairway NEARDATA dnstair, NEARDATA upstair; /* stairs up and down. */
  325. X#define xdnstair    (dnstair.sx)
  326. X#define ydnstair    (dnstair.sy)
  327. X#define xupstair    (upstair.sx)
  328. X#define yupstair    (upstair.sy)
  329. X
  330. XE stairway NEARDATA dnladder, NEARDATA upladder; /* ladders up and down. */
  331. X#define xdnladder    (dnladder.sx)
  332. X#define ydnladder    (dnladder.sy)
  333. X#define xupladder    (upladder.sx)
  334. X#define yupladder    (upladder.sy)
  335. X
  336. XE stairway NEARDATA sstairs;
  337. X
  338. XE dest_area NEARDATA updest, NEARDATA dndest; /* level-change dest. areas */
  339. X
  340. XE coord NEARDATA inv_pos;
  341. XE dungeon NEARDATA dungeons[];
  342. XE s_level NEARDATA *sp_levchn;
  343. X#define dunlev_reached(x)    (dungeons[(x)->dnum].dunlev_ureached)
  344. X
  345. X#ifdef MULDGN
  346. X#include "quest.h"
  347. XE struct q_score     quest_status;
  348. X#endif
  349. X
  350. XE int NEARDATA done_stopprint;
  351. XE int NEARDATA done_hup;
  352. X
  353. XE char NEARDATA pl_character[PL_CSIZ];
  354. X#ifdef TUTTI_FRUTTI
  355. XE char NEARDATA pl_fruit[PL_FSIZ];
  356. XE int NEARDATA current_fruit;
  357. XE struct fruit NEARDATA *ffruit;
  358. X#endif
  359. X
  360. XE char NEARDATA tune[6];
  361. X
  362. XE const char NEARDATA quitchars[];
  363. XE const char NEARDATA vowels[];
  364. XE const char NEARDATA ynchars[];
  365. XE const char NEARDATA ynqchars[];
  366. XE const char NEARDATA ynaqchars[];
  367. XE const char NEARDATA ynNaqchars[];
  368. XE long NEARDATA yn_number;
  369. XE int NEARDATA smeq[];
  370. XE int NEARDATA doorindex;
  371. XE char NEARDATA *save_cm;
  372. X#define KILLED_BY_AN     0
  373. X#define KILLED_BY     1
  374. X#define NO_KILLER_PREFIX 2
  375. XE int NEARDATA killer_format;
  376. XE const char NEARDATA *killer;
  377. XE const char *configfile;
  378. XE char NEARDATA plname[PL_NSIZ];
  379. XE char NEARDATA dogname[];
  380. XE char NEARDATA catname[];
  381. XE char preferred_pet;
  382. XE const char NEARDATA *occtxt;        /* defined when occupation != NULL */
  383. XE const char NEARDATA *nomovemsg;
  384. XE const char NEARDATA nul[];
  385. XE const char *traps[];
  386. XE char lock[];
  387. X
  388. XE const char NEARDATA sdir[], NEARDATA ndir[];
  389. XE const schar NEARDATA xdir[], NEARDATA ydir[], zdir[];
  390. X
  391. XE schar NEARDATA tbx, NEARDATA tby;        /* set in mthrowu.c */
  392. XE int NEARDATA dig_effort;    /* apply.c, hack.c */
  393. XE d_level NEARDATA dig_level;
  394. XE coord NEARDATA dig_pos;
  395. XE boolean NEARDATA dig_down;
  396. X
  397. XE long NEARDATA moves, NEARDATA monstermoves;
  398. XE long NEARDATA wailmsg;
  399. X
  400. XE boolean NEARDATA in_mklev;
  401. XE boolean NEARDATA stoned;
  402. XE boolean NEARDATA unweapon;
  403. XE boolean NEARDATA mrg_to_wielded;
  404. X
  405. X#ifdef KOPS
  406. XE boolean NEARDATA allow_kops;
  407. X#endif
  408. X
  409. XE const int shield_static[];
  410. X
  411. X#ifndef SPELLS_H
  412. X#include "spell.h"
  413. X#endif
  414. XE struct spell NEARDATA spl_book[];    /* sized in decl.c */
  415. X
  416. X#ifdef TEXTCOLOR
  417. X# ifndef COLOR_H
  418. X#include "color.h"
  419. X# endif
  420. XE const int zapcolors[];
  421. X#endif
  422. X
  423. XE const char def_oc_syms[MAXOCLASSES];    /* default class symbols */
  424. XE uchar oc_syms[MAXOCLASSES];        /* current class symbols */
  425. XE const char def_monsyms[MAXMCLASSES];    /* default class symbols */
  426. XE uchar monsyms[MAXMCLASSES];        /* current class symbols */
  427. X
  428. X#ifndef OBJ_H
  429. X#include "obj.h"
  430. X#endif
  431. X
  432. XE struct obj NEARDATA *invent, NEARDATA *uarm, NEARDATA *uarmc,
  433. X    NEARDATA *uarmh, NEARDATA *uarms, NEARDATA *uarmg, NEARDATA *uarmf,
  434. X#ifdef TOURIST
  435. X    NEARDATA *uarmu, /* under-wear, so to speak */
  436. X#endif
  437. X#ifdef POLYSELF
  438. X    NEARDATA *uskin,
  439. X#endif
  440. X    NEARDATA *uamul, NEARDATA *uleft, NEARDATA *uright, NEARDATA *ublindf,
  441. X    NEARDATA *uwep;
  442. X
  443. XE struct obj NEARDATA *uchain;    /* defined only when punished */
  444. XE struct obj NEARDATA *uball;
  445. XE struct obj NEARDATA *migrating_objs;
  446. XE struct obj NEARDATA *billobjs;
  447. XE struct obj NEARDATA zeroobj;        /* init'd and defined in decl.c */
  448. X
  449. X#ifndef YOU_H
  450. X#include "you.h"
  451. X#endif
  452. X
  453. XE struct you NEARDATA u;
  454. X
  455. X#ifndef ONAMES_H
  456. X#include "onames.h"
  457. X#endif
  458. X#ifndef PM_H
  459. X#include "pm.h"
  460. X#endif
  461. X
  462. XE struct permonst NEARDATA playermon, NEARDATA *uasmon;
  463. X                    /* also decl'd extern in permonst.h */
  464. X                    /* init'd in monst.c */
  465. X
  466. XE struct monst NEARDATA youmonst;    /* init'd and defined in decl.c */
  467. XE struct monst NEARDATA *mydogs, NEARDATA *migrating_mons;
  468. X
  469. XE struct c_color_names {
  470. X    char const    *const c_black, *const c_amber, *const c_golden,
  471. X        *const c_light_blue,*const c_red, *const c_green,
  472. X        *const c_silver, *const c_blue, *const c_purple,
  473. X        *const c_white;
  474. X} NEARDATA c_color_names;
  475. X#define Black        c_color_names.c_black
  476. X#define amber        c_color_names.c_amber
  477. X#define golden        c_color_names.c_golden
  478. X#define light_blue    c_color_names.c_light_blue
  479. X#define red        c_color_names.c_red
  480. X#define green        c_color_names.c_green
  481. X#define silver        c_color_names.c_silver
  482. X#define blue        c_color_names.c_blue
  483. X#define purple        c_color_names.c_purple
  484. X#define White        c_color_names.c_white
  485. X
  486. XE struct c_common_strings {
  487. X    char const    *const c_nothing_happens, *const c_thats_enough_tries,
  488. X        *const c_silly_thing_to, *const c_shudder_for_moment;
  489. X} c_common_strings;
  490. X#define nothing_happens    c_common_strings.c_nothing_happens
  491. X#define thats_enough_tries c_common_strings.c_thats_enough_tries
  492. X#define silly_thing_to       c_common_strings.c_silly_thing_to
  493. X#define shudder_for_moment c_common_strings.c_shudder_for_moment
  494. X
  495. X/* Vision */
  496. XE boolean NEARDATA vision_full_recalc;    /* TRUE if need vision recalc */
  497. XE char NEARDATA **viz_array;    /* could see/in sight row pointers */
  498. X
  499. X/* Window system stuff */
  500. XE winid NEARDATA WIN_MESSAGE, NEARDATA WIN_STATUS;
  501. XE winid NEARDATA WIN_MAP, NEARDATA WIN_INVEN;
  502. XE char toplines[];
  503. X#ifndef TERMCAP_H
  504. XE struct tc_gbl_data {    /* also declared in termcap.h */
  505. X    char *tc_AS, *tc_AE;    /* graphics start and end (tty font swapping) */
  506. X    int   tc_LI,  tc_CO;    /* lines and columns */
  507. X} tc_gbl_data;
  508. X#define AS tc_gbl_data.tc_AS
  509. X#define AE tc_gbl_data.tc_AE
  510. X#define LI tc_gbl_data.tc_LI
  511. X#define CO tc_gbl_data.tc_CO
  512. X#endif
  513. X
  514. X/* xxxexplain[] is in drawing.c */
  515. XE const char *monexplain[], *objexplain[], *oclass_names[];
  516. X
  517. XE const char NEARDATA *pl_classes;
  518. X
  519. X#undef E
  520. X
  521. X#endif /* DECL_H */
  522. END_OF_FILE
  523. if test 8850 -ne `wc -c <'include/decl.h'`; then
  524.     echo shar: \"'include/decl.h'\" unpacked with wrong size!
  525. fi
  526. # end of 'include/decl.h'
  527. fi
  528. if test -f 'src/extralev.c' -a "${1}" != "-c" ; then 
  529.   echo shar: Will not clobber existing file \"'src/extralev.c'\"
  530. else
  531. echo shar: Extracting \"'src/extralev.c'\" \(8664 characters\)
  532. sed "s/^X//" >'src/extralev.c' <<'END_OF_FILE'
  533. X/*    SCCS Id: @(#)extralev.c    3.1    92/05/27            */
  534. X/*    Copyright 1988, 1989 by Ken Arromdee                */
  535. X/* NetHack may be freely redistributed.  See license for details. */
  536. X
  537. X#include "hack.h"
  538. X
  539. X#ifdef REINCARNATION
  540. X
  541. Xstruct rogueroom {
  542. X    xchar rlx, rly;
  543. X    xchar dx, dy;
  544. X    boolean real;
  545. X    uchar doortable;
  546. X    int nroom; /* Only meaningful for "real" rooms */
  547. X};
  548. X#define UP 1
  549. X#define DOWN 2
  550. X#define LEFT 4
  551. X#define RIGHT 8
  552. X
  553. Xstatic struct rogueroom NEARDATA r[3][3];
  554. Xstatic void FDECL(roguejoin,(int,int,int,int,int));
  555. Xstatic void FDECL(roguecorr,(int,int,int));
  556. Xstatic void FDECL(miniwalk,(int,int));
  557. X
  558. Xstatic
  559. Xvoid
  560. Xroguejoin(x1,y1,x2,y2, horiz)
  561. Xint x1,y1,x2,y2;
  562. Xint horiz;
  563. X{
  564. X    register int x,y,middle;
  565. X#ifndef MAX
  566. X#define MAX(a,b) (((a) > (b)) ? (a) : (b))
  567. X#endif
  568. X#ifndef MIN
  569. X#define MIN(a,b) (((a) < (b)) ? (a) : (b))
  570. X#endif
  571. X    if (horiz) {
  572. X        middle = x1 + rn2(x2-x1+1);
  573. X        for(x=MIN(x1,middle); x<=MAX(x1,middle); x++)
  574. X            corr(x, y1);
  575. X        for(y=MIN(y1,y2); y<=MAX(y1,y2); y++)
  576. X            corr(middle,y);
  577. X        for(x=MIN(middle,x2); x<=MAX(middle,x2); x++)
  578. X            corr(x, y2);
  579. X    } else {
  580. X        middle = y1 + rn2(y2-y1+1);
  581. X        for(y=MIN(y1,middle); y<=MAX(y1,middle); y++)
  582. X            corr(x1, y);
  583. X        for(x=MIN(x1,x2); x<=MAX(x1,x2); x++)
  584. X            corr(x, middle);
  585. X        for(y=MIN(middle,y2); y<=MAX(middle,y2); y++)
  586. X            corr(x2,y);
  587. X    }
  588. X}
  589. X
  590. Xstatic
  591. Xvoid
  592. Xroguecorr(x, y, dir)
  593. Xint x,y,dir;
  594. X{
  595. X    register int fromx, fromy, tox, toy;
  596. X
  597. X    if (dir==DOWN) {
  598. X        r[x][y].doortable &= ~DOWN;
  599. X        if (!r[x][y].real) {
  600. X            fromx = r[x][y].rlx; fromy = r[x][y].rly;
  601. X            fromx += 1 + 26*x; fromy += 7*y;
  602. X        } else {
  603. X            fromx = r[x][y].rlx + rn2(r[x][y].dx);
  604. X            fromy = r[x][y].rly + r[x][y].dy;
  605. X            fromx += 1 + 26*x; fromy += 7*y;
  606. X            if (!IS_WALL(levl[fromx][fromy].typ))
  607. X                impossible("down: no wall at %d,%d?",fromx,
  608. X                                    fromy);
  609. X            dodoor(fromx, fromy, &rooms[r[x][y].nroom]);
  610. X            levl[fromx][fromy].doormask = D_NODOOR;
  611. X            fromy++;
  612. X        }
  613. X        if(y >= 2) {
  614. X            impossible("down door from %d,%d going nowhere?",x,y);
  615. X            return;
  616. X        }
  617. X        y++;
  618. X        r[x][y].doortable &= ~UP;
  619. X        if (!r[x][y].real) {
  620. X            tox = r[x][y].rlx; toy = r[x][y].rly;
  621. X            tox += 1 + 26*x; toy += 7*y;
  622. X        } else {
  623. X            tox = r[x][y].rlx + rn2(r[x][y].dx);
  624. X            toy = r[x][y].rly - 1;
  625. X            tox += 1 + 26*x; toy += 7*y;
  626. X            if (!IS_WALL(levl[tox][toy].typ))
  627. X                impossible("up: no wall at %d,%d?",tox,toy);
  628. X            dodoor(tox, toy, &rooms[r[x][y].nroom]);
  629. X            levl[tox][toy].doormask = D_NODOOR;
  630. X            toy--;
  631. X        }
  632. X        roguejoin(fromx, fromy, tox, toy, FALSE);
  633. X        return;
  634. X    } else if (dir == RIGHT) {
  635. X        r[x][y].doortable &= ~RIGHT;
  636. X        if (!r[x][y].real) {
  637. X            fromx = r[x][y].rlx; fromy = r[x][y].rly;
  638. X            fromx += 1 + 26*x; fromy += 7*y;
  639. X        } else {
  640. X            fromx = r[x][y].rlx + r[x][y].dx;
  641. X            fromy = r[x][y].rly + rn2(r[x][y].dy);
  642. X            fromx += 1 + 26*x; fromy += 7*y;
  643. X            if (!IS_WALL(levl[fromx][fromy].typ))
  644. X                impossible("down: no wall at %d,%d?",fromx,
  645. X                                    fromy);
  646. X            dodoor(fromx, fromy, &rooms[r[x][y].nroom]);
  647. X            levl[fromx][fromy].doormask = D_NODOOR;
  648. X            fromx++;
  649. X        }
  650. X        if(x >= 2) {
  651. X            impossible("right door from %d,%d going nowhere?",x,y);
  652. X            return;
  653. X        }
  654. X        x++;
  655. X        r[x][y].doortable &= ~LEFT;
  656. X        if (!r[x][y].real) {
  657. X            tox = r[x][y].rlx; toy = r[x][y].rly;
  658. X            tox += 1 + 26*x; toy += 7*y;
  659. X        } else {
  660. X            tox = r[x][y].rlx - 1;
  661. X            toy = r[x][y].rly + rn2(r[x][y].dy);
  662. X            tox += 1 + 26*x; toy += 7*y;
  663. X            if (!IS_WALL(levl[tox][toy].typ))
  664. X                impossible("left: no wall at %d,%d?",tox,toy);
  665. X            dodoor(tox, toy, &rooms[r[x][y].nroom]);
  666. X            levl[tox][toy].doormask = D_NODOOR;
  667. X            tox--;
  668. X        }
  669. X        roguejoin(fromx, fromy, tox, toy, TRUE);
  670. X        return;
  671. X    } else impossible("corridor in direction %d?",dir);
  672. X}
  673. X            
  674. X/* Modified walkfrom() from mkmaze.c */
  675. Xstatic
  676. Xvoid
  677. Xminiwalk(x, y)
  678. Xint x,y;
  679. X{
  680. X    register int q, dir;
  681. X    int dirs[4];
  682. X
  683. X    while(1) {
  684. X        q = 0;
  685. X#define doorhere (r[x][y].doortable)
  686. X        if (x>0 && (!(doorhere & LEFT)) &&
  687. X                    (!r[x-1][y].doortable || !rn2(10)))
  688. X            dirs[q++] = 0;
  689. X        if (x<2 && (!(doorhere & RIGHT)) &&
  690. X                    (!r[x+1][y].doortable || !rn2(10)))
  691. X            dirs[q++] = 1;
  692. X        if (y>0 && (!(doorhere & UP)) &&
  693. X                    (!r[x][y-1].doortable || !rn2(10)))
  694. X            dirs[q++] = 2;
  695. X        if (y<2 && (!(doorhere & DOWN)) &&
  696. X                    (!r[x][y+1].doortable || !rn2(10)))
  697. X            dirs[q++] = 3;
  698. X    /* Rogue levels aren't just 3 by 3 mazes; they have some extra
  699. X     * connections, thus that 1/10 chance
  700. X     */
  701. X        if (!q) return;
  702. X        dir = dirs[rn2(q)];
  703. X        switch(dir) { /* Move in direction */
  704. X            case 0: doorhere |= LEFT;
  705. X                x--;
  706. X                doorhere |= RIGHT;
  707. X                break;
  708. X            case 1: doorhere |= RIGHT;
  709. X                x++;
  710. X                doorhere |= LEFT;
  711. X                break;
  712. X            case 2: doorhere |= UP;
  713. X                y--;
  714. X                doorhere |= DOWN;
  715. X                break;
  716. X            case 3: doorhere |= DOWN;
  717. X                y++;
  718. X                doorhere |= UP;
  719. X                break;
  720. X        }
  721. X        miniwalk(x,y);
  722. X    }
  723. X}
  724. X
  725. Xvoid
  726. Xmakeroguerooms() {
  727. X    register int x,y;
  728. X    /* Rogue levels are structured 3 by 3, with each section containing
  729. X     * a room or an intersection.  The minimum width is 2 each way.
  730. X     * One difference between these and "real" Rogue levels: real Rogue
  731. X     * uses 24 rows and NetHack only 23.  So we cheat a bit by making the
  732. X     * second row of rooms not as deep.
  733. X     *
  734. X     * Each normal space has 6/7 rows and 25 columns in which a room may
  735. X     * actually be placed.  Walls go from rows 0-5/6 and columns 0-24.
  736. X     * Not counting walls, the room may go in
  737. X     * rows 1-5 and columns 1-23 (numbering starting at 0).  A room
  738. X     * coordinate of this type may be converted to a level coordinate
  739. X     * by adding 1+28*x to the column, and 7*y to the row.  (The 1
  740. X     * is because column 0 isn't used [we only use 1-78]).
  741. X     * Room height may be 2-4 (2-5 on last row), length 2-23 (not
  742. X     * counting walls)
  743. X     */
  744. X#define here r[x][y]
  745. X
  746. X    nroom = 0;
  747. X    for(y=0; y<3; y++) for(x=0; x<3; x++) {
  748. X        /* Note: we want to insure at least 1 room.  So, if the
  749. X         * first 8 are all dummies, force the last to be a room.
  750. X         */
  751. X        if (!rn2(5) && (nroom || (x<2 && y<2))) {
  752. X            /* Arbitrary: dummy rooms may only go where real
  753. X             * ones do.
  754. X             */
  755. X            here.real = FALSE;
  756. X            here.rlx = rn1(22, 2);
  757. X            here.rly = rn1((y==2)?4:3, 2);
  758. X        } else {
  759. X            here.real = TRUE;
  760. X            here.dx = rn1(22, 2); /* 2-23 long, plus walls */
  761. X            here.dy = rn1((y==2)?4:3, 2); /* 2-5 high, plus walls */
  762. X
  763. X            /* boundaries of room floor */
  764. X            here.rlx = rnd(23 - here.dx + 1);
  765. X            here.rly = rnd(((y==2) ? 5 : 4)- here.dy + 1);
  766. X            nroom++;
  767. X        }
  768. X        here.doortable = 0;
  769. X    }
  770. X    miniwalk(rn2(3), rn2(3));
  771. X    nroom = 0;
  772. X    for(y=0; y<3; y++) for(x=0; x<3; x++) {
  773. X        if (here.real) { /* Make a room */
  774. X            int lowx, lowy, hix, hiy;
  775. X
  776. X            r[x][y].nroom = nroom;
  777. X            smeq[nroom] = nroom;
  778. X
  779. X            lowx = 1 + 26*x + here.rlx;
  780. X            lowy = 7*y + here.rly;
  781. X            hix = 1 + 26*x + here.rlx + here.dx - 1;
  782. X            hiy = 7*y + here.rly + here.dy - 1;
  783. X            /* Strictly speaking, it should be lit only if above
  784. X             * level 10, but since Rogue rooms are only
  785. X             * encountered below level 10, use !rn2(7).
  786. X             */
  787. X
  788. X            add_room(lowx, lowy, hix, hiy, !rn2(7), OROOM, FALSE);
  789. X        }
  790. X    }
  791. X
  792. X    /* Now, add connecting corridors. */
  793. X    for(y=0; y<3; y++) for(x=0; x<3; x++) {
  794. X        if (here.doortable & DOWN)
  795. X            roguecorr(x, y, DOWN);
  796. X        if (here.doortable & RIGHT)
  797. X            roguecorr(x, y, RIGHT);
  798. X        if (here.doortable & LEFT)
  799. X            impossible ("left end of %d, %d never connected?",x,y);
  800. X        if (here.doortable & UP)
  801. X            impossible ("up end of %d, %d never connected?",x,y);
  802. X    }
  803. X}
  804. X
  805. Xvoid
  806. Xcorr(x,y)
  807. Xint x, y;
  808. X{
  809. X    if (rn2(50)) {
  810. X        levl[x][y].typ = CORR;
  811. X    } else {
  812. X        levl[x][y].typ = SCORR;
  813. X    }
  814. X}
  815. X
  816. Xvoid
  817. Xmakerogueghost()
  818. X{
  819. X    register struct monst *ghost;
  820. X    struct obj *ghostobj;
  821. X    struct mkroom *croom;
  822. X    int x,y;
  823. X
  824. X    if (!nroom) return; /* Should never happen */
  825. X    croom = &rooms[rn2(nroom)];
  826. X    x = somex(croom); y = somey(croom);
  827. X    if (!(ghost = makemon(&mons[PM_GHOST], x, y)))
  828. X        return;
  829. X    ghost->msleep = 1;
  830. X    Strcpy((char *)ghost->mextra, roguename());
  831. X
  832. X    if (rn2(4)) {
  833. X        ghostobj = mksobj_at(FOOD_RATION,x,y,FALSE);
  834. X        ghostobj->quan = (long) rnd(7);
  835. X        ghostobj->owt = weight(ghostobj);
  836. X    }
  837. X    if (rn2(2)) {
  838. X        ghostobj = mksobj_at(MACE,x,y,FALSE);
  839. X        ghostobj->spe = rnd(3);
  840. X        if (rn2(4)) curse(ghostobj);
  841. X    } else {
  842. X        ghostobj = mksobj_at(TWO_HANDED_SWORD,x,y,FALSE);
  843. X        ghostobj->spe = rnd(5) - 2;
  844. X        if (rn2(4)) curse(ghostobj);
  845. X    }
  846. X    ghostobj = mksobj_at(BOW,x,y,FALSE);
  847. X    ghostobj->spe = 1;
  848. X    if (rn2(4)) curse(ghostobj);
  849. X
  850. X    ghostobj = mksobj_at(ARROW,x,y,FALSE);
  851. X    ghostobj->spe = 0;
  852. X    ghostobj->quan = (long) rn1(10,25);
  853. X    ghostobj->owt = weight(ghostobj);
  854. X    if (rn2(4)) curse(ghostobj);
  855. X
  856. X    if (rn2(2)) {
  857. X        ghostobj = mksobj_at(RING_MAIL,x,y,FALSE);
  858. X        ghostobj->spe = rn2(3);
  859. X        if (!rn2(3)) ghostobj->oerodeproof = TRUE;
  860. X        if (rn2(4)) curse(ghostobj);
  861. X    } else {
  862. X        ghostobj = mksobj_at(PLATE_MAIL,x,y,FALSE);
  863. X        ghostobj->spe = rnd(5) - 2;
  864. X        if (!rn2(3)) ghostobj->oerodeproof = TRUE;
  865. X        if (rn2(4)) curse(ghostobj);
  866. X    }
  867. X    if (rn2(2)) {
  868. X        ghostobj = mksobj_at(FAKE_AMULET_OF_YENDOR,x,y,TRUE);
  869. X        ghostobj->known = TRUE;
  870. X    }
  871. X}
  872. X#endif /* REINCARNATION /**/
  873. X
  874. X/*extralev.c*/
  875. END_OF_FILE
  876. if test 8664 -ne `wc -c <'src/extralev.c'`; then
  877.     echo shar: \"'src/extralev.c'\" unpacked with wrong size!
  878. fi
  879. # end of 'src/extralev.c'
  880. fi
  881. if test -f 'src/mplayer.c' -a "${1}" != "-c" ; then 
  882.   echo shar: Will not clobber existing file \"'src/mplayer.c'\"
  883. else
  884. echo shar: Extracting \"'src/mplayer.c'\" \(8151 characters\)
  885. sed "s/^X//" >'src/mplayer.c' <<'END_OF_FILE'
  886. X/*    SCCS Id: @(#)mplayer.c    3.1    92/10/28    */
  887. X/*    Copyright (c) Izchak Miller, 1992.              */
  888. X/* NetHack may be freely redistributed.  See license for details. */
  889. X
  890. X#include "hack.h"
  891. X
  892. Xstatic const char *NDECL(dev_name);
  893. Xstatic void FDECL(get_mplname, (struct monst *, char *));
  894. Xstatic void FDECL(mk_mplayer_armor, (struct monst *, int, int));
  895. X
  896. X/* These are the names of those who
  897. X * contributed to the development of NetHack 3.1.
  898. X *
  899. X * Keep in alphabetical order within teams.
  900. X * Same first name is entered once within each team.
  901. X */
  902. Xstatic const char *developers[] = {
  903. X    /* devteam */
  904. X    "Dave", "Dean", "Eric", "Izchak", "Janet", "Jessie",
  905. X    "Ken", "Kevin", "Matt", "Mike", "Pat", "Steve", "Timo",
  906. X    /* PC team */
  907. X    "Bill", "Carl", "John", "Kevin", "Mike", "Norm", "Paul",
  908. X    "Stephen", "Steve",
  909. X    /* Amiga team */
  910. X    "Greg", "Gregg", "Keni", "Mike", "Olaf", "Richard",
  911. X    /* Mac team */
  912. X    "David", "Johnny", "Jon", "Jonathan", "Michael", "Rob",
  913. X    "Tim", "Wang",
  914. X    /* OS/2 team */
  915. X    "Timo",
  916. X    /* Atari team */
  917. X    "Eric",
  918. X    /* VMS team */
  919. X    "Joshua", "Pat",
  920. X    ""};
  921. X
  922. X
  923. X/* return a randomly chosen developer name */
  924. Xstatic const char *
  925. Xdev_name() 
  926. X{
  927. X    register int i, m = 0, n = SIZE(developers);
  928. X    register struct monst *mtmp;
  929. X    register boolean match;
  930. X
  931. X    do {
  932. X        match = FALSE;
  933. X        i = rn2(n);
  934. X        for (mtmp = fmon; mtmp; mtmp = mtmp->nmon) { 
  935. X        if(!is_mplayer(mtmp->data)) continue;
  936. X        if(!strncmp(developers[i], NAME(mtmp),
  937. X                           strlen(developers[i]))) {
  938. X            match = TRUE;
  939. X            break;
  940. X            }
  941. X        }
  942. X        m++;
  943. X    } while (match && m < 100); /* m for insurance */
  944. X
  945. X    if (match) return NULL;
  946. X    return(developers[i]);
  947. X}
  948. X
  949. Xstatic void
  950. Xget_mplname(mtmp, nam)
  951. Xregister struct monst *mtmp;
  952. Xchar *nam;
  953. X{
  954. X    boolean fmlkind = is_female(mtmp->data);
  955. X    const char *devnam;
  956. X
  957. X    devnam = dev_name();
  958. X    if (!devnam)
  959. X        Strcpy(nam, fmlkind ? "Eve" : "Adam");
  960. X    else if (fmlkind && !!strcmp(devnam, "Janet"))
  961. X        Strcpy(nam, rn2(2) ? "Maud" : "Eve");
  962. X    else Strcpy(nam, devnam);
  963. X
  964. X    if (fmlkind || !strcmp(nam, "Janet"))
  965. X        mtmp->female = 1;
  966. X    else
  967. X        mtmp->female = 0;
  968. X    Strcat(nam, " the ");
  969. X    Strcat(nam, rank_of((unsigned)rn1(12, 20), 
  970. X               highc(mtmp->data->mname[0]), (boolean)mtmp->female));
  971. X}
  972. X
  973. Xstatic void
  974. Xmk_mplayer_armor(mon, range1, range2)
  975. Xstruct monst *mon;
  976. Xint range1, range2;
  977. X{
  978. X    struct obj *obj;
  979. X
  980. X    obj = mksobj(rnd_class(range1, range2), FALSE, FALSE);
  981. X    if (!rn2(3)) obj->oerodeproof = 1;
  982. X    if (!rn2(3)) curse(obj);
  983. X    if (!rn2(3)) bless(obj);
  984. X    /* Most players who get to the endgame who have cursed equipment
  985. X     * have it because the wizard or other monsters cursed it, so its
  986. X     * chances of having plusses is the same as usual....
  987. X     */
  988. X    obj->spe = rn2(10) ? (rn2(3) ? rn2(5) : rn1(4,4)) : -rnd(3);
  989. X    mpickobj(mon, obj);
  990. X}
  991. X
  992. Xstruct monst *
  993. Xmk_mplayer(ptr, x, y, special)
  994. Xregister struct permonst *ptr;
  995. Xxchar x, y;
  996. Xregister boolean special;
  997. X{
  998. X    register struct monst *mtmp;
  999. X    char nam[PL_NSIZ];
  1000. X
  1001. X    if(!is_mplayer(ptr)) 
  1002. X        return((struct monst *)0);
  1003. X
  1004. X    if(MON_AT(x, y))
  1005. X        rloc(m_at(x, y)); /* insurance */
  1006. X
  1007. X    if(!In_endgame(&u.uz)) special = FALSE;
  1008. X
  1009. X    if ((mtmp = makemon(ptr, x, y)) != 0) {
  1010. X        int weapon, quan;
  1011. X        struct obj *otmp;
  1012. X
  1013. X        mtmp->m_lev = (special ? rn1(8,12) : rnd(16));
  1014. X        mtmp->mhp = mtmp->mhpmax = (special ?
  1015. X                          (d((int)mtmp->m_lev,10) + 30 + rnd(30)) :
  1016. X                          (d((int)mtmp->m_lev,10) + 30));
  1017. X        if(special) {
  1018. X            get_mplname(mtmp, nam);
  1019. X            mtmp = christen_monst(mtmp, nam);
  1020. X        }
  1021. X        mtmp->mpeaceful = 0;
  1022. X        set_malign(mtmp); /* peaceful may have changed again */
  1023. X        if(special && In_endgame(&u.uz))
  1024. X        /* that's why they are "stuck" in the endgame :-) */
  1025. X        (void)mongets(mtmp, FAKE_AMULET_OF_YENDOR);
  1026. X        switch(monsndx(ptr)) {
  1027. X        case PM_ARCHEOLOGIST:
  1028. X            weapon = BULLWHIP;
  1029. X            break;
  1030. X        case PM_BARBARIAN:
  1031. X            weapon = rn2(2) ? TWO_HANDED_SWORD : BATTLE_AXE;
  1032. X            break;
  1033. X        case PM_CAVEMAN:
  1034. X        case PM_CAVEWOMAN:
  1035. X            weapon = CLUB;
  1036. X            break;
  1037. X        case PM_ELF:
  1038. X            weapon = ELVEN_SHORT_SWORD;
  1039. X            break;
  1040. X        case PM_HEALER:
  1041. X            weapon = SCALPEL;
  1042. X            break;
  1043. X        case PM_KNIGHT:
  1044. X            weapon = LONG_SWORD;
  1045. X            break;
  1046. X        case PM_PRIEST:
  1047. X        case PM_PRIESTESS:
  1048. X            weapon = MACE;
  1049. X            break;
  1050. X        case PM_ROGUE:
  1051. X            weapon = SHORT_SWORD;
  1052. X            break;
  1053. X        case PM_SAMURAI:
  1054. X            weapon = KATANA;
  1055. X            break;
  1056. X#ifdef TOURIST
  1057. X        case PM_TOURIST:
  1058. X            weapon = 0;
  1059. X            break;
  1060. X#endif
  1061. X        case PM_VALKYRIE:
  1062. X            weapon = LONG_SWORD;
  1063. X            break;
  1064. X        case PM_WIZARD:
  1065. X            weapon = ATHAME;
  1066. X            break;
  1067. X        default: impossible("bad mplayer monster");
  1068. X            weapon = 0;
  1069. X            break;
  1070. X        }
  1071. X        if (rn2(2) && weapon)
  1072. X        otmp = mksobj(weapon, TRUE, FALSE);
  1073. X        else
  1074. X        otmp = mksobj(rn2(2) ? LONG_SWORD : 
  1075. X                  rnd_class(SPEAR, BULLWHIP), TRUE, FALSE);
  1076. X        otmp->spe = (special ? rn1(5,4) : rn2(4));
  1077. X        if (!rn2(3)) otmp->oerodeproof = 0;
  1078. X        if(special) {
  1079. X            /* probably the player got most artifacts anyway. */
  1080. X            if(In_endgame(&u.uz) && rn2(2)) 
  1081. X                  otmp = mk_artifact(otmp, A_NONE);
  1082. X            mpickobj(mtmp, otmp);
  1083. X            if (!rn2(10))
  1084. X            (void) mongets(mtmp, rn2(3) ? LUCKSTONE : LOADSTONE);
  1085. X            if (rn2(8))
  1086. X            mk_mplayer_armor(mtmp, ELVEN_LEATHER_HELM, HELM_OF_TELEPATHY);
  1087. X            if (!rn2(3))
  1088. X            mk_mplayer_armor(mtmp, GRAY_DRAGON_SCALE_MAIL,
  1089. X            YELLOW_DRAGON_SCALE_MAIL);
  1090. X            else if (rn2(15))
  1091. X            mk_mplayer_armor(mtmp, PLATE_MAIL, CHAIN_MAIL);
  1092. X            if (rn2(8))
  1093. X            mk_mplayer_armor(mtmp, ELVEN_SHIELD, 
  1094. X                               SHIELD_OF_REFLECTION);
  1095. X            if (rn2(8))
  1096. X            mk_mplayer_armor(mtmp, LEATHER_GLOVES, 
  1097. X                               GAUNTLETS_OF_DEXTERITY);
  1098. X            if (rn2(8))
  1099. X            mk_mplayer_armor(mtmp, LOW_BOOTS, LEVITATION_BOOTS);
  1100. X#ifdef MUSE
  1101. X            /* Not clear what to do without MUSE. */
  1102. X            m_dowear(mtmp, TRUE);
  1103. X#endif
  1104. X            quan = rn2(3) ? rn2(3) : rn2(16);
  1105. X            while(quan--)
  1106. X            (void)mongets(mtmp, rnd_class(DILITHIUM_CRYSTAL, JADE));
  1107. X            /* To get the gold "right" would mean a player can double his */
  1108. X            /* gold supply by killing one mplayer.  Not good. */
  1109. X            mtmp->mgold = rn2(1000);
  1110. X            quan = rn2(10);
  1111. X            while(quan--)
  1112. X            mpickobj(mtmp, mkobj(RANDOM_CLASS, FALSE));
  1113. X        }
  1114. X#ifdef MUSE
  1115. X        quan = rnd(3);
  1116. X        while(quan--)
  1117. X        (void)mongets(mtmp, rnd_offensive_item(mtmp));
  1118. X        quan = rnd(3);
  1119. X        while(quan--)
  1120. X        (void)mongets(mtmp, rnd_defensive_item(mtmp));
  1121. X        quan = rnd(3);
  1122. X        while(quan--)
  1123. X        (void)mongets(mtmp, rnd_misc_item(mtmp));
  1124. X#endif
  1125. X    }
  1126. X
  1127. X    return(mtmp);
  1128. X}
  1129. X
  1130. X/* create the indicated number (num) of monster-players,
  1131. X * randomly chosen, and in randomly chosen (free) locations
  1132. X * on the level.  If "special", the size of num should not
  1133. X * be bigger than the number of _non-repeated_ names in the
  1134. X * developers array, otherwise a bunch of Adams and Eves will
  1135. X * fill up the overflow.
  1136. X */
  1137. Xvoid
  1138. Xcreate_mplayers(num, special)
  1139. Xregister int num;
  1140. Xboolean special;
  1141. X{
  1142. X    register int pm, x, y;
  1143. X
  1144. X    while(num) {
  1145. X        int tryct = 0;
  1146. X
  1147. X        /* roll for character class */
  1148. X        pm = PM_ARCHEOLOGIST + rn2(PM_WIZARD - PM_ARCHEOLOGIST + 1);
  1149. X
  1150. X        /* roll for an available location */
  1151. X        do {
  1152. X            x = rn1(COLNO-4, 2);
  1153. X            y = rnd(ROWNO-2);
  1154. X        } while(!goodpos(x, y, (struct monst *)0, &mons[pm]) ||
  1155. X             tryct++ >= 50);
  1156. X
  1157. X        /* if pos not found in 50 tries, don't bother to continue */
  1158. X        if(tryct > 50) return;
  1159. X
  1160. X        (void) mk_mplayer(&mons[pm], (xchar)x, (xchar)y, special);
  1161. X        num--;
  1162. X    }
  1163. X}
  1164. X
  1165. Xvoid
  1166. Xmplayer_talk(mtmp)
  1167. Xregister struct monst *mtmp;
  1168. X{
  1169. X    char pbuf[BUFSZ];
  1170. X
  1171. X    if(mtmp->mpeaceful) return; /* will drop to humanoid talk */
  1172. X
  1173. X    Strcpy(pbuf, "Talk? -- ");
  1174. X    if(pl_character[0] == highc(*mtmp->data->mname)) { /* same kind */
  1175. X         switch(rn2(4)) {
  1176. X           case 0: Strcat(pbuf, "I can't win, and neither will you!");
  1177. X               break;
  1178. X           case 1: Strcat(pbuf, "You don't deserve to win!");
  1179. X               break;
  1180. X           case 3: Strcat(pbuf, "Mine should be the honor, not yours!");
  1181. X               break;
  1182. X         }
  1183. X    } else {
  1184. X         switch(rn2(4)) {
  1185. X           case 0: Strcat(pbuf, "The low-life wants to talk, eh?");
  1186. X               break;
  1187. X           case 1: Strcat(pbuf, "Fight, scum!");
  1188. X               break;
  1189. X           case 3: Strcat(pbuf, "Here is what I have to say!");
  1190. X               break;
  1191. X         }
  1192. X    }
  1193. X    pline(pbuf);
  1194. X}
  1195. X
  1196. X/*mplayer.c*/
  1197. END_OF_FILE
  1198. if test 8151 -ne `wc -c <'src/mplayer.c'`; then
  1199.     echo shar: \"'src/mplayer.c'\" unpacked with wrong size!
  1200. fi
  1201. # end of 'src/mplayer.c'
  1202. fi
  1203. if test -f 'src/wield.c' -a "${1}" != "-c" ; then 
  1204.   echo shar: Will not clobber existing file \"'src/wield.c'\"
  1205. else
  1206. echo shar: Extracting \"'src/wield.c'\" \(7935 characters\)
  1207. sed "s/^X//" >'src/wield.c' <<'END_OF_FILE'
  1208. X/*    SCCS Id: @(#)wield.c    3.1    92/12/10    */
  1209. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1210. X/* NetHack may be freely redistributed.  See license for details. */
  1211. X
  1212. X#include    "hack.h"
  1213. X
  1214. X/* elven weapons vibrate warningly when enchanted beyond a limit */
  1215. X#define is_elven_weapon(optr)    ((optr)->otyp == ELVEN_ARROW\
  1216. X                || (optr)->otyp == ELVEN_SPEAR\
  1217. X                || (optr)->otyp == ELVEN_DAGGER\
  1218. X                || (optr)->otyp == ELVEN_SHORT_SWORD\
  1219. X                || (optr)->otyp == ELVEN_BROADSWORD\
  1220. X                || (optr)->otyp == ELVEN_BOW)
  1221. X
  1222. X/* Note: setuwep() with a null obj, and uwepgone(), are NOT the same!  Sometimes
  1223. X * unwielding a weapon can kill you, and lifesaving will then put it back into
  1224. X * your hand.  If lifesaving is permitted to do this, use
  1225. X * setwuep((struct obj *)0); otherwise use uwepgone().
  1226. X */
  1227. Xvoid
  1228. Xsetuwep(obj)
  1229. Xregister struct obj *obj;
  1230. X{
  1231. X    setworn(obj, W_WEP);
  1232. X    /* Note: Explicitly wielding a pick-axe will not give a "bashing"
  1233. X     * message.  Wielding one via 'a'pplying it will.
  1234. X     */
  1235. X    if (obj)
  1236. X        unweapon = ((obj->otyp >= BOW || obj->otyp <= BOOMERANG) &&
  1237. X            obj->otyp != PICK_AXE && obj->otyp != UNICORN_HORN);
  1238. X    else
  1239. X        unweapon = TRUE;    /* for "bare hands" message */
  1240. X}
  1241. X
  1242. Xvoid
  1243. Xuwepgone()
  1244. X{
  1245. X    if (uwep) {
  1246. X        setnotworn(uwep);
  1247. X        unweapon = TRUE;
  1248. X    }
  1249. X}
  1250. X
  1251. Xstatic const char NEARDATA wield_objs[] =
  1252. X    { ALL_CLASSES, ALLOW_NONE, WEAPON_CLASS, TOOL_CLASS, 0 };
  1253. X
  1254. Xint
  1255. Xdowield()
  1256. X{
  1257. X    register struct obj *wep;
  1258. X    register int res = 0;
  1259. X
  1260. X    multi = 0;
  1261. X#ifdef POLYSELF
  1262. X    if (cantwield(uasmon)) {
  1263. X        pline("Don't be ridiculous!");
  1264. X        return(0);
  1265. X    }
  1266. X#endif
  1267. X    if (!(wep = getobj(wield_objs, "wield"))) /* nothing */;
  1268. X    else if (uwep == wep)
  1269. X        You("are already wielding that!");
  1270. X    else if (welded(uwep))
  1271. X        weldmsg(uwep, TRUE);
  1272. X    else if (wep == &zeroobj) {
  1273. X        if (uwep == 0)
  1274. X        You("are already empty %s.", body_part(HANDED));
  1275. X        else  {
  1276. X          You("are empty %s.", body_part(HANDED));
  1277. X          setuwep((struct obj *) 0);
  1278. X          res++;
  1279. X        }
  1280. X    } else if (!uarmg &&
  1281. X#ifdef POLYSELF
  1282. X           !resists_ston(uasmon) &&
  1283. X#endif
  1284. X           (wep->otyp == CORPSE && wep->corpsenm == PM_COCKATRICE)) {
  1285. X        /* Prevent wielding cockatrice when not wearing gloves --KAA */
  1286. X        You("wield the cockatrice corpse in your bare %s.",
  1287. X            makeplural(body_part(HAND)));
  1288. X# ifdef POLYSELF
  1289. X        if (!(poly_when_stoned(uasmon) && polymon(PM_STONE_GOLEM)))
  1290. X# endif
  1291. X        {
  1292. X        You("turn to stone...");
  1293. X        killer_format = KILLED_BY;
  1294. X        killer="touching a cockatrice corpse";
  1295. X        done(STONING);
  1296. X        }
  1297. X    } else if (uarms && bimanual(wep))
  1298. X        You("cannot wield a two-handed %s while wearing a shield.",
  1299. X        is_sword(wep) ? "sword" :
  1300. X            wep->otyp == BATTLE_AXE ? "axe" : "weapon");
  1301. X    else if (wep->owornmask & (W_ARMOR | W_RING | W_AMUL | W_TOOL))
  1302. X        You("cannot wield that!");
  1303. X    else if (!wep->oartifact || touch_artifact(wep,&youmonst)) {
  1304. X        res++;
  1305. X        if (wep->cursed &&
  1306. X            (wep->oclass == WEAPON_CLASS ||
  1307. X             wep->otyp == HEAVY_IRON_BALL || wep->otyp == PICK_AXE ||
  1308. X             wep->otyp == UNICORN_HORN || wep->otyp == TIN_OPENER)) {
  1309. X            const char *tmp = xname(wep), *thestr = "The ";
  1310. X            if (strncmp(tmp, thestr, 4) && !strncmp(The(tmp),thestr,4))
  1311. X            tmp = thestr;
  1312. X            else tmp = "";
  1313. X            pline("%s%s %s to your %s!",
  1314. X            tmp, aobjnam(wep, "weld"),
  1315. X            (wep->quan == 1L) ? "itself" : "themselves", /* a3 */
  1316. X            body_part(HAND));
  1317. X            wep->bknown = TRUE;
  1318. X        } else {
  1319. X            /* The message must be printed before setuwep (since
  1320. X             * you might die and be revived from changing weapons),
  1321. X             * and the message must be before the death message and
  1322. X             * Lifesaved rewielding.  Yet we want the message to
  1323. X             * say "weapon in hand", thus this kludge.
  1324. X             */
  1325. X            long dummy = wep->owornmask;
  1326. X            wep->owornmask |= W_WEP;
  1327. X            prinv(NULL, wep, 0L);
  1328. X            wep->owornmask = dummy;
  1329. X        }
  1330. X        setuwep(wep);
  1331. X    }
  1332. X    return(res);
  1333. X}
  1334. X
  1335. Xvoid
  1336. Xerode_weapon(acid_dmg)
  1337. Xboolean acid_dmg;
  1338. X/* Rust weapon, or corrode it if acid damage is called for */
  1339. X{
  1340. X    if(!uwep || uwep->oclass != WEAPON_CLASS) return;    /* %% */
  1341. X    if (uwep->greased) {
  1342. X        grease_protect(uwep,NULL,FALSE);
  1343. X    } else if(uwep->oerodeproof ||
  1344. X       (acid_dmg ? !is_corrodeable(uwep) : !is_rustprone(uwep))) {
  1345. X        if (flags.verbose || !(uwep->oerodeproof && uwep->rknown))
  1346. X            Your("%s not affected.", aobjnam(uwep, "are"));
  1347. X        if (uwep->oerodeproof) uwep->rknown = TRUE;
  1348. X    } else if (uwep->oeroded < MAX_ERODE) {
  1349. X        Your("%s%s!", aobjnam(uwep, acid_dmg ? "corrode" : "rust"),
  1350. X             uwep->oeroded+1 == MAX_ERODE ? " completely" :
  1351. X             uwep->oeroded ? " further" : "");
  1352. X        uwep->oeroded++;
  1353. X    } else
  1354. X        if (flags.verbose)
  1355. X            Your("%s completely %s.",
  1356. X             aobjnam(uwep, Blind ? "feel" : "look"),
  1357. X             acid_dmg ? "corroded" : "rusty");
  1358. X}
  1359. X
  1360. Xint
  1361. Xchwepon(otmp, amount)
  1362. Xregister struct obj *otmp;
  1363. Xregister int amount;
  1364. X{
  1365. X    register const char *color = Hallucination ? hcolor() :
  1366. X                     (amount < 0) ? Black : blue;
  1367. X    register const char *xtime;
  1368. X
  1369. X    if(!uwep || (uwep->oclass != WEAPON_CLASS && uwep->otyp != PICK_AXE
  1370. X            && uwep->otyp != UNICORN_HORN)) {
  1371. X        char buf[36];
  1372. X
  1373. X        Sprintf(buf, "Your %s %s.", makeplural(body_part(HAND)),
  1374. X            (amount >= 0) ? "twitch" : "itch");
  1375. X        strange_feeling(otmp, buf);
  1376. X        exercise(A_DEX, amount >= 0);
  1377. X        return(0);
  1378. X    }
  1379. X
  1380. X    if(uwep->otyp == WORM_TOOTH && amount >= 0) {
  1381. X        uwep->otyp = CRYSKNIFE;
  1382. X        Your("weapon seems sharper now.");
  1383. X        uwep->cursed = 0;
  1384. X        return(1);
  1385. X    }
  1386. X
  1387. X    if(uwep->otyp == CRYSKNIFE && amount < 0) {
  1388. X        uwep->otyp = WORM_TOOTH;
  1389. X        Your("weapon seems duller now.");
  1390. X        return(1);
  1391. X    }
  1392. X
  1393. X    if (amount < 0 && uwep->oartifact && restrict_name(uwep, ONAME(uwep))) {
  1394. X        if (!Blind)
  1395. X        Your("%s %s.", aobjnam(uwep, "faintly glow"), color);
  1396. X        return(1);
  1397. X    }
  1398. X    /* there is a (soft) upper and lower limit to uwep->spe */
  1399. X    if(((uwep->spe > 5 && amount >= 0) || (uwep->spe < -5 && amount < 0))
  1400. X                                && rn2(3)) {
  1401. X        if (!Blind)
  1402. X        Your("%s %s for a while and then evaporate%s.",
  1403. X         aobjnam(uwep, "violently glow"), color,
  1404. X         uwep->quan == 1L ? "s" : "");
  1405. X        else
  1406. X        Your("%s.", aobjnam(uwep, "evaporate"));
  1407. X
  1408. X        while(uwep)        /* let all of them disappear */
  1409. X                /* note: uwep->quan = 1 is nogood if unpaid */
  1410. X        useup(uwep);
  1411. X        return(1);
  1412. X    }
  1413. X    if (!Blind) {
  1414. X        xtime = (amount*amount == 1) ? "moment" : "while";
  1415. X        Your("%s %s for a %s.",
  1416. X         aobjnam(uwep, amount == 0 ? "violently glow" : "glow"),
  1417. X         color, xtime);
  1418. X    }
  1419. X    uwep->spe += amount;
  1420. X    if(amount > 0) uwep->cursed = 0;
  1421. X
  1422. X    /*
  1423. X     * Enchantment, which normally improves a weapon, has an
  1424. X     * addition adverse reaction on Magicbane whose effects are
  1425. X     * spe dependent.  Give an obscure clue here.
  1426. X     */
  1427. X    if (uwep->oartifact == ART_MAGICBANE && uwep->spe >= 0) {
  1428. X        Your("right %s %sches!",
  1429. X            body_part(HAND),
  1430. X            (((amount > 1) && (uwep->spe > 1)) ? "flin" : "it"));
  1431. X    }
  1432. X
  1433. X    /* an elven magic clue, cookie@keebler */
  1434. X    if ((uwep->spe > 5)
  1435. X        && (is_elven_weapon(uwep) || uwep->oartifact || !rn2(7)))
  1436. X        Your("%s unexpectedly.",
  1437. X        aobjnam(uwep, "suddenly vibrate"));
  1438. X
  1439. X    return(1);
  1440. X}
  1441. X
  1442. Xint
  1443. Xwelded(obj)
  1444. Xregister struct obj *obj;
  1445. X{
  1446. X    if (obj && obj == uwep && obj->cursed &&
  1447. X          (obj->oclass == WEAPON_CLASS ||
  1448. X           obj->otyp == HEAVY_IRON_BALL ||
  1449. X           obj->otyp == TIN_OPENER || obj->otyp == PICK_AXE ||
  1450. X           obj->otyp == UNICORN_HORN))
  1451. X    {
  1452. X        obj->bknown = TRUE;
  1453. X        return 1;
  1454. X    }
  1455. X    return 0;
  1456. X}
  1457. X
  1458. X/* The reason for "specific" is historical; some parts of the code used
  1459. X * the object name and others just used "weapon"/"sword".  This function
  1460. X * replaced all of those.  Which one we use is really arbitrary.
  1461. X */
  1462. Xvoid
  1463. Xweldmsg(obj, specific)
  1464. Xregister struct obj *obj;
  1465. Xboolean specific;
  1466. X{
  1467. X    char buf[BUFSZ];
  1468. X
  1469. X    if (specific) {
  1470. X        long savewornmask = obj->owornmask;
  1471. X        obj->owornmask &= ~W_WEP;
  1472. X        Strcpy(buf, Doname2(obj));
  1473. X        obj->owornmask = savewornmask;
  1474. X    } else
  1475. X        Sprintf(buf, "Your %s%s",
  1476. X            is_sword(obj) ? "sword" : "weapon",
  1477. X            plur(obj->quan));
  1478. X    Strcat(buf, (obj->quan == 1L) ? " is" : " are");
  1479. X#ifdef POLYSELF
  1480. X    Sprintf(eos(buf), " welded to your %s!",
  1481. X        bimanual(obj) ? (const char *)makeplural(body_part(HAND)) : body_part(HAND));
  1482. X#else
  1483. X    Sprintf(eos(buf), " welded to your hand%s!",
  1484. X        bimanual(obj) ? "s" : "");
  1485. X#endif
  1486. X    pline(buf);
  1487. X}
  1488. X
  1489. X/*wield.c*/
  1490. END_OF_FILE
  1491. if test 7935 -ne `wc -c <'src/wield.c'`; then
  1492.     echo shar: \"'src/wield.c'\" unpacked with wrong size!
  1493. fi
  1494. # end of 'src/wield.c'
  1495. fi
  1496. if test -f 'sys/share/pcunix.c' -a "${1}" != "-c" ; then 
  1497.   echo shar: Will not clobber existing file \"'sys/share/pcunix.c'\"
  1498. else
  1499. echo shar: Extracting \"'sys/share/pcunix.c'\" \(2804 characters\)
  1500. sed "s/^X//" >'sys/share/pcunix.c' <<'END_OF_FILE'
  1501. X/*    SCCS Id: @(#)pcunix.c    3.1    90/22/02
  1502. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1503. X/* NetHack may be freely redistributed.  See license for details. */
  1504. X
  1505. X/* This file collects some Unix dependencies; pager.c contains some more */
  1506. X
  1507. X#include "hack.h"
  1508. X
  1509. X#include    <sys/stat.h>
  1510. X
  1511. X#ifdef OVLB
  1512. X
  1513. Xstatic struct stat buf;
  1514. X# ifdef WANT_GETHDATE
  1515. Xstatic struct stat hbuf;
  1516. X# endif
  1517. X
  1518. Xvoid
  1519. Xgethdate(name)
  1520. Xchar *name;
  1521. X{
  1522. X# ifdef WANT_GETHDATE
  1523. X/* old version - for people short of space */
  1524. X/*
  1525. X/* register char *np;
  1526. X/*      if(stat(name, &hbuf))
  1527. X/*          error("Cannot get status of %s.",
  1528. X/*              (np = rindex(name, '/')) ? np+1 : name);
  1529. X/*
  1530. X/* version using PATH from: seismo!gregc@ucsf-cgl.ARPA (Greg Couch) */
  1531. X
  1532. X/*
  1533. X * The problem with   #include  <sys/param.h> is that this include file
  1534. X * does not exist on all systems, and moreover, that it sometimes includes
  1535. X * <sys/types.h> again, so that the compiler sees these typedefs twice.
  1536. X */
  1537. X#define     MAXPATHLEN      1024
  1538. X
  1539. X    register char *np, *path;
  1540. X    char filename[MAXPATHLEN+1], *getenv();
  1541. X
  1542. X    if (index(name, '/') != NULL || (path = getenv("PATH")) == NULL)
  1543. X    path = "";
  1544. X
  1545. X    for (;;) {
  1546. X    if ((np = index(path, ':')) == NULL)
  1547. X        np = path + strlen(path);       /* point to end str */
  1548. X    if (np - path <= 1)             /* %% */
  1549. X        Strcpy(filename, name);
  1550. X    else {
  1551. X        (void) strncpy(filename, path, np - path);
  1552. X        filename[np - path] = '/';
  1553. X        Strcpy(filename + (np - path) + 1, name);
  1554. X    }
  1555. X    if (stat(filename, &hbuf) == 0)
  1556. X        return;
  1557. X    if (*np == '\0')
  1558. X    path = "";
  1559. X    path = np + 1;
  1560. X    }
  1561. X    error("Cannot get status of %s.", (np = rindex(name, '/')) ? np+1 : name);
  1562. X# endif /* WANT_GETHDATE */
  1563. X}
  1564. X
  1565. Xint
  1566. Xuptodate(fd)
  1567. Xint fd;
  1568. X{
  1569. X# ifdef WANT_GETHDATE
  1570. X    if(fstat(fd, &buf)) {
  1571. X    pline("Cannot get status of saved level? ");
  1572. X    return(0);
  1573. X    }
  1574. X    if(buf.st_mtime < hbuf.st_mtime) {
  1575. X    pline("Saved level is out of date. ");
  1576. X    return(0);
  1577. X    }
  1578. X# else
  1579. X#  if defined(MICRO) && !defined(NO_FSTAT)
  1580. X    if(fstat(fd, &buf)) {
  1581. X    if(moves > 1) pline("Cannot get status of saved level? ");
  1582. X    else pline("Cannot get status of saved game");
  1583. X    return(0);
  1584. X    } 
  1585. X    if(comp_times(buf.st_mtime)) { 
  1586. X    if(moves > 1) pline("Saved level is out of date");
  1587. X    else pline("Saved game is out of date. ");
  1588. X    return(0);
  1589. X    }
  1590. X#  endif  /* MICRO /* */
  1591. X# endif /* WANT_GETHDATE */
  1592. X    return(1);
  1593. X}
  1594. X
  1595. Xvoid
  1596. Xregularize(s)
  1597. X/*
  1598. X * normalize file name - we don't like .'s, /'s, spaces, and
  1599. X * lots of other things
  1600. X */
  1601. Xregister char *s;
  1602. X{
  1603. X    register char *lp;
  1604. X
  1605. X    for (lp = s; *lp; lp++)
  1606. X        if (*lp <= ' ' || *lp == '"' || (*lp >= '*' && *lp <= ',') ||
  1607. X            *lp == '.' || *lp == '/' || (*lp >= ':' && *lp <= '?') ||
  1608. X# ifdef OS2
  1609. X            *lp == '&' || *lp == '(' || *lp == ')' ||
  1610. X# endif
  1611. X            *lp == '|' || *lp >= 127 || (*lp >= '[' && *lp <= ']'))
  1612. X                        *lp = '_';
  1613. X}
  1614. X
  1615. X#endif /* OVLB */
  1616. END_OF_FILE
  1617. if test 2804 -ne `wc -c <'sys/share/pcunix.c'`; then
  1618.     echo shar: \"'sys/share/pcunix.c'\" unpacked with wrong size!
  1619. fi
  1620. # end of 'sys/share/pcunix.c'
  1621. fi
  1622. if test -f 'win/tty/topl.c' -a "${1}" != "-c" ; then 
  1623.   echo shar: Will not clobber existing file \"'win/tty/topl.c'\"
  1624. else
  1625. echo shar: Extracting \"'win/tty/topl.c'\" \(7994 characters\)
  1626. sed "s/^X//" >'win/tty/topl.c' <<'END_OF_FILE'
  1627. X/*    SCCS Id: @(#)topl.c    3.1    90/09/21
  1628. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1629. X/* NetHack may be freely redistributed.  See license for details. */
  1630. X
  1631. X#include "hack.h"
  1632. X#include "termcap.h"
  1633. X#include "wintty.h"
  1634. X#include <ctype.h>
  1635. X
  1636. XSTATIC_DCL void FDECL(redotoplin, (const char*));
  1637. XSTATIC_DCL void FDECL(topl_putsym, (CHAR_P));
  1638. XSTATIC_DCL void NDECL(remember_topl);
  1639. Xstatic void FDECL(removetopl, (int));
  1640. X
  1641. X#ifdef OVLB
  1642. X
  1643. Xint
  1644. Xtty_doprev_message()
  1645. X{
  1646. X    register struct WinDesc *cw = wins[WIN_MESSAGE];
  1647. X
  1648. X    if(cw->data[cw->maxcol])
  1649. X    redotoplin(cw->data[cw->maxcol]);
  1650. X    else if(cw->maxcol == cw->maxrow)
  1651. X    redotoplin(toplines);
  1652. X    cw->maxcol--;
  1653. X    if(cw->maxcol < 0) cw->maxcol = cw->rows-1;
  1654. X    if(!cw->data[cw->maxcol])
  1655. X    cw->maxcol = cw->maxrow;
  1656. X    return 0;
  1657. X}
  1658. X
  1659. X#endif /* OVLB */
  1660. X#ifdef OVL1
  1661. X
  1662. XSTATIC_OVL void
  1663. Xredotoplin(str)
  1664. X    const char *str;
  1665. X{
  1666. X    int otoplin = ttyDisplay->toplin;
  1667. X    home();
  1668. X    if(*str & 0x80) {
  1669. X        /* kludge for the / command, the only time we ever want a */
  1670. X        /* graphics character on the top line */
  1671. X        g_putch(*str++);
  1672. X        ttyDisplay->curx++;
  1673. X    }
  1674. X    end_glyphout();    /* in case message printed during graphics output */
  1675. X    putsyms(str);
  1676. X    cl_end();
  1677. X    ttyDisplay->toplin = 1;
  1678. X    if(ttyDisplay->cury && otoplin != 3)
  1679. X        more();
  1680. X}
  1681. X
  1682. XSTATIC_OVL void
  1683. Xremember_topl()
  1684. X{
  1685. X    register struct WinDesc *cw = wins[WIN_MESSAGE];
  1686. X
  1687. X    cw->data[cw->maxrow] = (char*) alloc(strlen(toplines)+1);
  1688. X    Strcpy(cw->data[cw->maxrow], toplines);
  1689. X    cw->maxcol = cw->maxrow = (cw->maxrow+1) % cw->rows;
  1690. X    if(cw->data[cw->maxrow]) {
  1691. X    free((genericptr_t)cw->data[cw->maxrow]);
  1692. X    cw->data[cw->maxrow] = 0;
  1693. X    }
  1694. X}
  1695. X
  1696. Xvoid
  1697. Xaddtopl(s)
  1698. Xconst char *s;
  1699. X{
  1700. X    register struct WinDesc *cw = wins[WIN_MESSAGE];
  1701. X
  1702. X    tty_curs(BASE_WINDOW,cw->curx+1,cw->cury);
  1703. X    if(cw->curx + (int)strlen(s) >= CO) topl_putsym('\n');
  1704. X    putsyms(s);
  1705. X    cl_end();
  1706. X    ttyDisplay->toplin = 1;
  1707. X}
  1708. X
  1709. X#endif /* OVL1 */
  1710. X#ifdef OVL2
  1711. X
  1712. Xvoid
  1713. Xmore()
  1714. X{
  1715. X    struct WinDesc *cw = wins[WIN_MESSAGE];
  1716. X
  1717. X    /* avoid recursion -- only happens from interrupts */
  1718. X    if(ttyDisplay->inmore++)
  1719. X    return;
  1720. X
  1721. X    if(ttyDisplay->toplin) {
  1722. X    tty_curs(BASE_WINDOW, cw->curx+1, cw->cury);
  1723. X    if(cw->curx >= CO - 8) topl_putsym('\n');
  1724. X    }
  1725. X
  1726. X    if(flags.standout)
  1727. X    standoutbeg();
  1728. X    putsyms(defmorestr);
  1729. X    if(flags.standout)
  1730. X    standoutend();
  1731. X
  1732. X    xwaitforspace("\033");
  1733. X
  1734. X    if(morc == '\033')
  1735. X    cw->flags |= WIN_STOP;
  1736. X
  1737. X    if(ttyDisplay->toplin && cw->cury) {
  1738. X    docorner(1, cw->cury+1);
  1739. X    cw->curx = cw->cury = 0;
  1740. X    home();
  1741. X    } else if(morc == '\033') {
  1742. X    cw->curx = cw->cury = 0;
  1743. X    home();
  1744. X    cl_end();
  1745. X    }
  1746. X    ttyDisplay->toplin = 0;
  1747. X    ttyDisplay->inmore = 0;
  1748. X}
  1749. X
  1750. Xvoid
  1751. Xupdate_topl(bp)
  1752. X    register const char *bp;
  1753. X{
  1754. X    register char *tl, *otl;
  1755. X    register int n0;
  1756. X    int notdied = 1;
  1757. X    struct WinDesc *cw = wins[WIN_MESSAGE];
  1758. X
  1759. X    /* If there is room on the line, print message on same line */
  1760. X    /* But messages like "You die..." deserve their own line */
  1761. X    n0 = strlen(bp);
  1762. X    if(ttyDisplay->toplin == 1 && cw->cury == 0 &&
  1763. X        n0 + (int)strlen(toplines) + 3 < CO-8 &&  /* room for --More-- */
  1764. X        (notdied = strncmp(bp, "You die", 7))) {
  1765. X        Strcat(toplines, "  ");
  1766. X        Strcat(toplines, bp);
  1767. X        cw->curx += 2;
  1768. X        if(!(cw->flags & WIN_STOP))
  1769. X            addtopl(bp);
  1770. X        return;
  1771. X    } else if(!(cw->flags & WIN_STOP)) {
  1772. X        if(ttyDisplay->toplin == 1) more();
  1773. X        else if(cw->cury) {    /* for when flags.toplin == 2 && cury > 1 */
  1774. X        docorner(1, cw->cury+1); /* reset cury = 0 if redraw screen */
  1775. X        cw->curx = cw->cury = 0;/* from home--cls() & docorner(1,n) */
  1776. X        }
  1777. X    }
  1778. X    remember_topl();
  1779. X    Strcpy(toplines, bp);
  1780. X    for(tl = toplines; n0 >= CO; ){
  1781. X        otl = tl;
  1782. X        for(tl+=CO-1; tl != otl && !isspace(*tl); --tl) ;
  1783. X        if(tl == otl) {
  1784. X        /* Eek!  A huge token.  Try splitting after it. */
  1785. X        tl = index(otl, ' ');
  1786. X        if (!tl) break;    /* No choice but to spit it out whole. */
  1787. X        }
  1788. X        *tl++ = '\n';
  1789. X        n0 = strlen(tl);
  1790. X    }
  1791. X    if(!notdied) cw->flags &= ~WIN_STOP;
  1792. X    if(!(cw->flags & WIN_STOP)) redotoplin(toplines);
  1793. X}
  1794. X
  1795. XSTATIC_OVL
  1796. Xvoid
  1797. Xtopl_putsym(c)
  1798. X    char c;
  1799. X{
  1800. X    register struct WinDesc *cw = wins[WIN_MESSAGE];
  1801. X
  1802. X    if(cw == (struct WinDesc *) 0) panic("Putsym window MESSAGE nonexistant");
  1803. X    
  1804. X    switch(c) {
  1805. X    case '\b':
  1806. X    if(ttyDisplay->curx == 0 && ttyDisplay->cury > 0)
  1807. X        tty_curs(BASE_WINDOW, CO, (int)ttyDisplay->cury-1);
  1808. X    backsp();
  1809. X    ttyDisplay->curx--;
  1810. X    cw->curx = ttyDisplay->curx;
  1811. X    return;
  1812. X    case '\n':
  1813. X    cl_end();
  1814. X    ttyDisplay->curx = 0;
  1815. X    ttyDisplay->cury++;
  1816. X    cw->cury = ttyDisplay->cury;
  1817. X    break;
  1818. X    default:
  1819. X    if(ttyDisplay->curx == CO-1)
  1820. X        topl_putsym('\n'); /* 1 <= curx <= CO; avoid CO */
  1821. X    ttyDisplay->curx++;
  1822. X    }
  1823. X    cw->curx = ttyDisplay->curx;
  1824. X    if(cw->curx == 0) cl_end();
  1825. X    (void) putchar(c);
  1826. X}
  1827. X
  1828. Xvoid
  1829. Xputsyms(str)
  1830. X    const char *str;
  1831. X{
  1832. X    while(*str)
  1833. X    topl_putsym(*str++);
  1834. X}
  1835. X
  1836. Xstatic void
  1837. Xremovetopl(n)
  1838. Xregister int n;
  1839. X{
  1840. X    /* assume addtopl() has been done, so ttyDisplay->toplin is already set */
  1841. X    while (n-- > 0) putsyms("\b \b");
  1842. X}
  1843. X
  1844. Xextern char erase_char;        /* from xxxtty.c; don't need kill_char */
  1845. X
  1846. Xchar
  1847. Xtty_yn_function(query,resp, def)
  1848. Xconst char *query,*resp;
  1849. Xchar def;
  1850. X/*
  1851. X *   Generic yes/no function. 'def' is the default (returned by space or
  1852. X *   return; 'esc' returns 'q', or 'n', or the default, depending on
  1853. X *   what's in the string. The 'query' string is printed before the user
  1854. X *   is asked about the string.
  1855. X *   If resp is NULL, any single character is accepted and returned.
  1856. X */
  1857. X{
  1858. X    register char q;
  1859. X    char rtmp[40];
  1860. X    boolean digit_ok, allow_num;
  1861. X    struct WinDesc *cw = wins[WIN_MESSAGE];
  1862. X    boolean doprev = 0;
  1863. X    char prompt[QBUFSZ];
  1864. X
  1865. X    if(ttyDisplay->toplin == 1 && !(cw->flags & WIN_STOP)) more();
  1866. X    cw->flags &= ~WIN_STOP;
  1867. X    ttyDisplay->toplin = 3; /* special prompt state */
  1868. X    ttyDisplay->inread++;
  1869. X    if(resp) {
  1870. X        allow_num = (index(resp, '#') != 0);
  1871. X        if(def)
  1872. X        Sprintf(prompt, "%s [%s] (%c) ", query, resp, def);
  1873. X        else
  1874. X        Sprintf(prompt, "%s [%s] ", query, resp);
  1875. X        pline("%s", prompt);
  1876. X    } else {
  1877. X        pline("%s ", query);
  1878. X        q = readchar();
  1879. X        goto clean_up;
  1880. X    }
  1881. X
  1882. X    do {    /* loop until we get valid input */
  1883. X        q = lowc(readchar());
  1884. X        if (q == '\020') { /* ctrl-P */
  1885. X        if(!doprev) (void) tty_doprev_message(); /* need two initially */
  1886. X        (void) tty_doprev_message();
  1887. X        q = (char)0;
  1888. X        doprev = 1;
  1889. X        continue;
  1890. X        } else if(doprev) {
  1891. X        tty_clear_nhwindow(WIN_MESSAGE);
  1892. X        cw->maxcol = cw->maxrow;
  1893. X        doprev = 0;
  1894. X        addtopl(prompt);
  1895. X        continue;
  1896. X        }
  1897. X        digit_ok = allow_num && digit(q);
  1898. X        if (q == '\033') {
  1899. X        if (index(resp, 'q'))
  1900. X            q = 'q';
  1901. X        else if (index(resp, 'n'))
  1902. X            q = 'n';
  1903. X        else
  1904. X            q = def;
  1905. X        break;
  1906. X        } else if (index(quitchars, q)) {
  1907. X        q = def;
  1908. X        break;
  1909. X        }
  1910. X        if (!index(resp, q) && !digit_ok) {
  1911. X        tty_nhbell();
  1912. X        q = (char)0;
  1913. X        } else if (q == '#' || digit_ok) {
  1914. X        char z, digit_string[2];
  1915. X        int n_len = 0;
  1916. X        long value = 0;
  1917. X        addtopl("#"),  n_len++;
  1918. X        digit_string[1] = '\0';
  1919. X        if (q != '#') {
  1920. X            digit_string[0] = q;
  1921. X            addtopl(digit_string),  n_len++;
  1922. X            value = q - '0';
  1923. X            q = '#';
  1924. X        }
  1925. X        do {    /* loop until we get a non-digit */
  1926. X            z = lowc(readchar());
  1927. X            if (digit(z)) {
  1928. X            value = (10 * value) + (z - '0');
  1929. X            if (value < 0) break;    /* overflow: try again */
  1930. X            digit_string[0] = z;
  1931. X            addtopl(digit_string),  n_len++;
  1932. X            } else if (z == 'y' || index(quitchars, z)) {
  1933. X            if (z == '\033')  value = -1;    /* abort */
  1934. X            z = '\n';    /* break */
  1935. X            } else if (z == erase_char || z == '\b') {
  1936. X            if (n_len <= 1) { value = -1;  break; }
  1937. X            else { value /= 10;  removetopl(1),  n_len--; }
  1938. X            } else {
  1939. X            value = -1;    /* abort */
  1940. X            tty_nhbell();
  1941. X            break;
  1942. X            }
  1943. X        } while (z != '\n');
  1944. X        if (value > 0) yn_number = value;
  1945. X        else if (value == 0) q = 'n';        /* 0 => "no" */
  1946. X        else {    /* remove number from top line, then try again */
  1947. X            removetopl(n_len),  n_len = 0;
  1948. X            q = '\0';
  1949. X        }
  1950. X        }
  1951. X    } while(!q);
  1952. X
  1953. X    if (q != '#') {
  1954. X        Sprintf(rtmp, "%c", q);
  1955. X        addtopl(rtmp);
  1956. X    }
  1957. X    clean_up:
  1958. X    ttyDisplay->inread--;
  1959. X    ttyDisplay->toplin = 2;
  1960. X    if(wins[WIN_MESSAGE]->cury)
  1961. X        tty_clear_nhwindow(WIN_MESSAGE);
  1962. X
  1963. X    return q;
  1964. X}
  1965. X
  1966. X#endif /* OVL2 */
  1967. X
  1968. X/*topl.c*/
  1969. END_OF_FILE
  1970. if test 7994 -ne `wc -c <'win/tty/topl.c'`; then
  1971.     echo shar: \"'win/tty/topl.c'\" unpacked with wrong size!
  1972. fi
  1973. # end of 'win/tty/topl.c'
  1974. fi
  1975. echo shar: End of archive 96 \(of 108\).
  1976. cp /dev/null ark96isdone
  1977. MISSING=""
  1978. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 \
  1979. 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 \
  1980. 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 \
  1981. 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 \
  1982. 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 \
  1983. 101 102 103 104 105 106 107 108 ; do
  1984.     if test ! -f ark${I}isdone ; then
  1985.     MISSING="${MISSING} ${I}"
  1986.     fi
  1987. done
  1988. if test "${MISSING}" = "" ; then
  1989.     echo You have unpacked all 108 archives.
  1990.     echo "Now execute 'rebuild.sh'"
  1991.     rm -f ark10[0-8]isdone ark[1-9]isdone ark[1-9][0-9]isdone
  1992. else
  1993.     echo You still need to unpack the following archives:
  1994.     echo "        " ${MISSING}
  1995. fi
  1996. ##  End of shell archive.
  1997. exit 0
  1998.