home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #18 / NN_1992_18.iso / spool / comp / sources / games / 166 < prev    next >
Encoding:
Internet Message Format  |  1992-08-20  |  56.1 KB
  1. Path: sparky!uunet!zephyr.ens.tek.com!master!saab!billr
  2. From: billr@saab.CNA.TEK.COM (Bill Randle)
  3. Newsgroups: comp.sources.games
  4. Subject: v14i036:  umoria4 - single player dungeon simulation (ver. 5.5), Part04/39
  5. Message-ID: <3394@master.CNA.TEK.COM>
  6. Date: 20 Aug 92 18:02:29 GMT
  7. Sender: news@master.CNA.TEK.COM
  8. Lines: 2285
  9. Approved: billr@saab.CNA.TEK.COM
  10.  
  11. Submitted-by: grabiner@math.harvard.edu (David Grabiner)
  12. Posting-number: Volume 14, Issue 36
  13. Archive-name: umoria4/Part04
  14. Supersedes: umoria3: Volume 9, Issue 55-97; Volume 10, Issue 15-17
  15. Environment: Curses, Unix, Mac, MS-DOS, Atari-ST, Amiga, VMS
  16.  
  17.  
  18.  
  19. #! /bin/sh
  20. # This is a shell archive.  Remove anything before this line, then unpack
  21. # it by saving it into a file and typing "sh file".  To overwrite existing
  22. # files, type "sh file -c".  You can also feed this as standard input via
  23. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  24. # will see the following message at the end:
  25. #        "End of archive 4 (of 39)."
  26. # Contents:  atari_st/curscomp/curses.txt source/dungeon.c
  27. # Wrapped by billr@saab on Thu Aug 20 09:11:26 1992
  28. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  29. if test -f 'atari_st/curscomp/curses.txt' -a "${1}" != "-c" ; then 
  30.   echo shar: Will not clobber existing file \"'atari_st/curscomp/curses.txt'\"
  31. else
  32. echo shar: Extracting \"'atari_st/curscomp/curses.txt'\" \(2869 characters\)
  33. sed "s/^X//" >'atari_st/curscomp/curses.txt' <<'END_OF_FILE'
  34. XCURSES.TXT - some documentation for ST-Curses.
  35. X
  36. XThis text should come together with three other files :
  37. X  CURSES.C  - C code for the ST-Curses package
  38. X  CURSES.H  - include file for programs using curses
  39. X  CURSINC.H - include file for CURSES.C
  40. X  
  41. XCurses is a computer and terminal-independent screen package for character-
  42. Xbased programs. Curses originated in the UNIX world and many programs written
  43. Xfor UNIX require a version of curses. This is ST-curses, a port of Curses for
  44. Xthe Atari ST in monochrome or medium resolution. This text has been written by
  45. XHildo Biersma (address below), but I did not originally write the ST-Curses
  46. Xpackage. However, I did an almost complete rewrite for reasons of clarity and
  47. Xspeed; I am therefore including some documentation with it, too.
  48. X
  49. XThis version was written for use with Turbo-C 2.0; some changes may be needed
  50. Xif you intend to use it with Mark Williams C, GNU C or other compiler.
  51. XThroughout all of the code in CURSES.C I have included a number of comments that
  52. Xshould make the code understandable and therefore (I hope) maintainable.
  53. XYou should take special notice of the explanation of the *WINDOW data structure
  54. Xthat appears as a header in CURSES.C.
  55. X
  56. XST-Curses was originally written by :
  57. X  Rene van't Veen
  58. X  Debussystraat 27
  59. X  1817 GL Alkmaar
  60. X  The Netherlands
  61. Xwhom I do not personally know. Thanks, Rene.
  62. X
  63. XRene made ST-Curses available as a shareware program. That is, you can use it
  64. Xfor own programs as long as you do not remove the copyright. For commercial use
  65. Xyou are supposed to make a donation of US $5 or equivalent. Please read the
  66. Xheader in CURSES.C for more details. Also note that the copyright remains with
  67. XRene, even though the code has been extensively modified by me.
  68. X
  69. XSome bugs may remain in the code; especially the wgetstr routine looks suspect.
  70. XI used ST-Curses in a version of the game Moria and can assure you that all
  71. Xroutines used by Moria work fine. Modifications to the code have mostly been to
  72. Xuse pointers and more pointers instead of array dereferencing. The net result
  73. Xhas been that the compiled code is some 200 bytes smaller and, depending on the 
  74. Xroutine, 2 through 10 times faster. I also ensured that the routine type (void,
  75. Xinteger etc) was more in line with the original ('real') UNIX curses. For an
  76. Xidea of what I've done, I included the old version of the routine wrefresh()
  77. Xalong with the new code (commented out in CURSES.C).
  78. X
  79. XPlease note that I do not take any responsibility for this code. It may or may
  80. Xnot contain any bugs; it may or may not have been optimized completely. In my
  81. Xown opinion, it works pretty good and quite fast enough for my purposes.
  82. XShould you have any problems with the code or discover any bugs, please contact
  83. Xme - I'll do what I can to help. 
  84. X
  85. XGood luck and greetings from :
  86. X  Hildo Biersma
  87. X  Tollensstraat 138
  88. X  2513 GE Den Haag
  89. X  Holland (Europe).
  90. END_OF_FILE
  91. if test 2869 -ne `wc -c <'atari_st/curscomp/curses.txt'`; then
  92.     echo shar: \"'atari_st/curscomp/curses.txt'\" unpacked with wrong size!
  93. fi
  94. # end of 'atari_st/curscomp/curses.txt'
  95. fi
  96. if test -f 'source/dungeon.c' -a "${1}" != "-c" ; then 
  97.   echo shar: Will not clobber existing file \"'source/dungeon.c'\"
  98. else
  99. echo shar: Extracting \"'source/dungeon.c'\" \(49774 characters\)
  100. sed "s/^X//" >'source/dungeon.c' <<'END_OF_FILE'
  101. X/* source/dungeon.c: the main command interpreter, updating player status
  102. X
  103. X   Copyright (c) 1989-92 James E. Wilson, Robert A. Koeneke
  104. X
  105. X   This software may be copied and distributed for educational, research, and
  106. X   not for profit purposes provided that this copyright and statement are
  107. X   included in all such copies. */
  108. X
  109. X#ifdef __TURBOC__
  110. X#include    <conio.h>
  111. X#include    <stdio.h>
  112. X#include    <stdlib.h>
  113. X#endif /* __TURBOC__ */
  114. X 
  115. X#include "config.h"
  116. X#include "constant.h"
  117. X#include "types.h"
  118. X#include "externs.h"
  119. X
  120. X#ifdef USG
  121. X#ifndef ATARIST_MWC
  122. X#include <string.h>
  123. X#endif
  124. X#else
  125. X#include <strings.h>
  126. X#endif
  127. X
  128. X#if defined(LINT_ARGS)
  129. Xstatic char original_commands(char);
  130. Xstatic void do_command(char);
  131. Xstatic int valid_countcommand(char);
  132. Xstatic void regenhp(int);
  133. Xstatic void regenmana(int);
  134. Xstatic int enchanted(inven_type *);
  135. Xstatic void examine_book(void);
  136. Xstatic void go_up(void);
  137. Xstatic void go_down(void);
  138. Xstatic void jamdoor(void);
  139. Xstatic void refill_lamp(void);
  140. X#else
  141. Xstatic char original_commands();
  142. Xstatic void do_command();
  143. Xstatic int valid_countcommand();
  144. Xstatic void regenhp();
  145. Xstatic void regenmana();
  146. Xstatic int enchanted();
  147. Xstatic void examine_book();
  148. Xstatic void go_up();
  149. Xstatic void go_down();
  150. Xstatic void jamdoor();
  151. Xstatic void refill_lamp();
  152. X#endif
  153. X
  154. X#ifdef ATARIST_TC
  155. X/* Include this to get prototypes for standard library functions.  */
  156. X#include <stdlib.h>
  157. X#endif
  158. X
  159. X/* Moria game module                    -RAK-    */
  160. X/* The code in this section has gone through many revisions, and */
  161. X/* some of it could stand some more hard work.    -RAK-           */
  162. X
  163. X/* It has had a bit more hard work.            -CJS- */
  164. X
  165. Xvoid dungeon()
  166. X{
  167. X  int find_count, i;
  168. X  int regen_amount;        /* Regenerate hp and mana*/
  169. X  char command;        /* Last command         */
  170. X  register struct misc *p_ptr;
  171. X  register inven_type *i_ptr;
  172. X  register struct flags *f_ptr;
  173. X#ifdef ATARIST_WMC
  174. X  int32u holder;
  175. X#endif
  176. X
  177. X  /* Main procedure for dungeon.            -RAK-    */
  178. X  /* Note: There is a lot of preliminary magic going on here at first*/
  179. X
  180. X  /* init pointers. */
  181. X  f_ptr = &py.flags;
  182. X  p_ptr = &py.misc;
  183. X
  184. X  /* Check light status for setup       */
  185. X  i_ptr = &inventory[INVEN_LIGHT];
  186. X  if (i_ptr->p1 > 0)
  187. X    player_light = TRUE;
  188. X  else
  189. X    player_light = FALSE;
  190. X  /* Check for a maximum level           */
  191. X  if (dun_level > p_ptr->max_dlv)
  192. X    p_ptr->max_dlv = dun_level;
  193. X
  194. X  /* Reset flags and initialize variables  */
  195. X  command_count = 0;
  196. X  find_count = 0;
  197. X  new_level_flag    = FALSE;
  198. X  find_flag    = FALSE;
  199. X  teleport_flag = FALSE;
  200. X  mon_tot_mult    = 0;
  201. X  cave[char_row][char_col].cptr = 1;
  202. X  /* Ensure we display the panel. Used to do this with a global var. -CJS- */
  203. X  panel_row = panel_col = -1;
  204. X  /* Light up the area around character       */
  205. X  check_view ();
  206. X  /* must do this after panel_row/col set to -1, because search_off() will
  207. X     call check_view(), and so the panel_* variables must be valid before
  208. X     search_off() is called */
  209. X  if (py.flags.status & PY_SEARCH)
  210. X    search_off();
  211. X  /* Light,  but do not move critters        */
  212. X  creatures(FALSE);
  213. X  /* Print the depth               */
  214. X  prt_depth();
  215. X#if 0
  216. X  /* This can't be right.  */
  217. X#ifdef ATARIST_MWC
  218. X  prt_map();
  219. X#endif
  220. X#endif
  221. X
  222. X  /* Loop until dead,  or new level        */
  223. X  do
  224. X    {
  225. X      /* Increment turn counter            */
  226. X      turn++;
  227. X#ifndef MAC
  228. X      /* The Mac ignores the game hours file        */
  229. X      /* Check for game hours                   */
  230. X      if (((turn % 250) == 1) && !check_time())
  231. X    if (closing_flag > 4)
  232. X      {
  233. X        msg_print("The gates to Moria are now closed.");
  234. X        (void) strcpy (died_from, "(closing gate: saved)");
  235. X        if (!save_char())
  236. X          {
  237. X        (void) strcpy (died_from, "a slammed gate");
  238. X        death = TRUE;
  239. X          }
  240. X        exit_game();
  241. X      }
  242. X    else
  243. X      {
  244. X        disturb (0, 0);
  245. X        closing_flag++;
  246. X        msg_print("The gates to Moria are closing.");
  247. X        msg_print("Please finish up or save your game.");
  248. X      }
  249. X#endif
  250. X
  251. X      /* turn over the store contents every, say, 1000 turns */
  252. X      if ((dun_level != 0) && ((turn % 1000) == 0))
  253. X    store_maint();
  254. X
  255. X      /* Check for creature generation        */
  256. X      if (randint(MAX_MALLOC_CHANCE) == 1)
  257. X    alloc_monster(1, MAX_SIGHT, FALSE);
  258. X      /* Check light status                   */
  259. X      i_ptr = &inventory[INVEN_LIGHT];
  260. X      if (player_light)
  261. X    if (i_ptr->p1 > 0)
  262. X      {
  263. X        i_ptr->p1--;
  264. X        if (i_ptr->p1 == 0)
  265. X          {
  266. X        player_light = FALSE;
  267. X        msg_print("Your light has gone out!");
  268. X        disturb (0, 1);
  269. X        /* unlight creatures */
  270. X        creatures(FALSE);
  271. X          }
  272. X        else if ((i_ptr->p1 < 40) && (randint(5) == 1) &&
  273. X             (py.flags.blind < 1))
  274. X          {
  275. X        disturb (0, 0);
  276. X        msg_print("Your light is growing faint.");
  277. X          }
  278. X      }
  279. X    else
  280. X      {
  281. X        player_light = FALSE;
  282. X        disturb (0, 1);
  283. X        /* unlight creatures */
  284. X        creatures(FALSE);
  285. X      }
  286. X      else if (i_ptr->p1 > 0)
  287. X    {
  288. X      i_ptr->p1--;
  289. X      player_light = TRUE;
  290. X      disturb (0, 1);
  291. X      /* light creatures */
  292. X      creatures(FALSE);
  293. X    }
  294. X
  295. X      /* Update counters and messages            */
  296. X      /* Check food status           */
  297. X      regen_amount = PLAYER_REGEN_NORMAL;
  298. X      if (f_ptr->food < PLAYER_FOOD_ALERT)
  299. X    {
  300. X      if (f_ptr->food < PLAYER_FOOD_WEAK)
  301. X        {
  302. X          if (f_ptr->food < 0)
  303. X        regen_amount = 0;
  304. X          else if (f_ptr->food < PLAYER_FOOD_FAINT)
  305. X        regen_amount = PLAYER_REGEN_FAINT;
  306. X          else if (f_ptr->food < PLAYER_FOOD_WEAK)
  307. X        regen_amount = PLAYER_REGEN_WEAK;
  308. X          if ((PY_WEAK & f_ptr->status) == 0)
  309. X        {
  310. X          f_ptr->status |= PY_WEAK;
  311. X          msg_print("You are getting weak from hunger.");
  312. X          disturb (0, 0);
  313. X          prt_hunger();
  314. X        }
  315. X          if ((f_ptr->food < PLAYER_FOOD_FAINT) && (randint(8) == 1))
  316. X        {
  317. X          f_ptr->paralysis += randint(5);
  318. X          msg_print("You faint from the lack of food.");
  319. X          disturb (1, 0);
  320. X        }
  321. X        }
  322. X      else if ((PY_HUNGRY & f_ptr->status) == 0)
  323. X        {
  324. X          f_ptr->status |= PY_HUNGRY;
  325. X          msg_print("You are getting hungry.");
  326. X          disturb (0, 0);
  327. X          prt_hunger();
  328. X        }
  329. X    }
  330. X      /* Food consumption    */
  331. X      /* Note: Speeded up characters really burn up the food!  */
  332. X      if (f_ptr->speed < 0)
  333. X    f_ptr->food -=    f_ptr->speed*f_ptr->speed;
  334. X      f_ptr->food -= f_ptr->food_digested;
  335. X      if (f_ptr->food < 0)
  336. X    {
  337. X      take_hit (-f_ptr->food/16, "starvation");   /* -CJS- */
  338. X      disturb(1, 0);
  339. X    }
  340. X      /* Regenerate           */
  341. X      if (f_ptr->regenerate)  regen_amount = regen_amount * 3 / 2;
  342. X      if ((py.flags.status & PY_SEARCH) || f_ptr->rest != 0)
  343. X    regen_amount = regen_amount * 2;
  344. X      if ((py.flags.poisoned < 1) && (p_ptr->chp < p_ptr->mhp))
  345. X    regenhp(regen_amount);
  346. X      if (p_ptr->cmana < p_ptr->mana)
  347. X    regenmana(regen_amount);
  348. X      /* Blindness           */
  349. X      if (f_ptr->blind > 0)
  350. X    {
  351. X      if ((PY_BLIND & f_ptr->status) == 0)
  352. X        {
  353. X          f_ptr->status |= PY_BLIND;
  354. X          prt_map();
  355. X          prt_blind();
  356. X          disturb (0, 1);
  357. X          /* unlight creatures */
  358. X          creatures (FALSE);
  359. X        }
  360. X      f_ptr->blind--;
  361. X      if (f_ptr->blind == 0)
  362. X        {
  363. X#ifdef ATARIST_MWC
  364. X          f_ptr->status &= ~(holder = PY_BLIND);
  365. X#else
  366. X          f_ptr->status &= ~PY_BLIND;
  367. X#endif
  368. X          prt_blind();
  369. X          prt_map();
  370. X          /* light creatures */
  371. X          disturb (0, 1);
  372. X          creatures(FALSE);
  373. X          msg_print("The veil of darkness lifts.");
  374. X        }
  375. X    }
  376. X      /* Confusion           */
  377. X      if (f_ptr->confused > 0)
  378. X    {
  379. X      if ((PY_CONFUSED & f_ptr->status) == 0)
  380. X        {
  381. X          f_ptr->status |= PY_CONFUSED;
  382. X          prt_confused();
  383. X        }
  384. X      f_ptr->confused--;
  385. X      if (f_ptr->confused == 0)
  386. X        {
  387. X#ifdef ATARIST_MWC
  388. X          f_ptr->status &= ~(holder = PY_CONFUSED);
  389. X#else
  390. X          f_ptr->status &= ~PY_CONFUSED;
  391. X#endif
  392. X          prt_confused();
  393. X          msg_print("You feel less confused now.");
  394. X          if (py.flags.rest != 0)
  395. X        rest_off ();
  396. X        }
  397. X    }
  398. X      /* Afraid               */
  399. X      if (f_ptr->afraid > 0)
  400. X    {
  401. X      if ((PY_FEAR & f_ptr->status) == 0)
  402. X        {
  403. X          if ((f_ptr->shero+f_ptr->hero) > 0)
  404. X        f_ptr->afraid = 0;
  405. X          else
  406. X        {
  407. X          f_ptr->status |= PY_FEAR;
  408. X          prt_afraid();
  409. X        }
  410. X        }
  411. X      else if ((f_ptr->shero+f_ptr->hero) > 0)
  412. X        f_ptr->afraid = 1;
  413. X      f_ptr->afraid--;
  414. X      if (f_ptr->afraid == 0)
  415. X        {
  416. X#ifdef ATARIST_MWC
  417. X          f_ptr->status &= ~(holder = PY_FEAR);
  418. X#else
  419. X          f_ptr->status &= ~PY_FEAR;
  420. X#endif
  421. X          prt_afraid();
  422. X          msg_print("You feel bolder now.");
  423. X          disturb (0, 0);
  424. X        }
  425. X    }
  426. X      /* Poisoned           */
  427. X      if (f_ptr->poisoned > 0)
  428. X    {
  429. X      if ((PY_POISONED & f_ptr->status) == 0)
  430. X        {
  431. X          f_ptr->status |= PY_POISONED;
  432. X          prt_poisoned();
  433. X        }
  434. X      f_ptr->poisoned--;
  435. X      if (f_ptr->poisoned == 0)
  436. X        {
  437. X#ifdef ATARIST_MWC
  438. X          f_ptr->status &= ~(holder = PY_POISONED);
  439. X#else
  440. X          f_ptr->status &= ~PY_POISONED;
  441. X#endif
  442. X          prt_poisoned();
  443. X          msg_print("You feel better.");
  444. X          disturb (0, 0);
  445. X        }
  446. X      else
  447. X        {
  448. X          switch(con_adj())
  449. X        {
  450. X        case -4:  i = 4;  break;
  451. X        case -3:
  452. X        case -2:  i = 3;  break;
  453. X        case -1:  i = 2;  break;
  454. X        case 0:      i = 1;  break;
  455. X        case 1: case 2: case 3:
  456. X          i = ((turn % 2) == 0);
  457. X          break;
  458. X        case 4: case 5:
  459. X          i = ((turn % 3) == 0);
  460. X          break;
  461. X        case 6:
  462. X          i = ((turn % 4) == 0);
  463. X          break;
  464. X        }
  465. X          take_hit (i, "poison");
  466. X          disturb (1, 0);
  467. X        }
  468. X    }
  469. X      /* Fast               */
  470. X      if (f_ptr->fast > 0)
  471. X    {
  472. X      if ((PY_FAST & f_ptr->status) == 0)
  473. X        {
  474. X          f_ptr->status |= PY_FAST;
  475. X          change_speed(-1);
  476. X          msg_print("You feel yourself moving faster.");
  477. X          disturb (0, 0);
  478. X        }
  479. X      f_ptr->fast--;
  480. X      if (f_ptr->fast == 0)
  481. X        {
  482. X#ifdef ATARIST_MWC
  483. X          f_ptr->status &= ~(holder = PY_FAST);
  484. X#else
  485. X          f_ptr->status &= ~PY_FAST;
  486. X#endif
  487. X          change_speed(1);
  488. X          msg_print("You feel yourself slow down.");
  489. X          disturb (0, 0);
  490. X        }
  491. X    }
  492. X      /* Slow               */
  493. X      if (f_ptr->slow > 0)
  494. X    {
  495. X      if ((PY_SLOW & f_ptr->status) == 0)
  496. X        {
  497. X          f_ptr->status |= PY_SLOW;
  498. X          change_speed(1);
  499. X          msg_print("You feel yourself moving slower.");
  500. X          disturb (0, 0);
  501. X        }
  502. X      f_ptr->slow--;
  503. X      if (f_ptr->slow == 0)
  504. X        {
  505. X#ifdef ATARIST_MWC
  506. X          f_ptr->status &= ~(holder = PY_SLOW);
  507. X#else
  508. X          f_ptr->status &= ~PY_SLOW;
  509. X#endif
  510. X          change_speed(-1);
  511. X          msg_print("You feel yourself speed up.");
  512. X          disturb (0, 0);
  513. X        }
  514. X    }
  515. X      /* Resting is over?      */
  516. X      if (f_ptr->rest > 0)
  517. X    {
  518. X      f_ptr->rest--;
  519. X      if (f_ptr->rest == 0)              /* Resting over           */
  520. X        rest_off();
  521. X    }
  522. X      else if (f_ptr->rest < 0)
  523. X    {
  524. X      /* Rest until reach max mana and max hit points.  */
  525. X      f_ptr->rest++;
  526. X      if ((p_ptr->chp == p_ptr->mhp && p_ptr->cmana == p_ptr->mana)
  527. X          || f_ptr->rest == 0)
  528. X        rest_off();
  529. X    }
  530. X
  531. X      /* Check for interrupts to find or rest. */
  532. X#ifdef MAC
  533. X      /* On Mac, checking for input is expensive, since it involves handling
  534. X     events, so we only check in multiples of 16 turns. */
  535. X      if (!(turn & 0xF) && ((command_count > 0) || find_flag
  536. X                 || (f_ptr->rest != 0)))
  537. X    if (macgetkey(CNIL, TRUE))
  538. X      disturb(0, 0);
  539. X#else
  540. X      if ((command_count > 0 || find_flag || f_ptr->rest != 0)
  541. X#if defined(MSDOS) || defined(VMS)
  542. X      && kbhit()
  543. X#else
  544. X      && (check_input (find_flag ? 0 : 10000))
  545. X#endif
  546. X      )
  547. X    {
  548. X#ifdef MSDOS
  549. X      (void) msdos_getch();
  550. X#endif
  551. X#ifdef VMS
  552. X      /* Get and ignore the key used to interrupt resting/running.  */
  553. X      (void) vms_getch ();
  554. X#endif
  555. X      disturb (0, 0);
  556. X    }
  557. X#endif
  558. X
  559. X      /* Hallucinating?     (Random characters appear!)*/
  560. X      if (f_ptr->image > 0)
  561. X    {
  562. X      end_find ();
  563. X      f_ptr->image--;
  564. X      if (f_ptr->image == 0)
  565. X        prt_map ();     /* Used to draw entire screen! -CJS- */
  566. X    }
  567. X      /* Paralysis           */
  568. X      if (f_ptr->paralysis > 0)
  569. X    {
  570. X      /* when paralysis true, you can not see any movement that occurs */
  571. X      f_ptr->paralysis--;
  572. X      disturb (1, 0);
  573. X    }
  574. X      /* Protection from evil counter*/
  575. X      if (f_ptr->protevil > 0)
  576. X    {
  577. X      f_ptr->protevil--;
  578. X      if (f_ptr->protevil == 0)
  579. X        msg_print ("You no longer feel safe from evil.");
  580. X    }
  581. X      /* Invulnerability    */
  582. X      if (f_ptr->invuln > 0)
  583. X    {
  584. X      if ((PY_INVULN & f_ptr->status) == 0)
  585. X        {
  586. X          f_ptr->status |= PY_INVULN;
  587. X          disturb (0, 0);
  588. X          py.misc.pac += 100;
  589. X          py.misc.dis_ac += 100;
  590. X          prt_pac();
  591. X          msg_print("Your skin turns into steel!");
  592. X        }
  593. X      f_ptr->invuln--;
  594. X      if (f_ptr->invuln == 0)
  595. X        {
  596. X#ifdef ATARIST_MWC
  597. X          f_ptr->status &= ~(holder = PY_INVULN);
  598. X#else
  599. X          f_ptr->status &= ~PY_INVULN;
  600. X#endif
  601. X          disturb (0, 0);
  602. X          py.misc.pac -= 100;
  603. X          py.misc.dis_ac -= 100;
  604. X          prt_pac();
  605. X          msg_print("Your skin returns to normal.");
  606. X        }
  607. X    }
  608. X      /* Heroism       */
  609. X      if (f_ptr->hero > 0)
  610. X    {
  611. X      if ((PY_HERO & f_ptr->status) == 0)
  612. X        {
  613. X          f_ptr->status |= PY_HERO;
  614. X          disturb (0, 0);
  615. X          p_ptr->mhp += 10;
  616. X          p_ptr->chp += 10;
  617. X          p_ptr->bth += 12;
  618. X          p_ptr->bthb+= 12;
  619. X          msg_print("You feel like a HERO!");
  620. X          prt_mhp();
  621. X          prt_chp();
  622. X        }
  623. X      f_ptr->hero--;
  624. X      if (f_ptr->hero == 0)
  625. X        {
  626. X#ifdef ATARIST_MWC
  627. X          f_ptr->status &= ~(holder = PY_HERO);
  628. X#else
  629. X          f_ptr->status &= ~PY_HERO;
  630. X#endif
  631. X          disturb (0, 0);
  632. X          p_ptr->mhp -= 10;
  633. X          if (p_ptr->chp > p_ptr->mhp)
  634. X        {
  635. X          p_ptr->chp = p_ptr->mhp;
  636. X          p_ptr->chp_frac = 0;
  637. X          prt_chp();
  638. X        }
  639. X          p_ptr->bth -= 12;
  640. X          p_ptr->bthb-= 12;
  641. X          msg_print("The heroism wears off.");
  642. X          prt_mhp();
  643. X        }
  644. X    }
  645. X      /* Super Heroism */
  646. X      if (f_ptr->shero > 0)
  647. X    {
  648. X      if ((PY_SHERO & f_ptr->status) == 0)
  649. X        {
  650. X          f_ptr->status |= PY_SHERO;
  651. X          disturb (0, 0);
  652. X          p_ptr->mhp += 20;
  653. X          p_ptr->chp += 20;
  654. X          p_ptr->bth += 24;
  655. X          p_ptr->bthb+= 24;
  656. X          msg_print("You feel like a SUPER HERO!");
  657. X          prt_mhp();
  658. X          prt_chp();
  659. X        }
  660. X      f_ptr->shero--;
  661. X      if (f_ptr->shero == 0)
  662. X        {
  663. X#ifdef ATARIST_MWC
  664. X          f_ptr->status &= ~(holder = PY_SHERO);
  665. X#else
  666. X          f_ptr->status &= ~PY_SHERO;
  667. X#endif
  668. X          disturb (0, 0);
  669. X          p_ptr->mhp -= 20;
  670. X          if (p_ptr->chp > p_ptr->mhp)
  671. X        {
  672. X          p_ptr->chp = p_ptr->mhp;
  673. X          p_ptr->chp_frac = 0;
  674. X          prt_chp();
  675. X        }
  676. X          p_ptr->bth -= 24;
  677. X          p_ptr->bthb-= 24;
  678. X          msg_print("The super heroism wears off.");
  679. X          prt_mhp();
  680. X        }
  681. X    }
  682. X      /* Blessed       */
  683. X      if (f_ptr->blessed > 0)
  684. X    {
  685. X      if ((PY_BLESSED & f_ptr->status) == 0)
  686. X        {
  687. X          f_ptr->status |= PY_BLESSED;
  688. X          disturb (0, 0);
  689. X          p_ptr->bth += 5;
  690. X          p_ptr->bthb+= 5;
  691. X          p_ptr->pac += 2;
  692. X          p_ptr->dis_ac+= 2;
  693. X          msg_print("You feel righteous!");
  694. X          prt_pac();
  695. X        }
  696. X      f_ptr->blessed--;
  697. X      if (f_ptr->blessed == 0)
  698. X        {
  699. X#ifdef ATARIST_MWC
  700. X          f_ptr->status &= ~(holder = PY_BLESSED);
  701. X#else
  702. X          f_ptr->status &= ~PY_BLESSED;
  703. X#endif
  704. X          disturb (0, 0);
  705. X          p_ptr->bth -= 5;
  706. X          p_ptr->bthb-= 5;
  707. X          p_ptr->pac -= 2;
  708. X          p_ptr->dis_ac -= 2;
  709. X          msg_print("The prayer has expired.");
  710. X          prt_pac();
  711. X        }
  712. X    }
  713. X      /* Resist Heat   */
  714. X      if (f_ptr->resist_heat > 0)
  715. X    {
  716. X      f_ptr->resist_heat--;
  717. X      if (f_ptr->resist_heat == 0)
  718. X        msg_print ("You no longer feel safe from flame.");
  719. X    }
  720. X      /* Resist Cold   */
  721. X      if (f_ptr->resist_cold > 0)
  722. X    {
  723. X      f_ptr->resist_cold--;
  724. X      if (f_ptr->resist_cold == 0)
  725. X        msg_print ("You no longer feel safe from cold.");
  726. X    }
  727. X      /* Detect Invisible      */
  728. X      if (f_ptr->detect_inv > 0)
  729. X    {
  730. X#ifdef ATARIST_MWC
  731. X      if (((holder = PY_DET_INV) & f_ptr->status) == 0)
  732. X#else
  733. X      if ((PY_DET_INV & f_ptr->status) == 0)
  734. X#endif
  735. X        {
  736. X#ifdef ATARIST_MWC
  737. X          f_ptr->status |= holder;
  738. X#else
  739. X          f_ptr->status |= PY_DET_INV;
  740. X#endif
  741. X          f_ptr->see_inv = TRUE;
  742. X          /* light but don't move creatures */
  743. X          creatures (FALSE);
  744. X        }
  745. X      f_ptr->detect_inv--;
  746. X      if (f_ptr->detect_inv == 0)
  747. X        {
  748. X#ifdef ATARIST_MWC
  749. X          f_ptr->status &= ~holder;
  750. X#else
  751. X          f_ptr->status &= ~PY_DET_INV;
  752. X#endif
  753. X          /* may still be able to see_inv if wearing magic item */
  754. X          calc_bonuses();
  755. X          /* unlight but don't move creatures */
  756. X          creatures (FALSE);
  757. X        }
  758. X    }
  759. X      /* Timed infra-vision    */
  760. X      if (f_ptr->tim_infra > 0)
  761. X    {
  762. X#ifdef ATARIST_MWC
  763. X      if (((holder = PY_TIM_INFRA) & f_ptr->status) == 0)
  764. X#else
  765. X      if ((PY_TIM_INFRA & f_ptr->status) == 0)
  766. X#endif
  767. X        {
  768. X#ifdef ATARIST_MWC
  769. X          f_ptr->status |= holder;
  770. X#else
  771. X          f_ptr->status |= PY_TIM_INFRA;
  772. X#endif
  773. X          f_ptr->see_infra++;
  774. X          /* light but don't move creatures */
  775. X          creatures (FALSE);
  776. X        }
  777. X      f_ptr->tim_infra--;
  778. X      if (f_ptr->tim_infra == 0)
  779. X        {
  780. X#ifdef ATARIST_MWC
  781. X          f_ptr->status &= ~holder;
  782. X#else
  783. X          f_ptr->status &= ~PY_TIM_INFRA;
  784. X#endif
  785. X          f_ptr->see_infra--;
  786. X          /* unlight but don't move creatures */
  787. X          creatures (FALSE);
  788. X        }
  789. X    }
  790. X    /* Word-of-Recall  Note: Word-of-Recall is a delayed action     */
  791. X      if (f_ptr->word_recall > 0)
  792. X    if (f_ptr->word_recall == 1)
  793. X      {
  794. X        new_level_flag = TRUE;
  795. X        f_ptr->paralysis++;
  796. X        f_ptr->word_recall = 0;
  797. X        if (dun_level > 0)
  798. X          {
  799. X        dun_level = 0;
  800. X        msg_print("You feel yourself yanked upwards!");
  801. X          }
  802. X        else if (py.misc.max_dlv != 0)
  803. X          {
  804. X        dun_level = py.misc.max_dlv;
  805. X        msg_print("You feel yourself yanked downwards!");
  806. X          }
  807. X      }
  808. X    else
  809. X      f_ptr->word_recall--;
  810. X
  811. X      /* Random teleportation  */
  812. X      if ((py.flags.teleport) && (randint(100) == 1))
  813. X    {
  814. X      disturb (0, 0);
  815. X      teleport(40);
  816. X    }
  817. X
  818. X      /* See if we are too weak to handle the weapon or pack.  -CJS- */
  819. X#ifdef ATARIST_MWC
  820. X      if (py.flags.status & (holder = PY_STR_WGT))
  821. X#else
  822. X      if (py.flags.status & PY_STR_WGT)
  823. X#endif
  824. X    check_strength();
  825. X      if (py.flags.status & PY_STUDY)
  826. X    prt_study();
  827. X#ifdef ATARIST_MWC
  828. X      if (py.flags.status & (holder = PY_SPEED))
  829. X#else
  830. X      if (py.flags.status & PY_SPEED)
  831. X#endif
  832. X    {
  833. X#ifdef ATARIST_MWC
  834. X      py.flags.status &= ~holder;
  835. X#else
  836. X      py.flags.status &= ~PY_SPEED;
  837. X#endif
  838. X      prt_speed();
  839. X    }
  840. X#ifdef ATARIST_MWC
  841. X      if ((py.flags.status & (holder = PY_PARALYSED))
  842. X      && (py.flags.paralysis < 1))
  843. X#else
  844. X      if ((py.flags.status & PY_PARALYSED) && (py.flags.paralysis < 1))
  845. X#endif
  846. X    {
  847. X      prt_state();
  848. X#ifdef ATARIST_MWC
  849. X      py.flags.status &= ~holder;
  850. X#else
  851. X      py.flags.status &= ~PY_PARALYSED;
  852. X#endif
  853. X    }
  854. X      else if (py.flags.paralysis > 0)
  855. X    {
  856. X      prt_state();
  857. X#ifdef ATARIST_MWC
  858. X      py.flags.status |= (holder = PY_PARALYSED);
  859. X#else
  860. X      py.flags.status |= PY_PARALYSED;
  861. X#endif
  862. X    }
  863. X      else if (py.flags.rest != 0)
  864. X    prt_state();
  865. X
  866. X#ifdef ATARIST_MWC
  867. X      if ((py.flags.status & (holder = PY_ARMOR)) != 0)
  868. X#else
  869. X      if ((py.flags.status & PY_ARMOR) != 0)
  870. X#endif
  871. X    {
  872. X      prt_pac();
  873. X#ifdef ATARIST_MWC
  874. X      py.flags.status &= ~holder;
  875. X#else
  876. X      py.flags.status &= ~PY_ARMOR;
  877. X#endif
  878. X    }
  879. X#ifdef ATARIST_MWC
  880. X      if ((py.flags.status & (holder = PY_STATS)) != 0)
  881. X#else
  882. X      if ((py.flags.status & PY_STATS) != 0)
  883. X#endif
  884. X    {
  885. X      for (i = 0; i < 6; i++)
  886. X#ifdef ATARIST_MWC
  887. X        if (((holder = PY_STR) << i) & py.flags.status)
  888. X#else
  889. X        if ((PY_STR << i) & py.flags.status)
  890. X#endif
  891. X          prt_stat(i);
  892. X#ifdef ATARIST_MWC
  893. X      py.flags.status &= ~(holder = PY_STATS);
  894. X#else
  895. X      py.flags.status &= ~PY_STATS;
  896. X#endif
  897. X    }
  898. X#ifdef ATARIST_MWC
  899. X      if (py.flags.status & (holder = PY_HP))
  900. X#else
  901. X      if (py.flags.status & PY_HP)
  902. X#endif
  903. X    {
  904. X      prt_mhp();
  905. X      prt_chp();
  906. X#ifdef ATARIST_MWC
  907. X      py.flags.status &= ~holder;
  908. X#else
  909. X      py.flags.status &= ~PY_HP;
  910. X#endif
  911. X    }
  912. X#ifdef ATARIST_MWC
  913. X      if (py.flags.status & (holder = PY_MANA))
  914. X#else
  915. X      if (py.flags.status & PY_MANA)
  916. X#endif
  917. X    {
  918. X      prt_cmana();
  919. X#ifdef ATARIST_MWC
  920. X      py.flags.status &= ~holder;
  921. X#else
  922. X      py.flags.status &= ~PY_MANA;
  923. X#endif
  924. X    }
  925. X
  926. X      /* Allow for a slim chance of detect enchantment -CJS- */
  927. X      /* for 1st level char, check once every 2160 turns
  928. X     for 40th level char, check once every 416 turns */
  929. X      if (((turn & 0xF) == 0) && (f_ptr->confused == 0)
  930. X      && (randint((int)(10 + 750 / (5 + py.misc.lev))) == 1))
  931. X    {
  932. X      vtype tmp_str;
  933. X
  934. X      for (i = 0; i < INVEN_ARRAY_SIZE; i++)
  935. X        {
  936. X          if (i == inven_ctr)
  937. X        i = 22;
  938. X          i_ptr = &inventory[i];
  939. X          /* if in inventory, succeed 1 out of 50 times,
  940. X         if in equipment list, success 1 out of 10 times */
  941. X          if ((i_ptr->tval != TV_NOTHING) && enchanted(i_ptr) &&
  942. X          (randint(i < 22 ? 50 : 10) == 1))
  943. X        {
  944. X          extern char *describe_use();
  945. X
  946. X          (void) sprintf(tmp_str,
  947. X                 "There's something about what you are %s...",
  948. X                 describe_use(i));
  949. X          disturb(0, 0);
  950. X          msg_print(tmp_str);
  951. X          add_inscribe(i_ptr, ID_MAGIK);
  952. X        }
  953. X        }
  954. X    }
  955. X
  956. X      /* Check the state of the monster list, and delete some monsters if
  957. X     the monster list is nearly full.  This helps to avoid problems in
  958. X     creature.c when monsters try to multiply.  Compact_monsters() is
  959. X     much more likely to succeed if called from here, than if called
  960. X     from within creatures().  */
  961. X      if (MAX_MALLOC - mfptr < 10)
  962. X    (void) compact_monsters ();
  963. X
  964. X      if ((py.flags.paralysis < 1) &&         /* Accept a command?     */
  965. X      (py.flags.rest == 0) &&
  966. X      (!death))
  967. X    /* Accept a command and execute it                 */
  968. X    {
  969. X      do
  970. X        {
  971. X#ifdef ATARIST_MWC
  972. X          if (py.flags.status & (holder = PY_REPEAT))
  973. X#else
  974. X          if (py.flags.status & PY_REPEAT)
  975. X#endif
  976. X        prt_state ();
  977. X          default_dir = FALSE;
  978. X          free_turn_flag = FALSE;
  979. X
  980. X          if (find_flag)
  981. X        {
  982. X          find_run();
  983. X          find_count--;
  984. X          if (find_count == 0)
  985. X            end_find();
  986. X          put_qio();
  987. X        }
  988. X          else if (doing_inven)
  989. X        inven_command (doing_inven);
  990. X          else
  991. X        {
  992. X          /* move the cursor to the players character */
  993. X          move_cursor_relative (char_row, char_col);
  994. X          if (command_count > 0)
  995. X            {
  996. X              msg_flag = FALSE;
  997. X              default_dir = TRUE;
  998. X            }
  999. X          else
  1000. X            {
  1001. X              msg_flag = FALSE;
  1002. X#ifdef MAC
  1003. X              unloadsegments();
  1004. X              enablesavecmd(TRUE);
  1005. X              command = inkeydir();
  1006. X              enablesavecmd(FALSE);
  1007. X#else
  1008. X              command = inkey();
  1009. X#endif
  1010. X              i = 0;
  1011. X              /* Get a count for a command. */
  1012. X              if ((rogue_like_commands
  1013. X               && command >= '0' && command <= '9')
  1014. X              || (!rogue_like_commands && command == '#'))
  1015. X            {
  1016. X              char tmp[8];
  1017. X
  1018. X              prt("Repeat count:", 0, 0);
  1019. X              if (command == '#')
  1020. X                command = '0';
  1021. X              i = 0;
  1022. X              while (TRUE)
  1023. X                {
  1024. X                  if (command == DELETE || command == CTRL('H'))
  1025. X                {
  1026. X                  i = i / 10;
  1027. X                  (void) sprintf(tmp, "%d", i);
  1028. X                  prt (tmp, 0, 14);
  1029. X                }
  1030. X                  else if (command >= '0' && command <= '9')
  1031. X                {
  1032. X                      if (i > 99)
  1033. X                    bell ();
  1034. X                  else
  1035. X                    {
  1036. X                      i = i * 10 + command - '0';
  1037. X                      (void) sprintf (tmp, "%d", i);
  1038. X                      prt (tmp, 0, 14);
  1039. X                    }
  1040. X                }
  1041. X                  else
  1042. X                break;
  1043. X#ifdef MAC
  1044. X                  command = inkeydir();
  1045. X#else
  1046. X                  command = inkey();
  1047. X#endif
  1048. X                }
  1049. X              if (i == 0)
  1050. X                {
  1051. X                  i = 99;
  1052. X                  (void) sprintf (tmp, "%d", i);
  1053. X                  prt (tmp, 0, 14);
  1054. X                }
  1055. X              /* a special hack to allow numbers as commands */
  1056. X              if (command == ' ')
  1057. X                {
  1058. X                  prt ("Command:", 0, 20);
  1059. X#ifdef MAC
  1060. X                  command = inkeydir();
  1061. X#else
  1062. X                  command = inkey();
  1063. X#endif
  1064. X                }
  1065. X            }
  1066. X              /* Another way of typing control codes -CJS- */
  1067. X              if (command == '^')
  1068. X            {
  1069. X              if (command_count > 0)
  1070. X                prt_state();
  1071. X              if (get_com("Control-", &command))
  1072. X                {
  1073. X                  if (command >= 'A' && command <= 'Z')
  1074. X                command -= 'A' - 1;
  1075. X                  else if (command >= 'a' && command <= 'z')
  1076. X                command -= 'a' - 1;
  1077. X                  else
  1078. X                {
  1079. X                   msg_print("Type ^ <letter> for a control char");
  1080. X                  command = ' ';
  1081. X                }
  1082. X                }
  1083. X              else
  1084. X                command = ' ';
  1085. X            }
  1086. X              /* move cursor to player char again, in case it moved */
  1087. X              move_cursor_relative (char_row, char_col);
  1088. X              /* Commands are always converted to rogue form. -CJS- */
  1089. X              if (rogue_like_commands == FALSE)
  1090. X            command = original_commands (command);
  1091. X              if (i > 0)
  1092. X            {
  1093. X              if (!valid_countcommand(command))
  1094. X                {
  1095. X                  free_turn_flag = TRUE;
  1096. X                  msg_print ("Invalid command with a count.");
  1097. X                  command = ' ';
  1098. X                }
  1099. X              else
  1100. X                {
  1101. X                  command_count = i;
  1102. X                  prt_state ();
  1103. X                }
  1104. X            }
  1105. X            }
  1106. X          /* Flash the message line. */
  1107. X          erase_line(MSG_LINE, 0);
  1108. X          move_cursor_relative(char_row, char_col);
  1109. X          put_qio();
  1110. X
  1111. X          do_command (command);
  1112. X          /* Find is counted differently, as the command changes. */
  1113. X          if (find_flag)
  1114. X            {
  1115. X              find_count = command_count - 1;
  1116. X              command_count = 0;
  1117. X            }
  1118. X          else if (free_turn_flag)
  1119. X            command_count = 0;
  1120. X          else if (command_count)
  1121. X            command_count--;
  1122. X        }
  1123. X          /* End of commands                     */
  1124. X        }
  1125. X      while (free_turn_flag && !new_level_flag && !eof_flag);
  1126. X    }
  1127. X      else
  1128. X    {
  1129. X      /* if paralyzed, resting, or dead, flush output */
  1130. X      /* but first move the cursor onto the player, for aesthetics */
  1131. X      move_cursor_relative (char_row, char_col);
  1132. X      put_qio ();
  1133. X    }
  1134. X
  1135. X      /* Teleport?               */
  1136. X      if (teleport_flag)  teleport(100);
  1137. X      /* Move the creatures           */
  1138. X      if (!new_level_flag)  creatures(TRUE);
  1139. X      /* Exit when new_level_flag is set   */
  1140. X    }
  1141. X  while (!new_level_flag && !eof_flag);
  1142. X}
  1143. X
  1144. X
  1145. Xstatic char original_commands(com_val)
  1146. Xchar com_val;
  1147. X{
  1148. X  int dir_val;
  1149. X
  1150. X  switch(com_val)
  1151. X    {
  1152. X    case CTRL('K'):    /*^K = exit    */
  1153. X      com_val = 'Q';
  1154. X      break;
  1155. X    case CTRL('J'):
  1156. X    case CTRL('M'):
  1157. X      com_val = '+';
  1158. X      break;
  1159. X    case CTRL('P'):    /*^P = repeat  */
  1160. X    case CTRL('W'):    /*^W = password*/
  1161. X    case CTRL('X'):    /*^X = save    */
  1162. X    case ' ':
  1163. X    case '!':
  1164. X    case '$':
  1165. X      break;
  1166. X    case '.':
  1167. X      if (get_dir(CNIL, &dir_val))
  1168. X    switch (dir_val)
  1169. X      {
  1170. X      case 1:    com_val = 'B';    break;
  1171. X      case 2:    com_val = 'J';    break;
  1172. X      case 3:    com_val = 'N';    break;
  1173. X      case 4:    com_val = 'H';    break;
  1174. X      case 6:    com_val = 'L';    break;
  1175. X      case 7:    com_val = 'Y';    break;
  1176. X      case 8:    com_val = 'K';    break;
  1177. X      case 9:    com_val = 'U';    break;
  1178. X      default:   com_val = ' ';    break;
  1179. X      }
  1180. X      else
  1181. X    com_val = ' ';
  1182. X      break;
  1183. X    case '/':
  1184. X    case '<':
  1185. X    case '>':
  1186. X    case '-':
  1187. X    case '=':
  1188. X    case '{':
  1189. X    case '?':
  1190. X    case 'A':
  1191. X      break;
  1192. X    case '1':
  1193. X      com_val = 'b';
  1194. X      break;
  1195. X    case '2':
  1196. X      com_val = 'j';
  1197. X      break;
  1198. X    case '3':
  1199. X      com_val = 'n';
  1200. X      break;
  1201. X    case '4':
  1202. X      com_val = 'h';
  1203. X      break;
  1204. X    case '5':    /* Rest one turn */
  1205. X      com_val = '.';
  1206. X      break;
  1207. X    case '6':
  1208. X      com_val = 'l';
  1209. X      break;
  1210. X    case '7':
  1211. X      com_val = 'y';
  1212. X      break;
  1213. X    case '8':
  1214. X      com_val = 'k';
  1215. X      break;
  1216. X    case '9':
  1217. X      com_val = 'u';
  1218. X      break;
  1219. X    case 'B':
  1220. X      com_val = 'f';
  1221. X      break;
  1222. X    case 'C':
  1223. X    case 'D':
  1224. X    case 'E':
  1225. X    case 'F':
  1226. X    case 'G':
  1227. X      break;
  1228. X    case 'L':
  1229. X      com_val = 'W';
  1230. X      break;
  1231. X    case 'M':
  1232. X      break;
  1233. X    case 'R':
  1234. X      break;
  1235. X    case 'S':
  1236. X      com_val = '#';
  1237. X      break;
  1238. X    case 'T':
  1239. X      if (get_dir(CNIL, &dir_val))
  1240. X    switch (dir_val)
  1241. X      {
  1242. X      case 1:    com_val = CTRL('B');    break;
  1243. X      case 2:    com_val = CTRL('J');    break;
  1244. X      case 3:    com_val = CTRL('N');    break;
  1245. X      case 4:    com_val = CTRL('H');    break;
  1246. X      case 6:    com_val = CTRL('L');    break;
  1247. X      case 7:    com_val = CTRL('Y');    break;
  1248. X      case 8:    com_val = CTRL('K');    break;
  1249. X      case 9:    com_val = CTRL('U');    break;
  1250. X      default:   com_val = ' ';         break;
  1251. X      }
  1252. X      else
  1253. X    com_val = ' ';
  1254. X      break;
  1255. X    case 'V':
  1256. X      break;
  1257. X    case 'a':
  1258. X      com_val = 'z';
  1259. X      break;
  1260. X    case 'b':
  1261. X      com_val = 'P';
  1262. X      break;
  1263. X    case 'c':
  1264. X    case 'd':
  1265. X    case 'e':
  1266. X      break;
  1267. X    case 'f':
  1268. X      com_val = 't';
  1269. X      break;
  1270. X    case 'h':
  1271. X      com_val = '?';
  1272. X      break;
  1273. X    case 'i':
  1274. X      break;
  1275. X    case 'j':
  1276. X      com_val = 'S';
  1277. X      break;
  1278. X    case 'l':
  1279. X      com_val = 'x';
  1280. X      break;
  1281. X    case 'm':
  1282. X    case 'o':
  1283. X    case 'p':
  1284. X    case 'q':
  1285. X    case 'r':
  1286. X    case 's':
  1287. X      break;
  1288. X    case 't':
  1289. X      com_val = 'T';
  1290. X      break;
  1291. X    case 'u':
  1292. X      com_val = 'Z';
  1293. X      break;
  1294. X    case 'v':
  1295. X    case 'w':
  1296. X      break;
  1297. X    case 'x':
  1298. X      com_val = 'X';
  1299. X      break;
  1300. X
  1301. X      /* wizard mode commands follow */
  1302. X    case CTRL('A'): /*^A = cure all */
  1303. X      break;
  1304. X    case CTRL('B'):    /*^B = objects */
  1305. X      com_val = CTRL('O');
  1306. X      break;
  1307. X    case CTRL('D'):    /*^D = up/down */
  1308. X      break;
  1309. X    case CTRL('H'):    /*^H = wizhelp */
  1310. X      com_val = '\\';
  1311. X      break;
  1312. X    case CTRL('I'):    /*^I = identify*/
  1313. X      break;
  1314. X    case CTRL('L'):    /*^L = wizlight*/
  1315. X      com_val = '*';
  1316. X      break;
  1317. X    case ':':
  1318. X    case CTRL('T'):    /*^T = teleport*/
  1319. X    case CTRL('E'):    /*^E = wizchar */
  1320. X    case CTRL('F'):    /*^F = genocide*/
  1321. X    case CTRL('G'):    /*^G = treasure*/
  1322. X    case '@':
  1323. X    case '+':
  1324. X      break;
  1325. X    case CTRL('U'):    /*^U = summon  */
  1326. X      com_val = '&';
  1327. X      break;
  1328. X    default:
  1329. X      com_val = '~';  /* Anything illegal. */
  1330. X      break;
  1331. X    }
  1332. X  return com_val;
  1333. X}
  1334. X
  1335. X
  1336. Xstatic void do_command(com_val)
  1337. Xchar com_val;
  1338. X{
  1339. X  int dir_val, do_pickup;
  1340. X  int y, x, i, j;
  1341. X  vtype out_val, tmp_str;
  1342. X  register struct flags *f_ptr;
  1343. X
  1344. X  /* hack for move without pickup.  Map '-' to a movement command. */
  1345. X  if (com_val == '-')
  1346. X    {
  1347. X      do_pickup = FALSE;
  1348. X      i = command_count;
  1349. X      if (get_dir(CNIL, &dir_val))
  1350. X    {
  1351. X      command_count = i;
  1352. X      switch (dir_val)
  1353. X        {
  1354. X        case 1:    com_val = 'b';     break;
  1355. X        case 2:    com_val = 'j';     break;
  1356. X        case 3:    com_val = 'n';     break;
  1357. X        case 4:    com_val = 'h';     break;
  1358. X        case 6:    com_val = 'l';     break;
  1359. X        case 7:    com_val = 'y';     break;
  1360. X        case 8:    com_val = 'k';     break;
  1361. X        case 9:    com_val = 'u';     break;
  1362. X        default:   com_val = '~';     break;
  1363. X        }
  1364. X    }
  1365. X      else
  1366. X    com_val = ' ';
  1367. X    }
  1368. X  else
  1369. X    do_pickup = TRUE;
  1370. X
  1371. X  switch(com_val)
  1372. X    {
  1373. X    case 'Q':    /* (Q)uit        (^K)ill */
  1374. X      flush();
  1375. X      if (get_check("Do you really want to quit?"))
  1376. X    {
  1377. X      new_level_flag = TRUE;
  1378. X      death = TRUE;
  1379. X      (void) strcpy(died_from, "Quitting");
  1380. X    }
  1381. X      free_turn_flag = TRUE;
  1382. X      break;
  1383. X    case CTRL('P'):    /* (^P)revious message. */
  1384. X      if (command_count > 0)
  1385. X    {
  1386. X      i = command_count;
  1387. X      if (i > MAX_SAVE_MSG)
  1388. X        i = MAX_SAVE_MSG;
  1389. X      command_count = 0;
  1390. X    }
  1391. X      else if (last_command != CTRL('P'))
  1392. X    i = 1;
  1393. X      else
  1394. X    i = MAX_SAVE_MSG;
  1395. X      j = last_msg;
  1396. X      if (i > 1)
  1397. X    {
  1398. X      save_screen();
  1399. X      x = i;
  1400. X      while (i > 0)
  1401. X        {
  1402. X          i--;
  1403. X          prt(old_msg[j], i, 0);
  1404. X          if (j == 0)
  1405. X        j = MAX_SAVE_MSG-1;
  1406. X          else
  1407. X        j--;
  1408. X        }
  1409. X      erase_line (x, 0);
  1410. X      pause_line(x);
  1411. X      restore_screen();
  1412. X    }
  1413. X      else
  1414. X    {
  1415. X      /* Distinguish real and recovered messages with a '>'. -CJS- */
  1416. X      put_buffer(">", 0, 0);
  1417. X      prt(old_msg[j], 0, 1);
  1418. X    }
  1419. X      free_turn_flag = TRUE;
  1420. X      break;
  1421. X    case CTRL('W'):    /* (^W)izard mode */
  1422. X      if (wizard)
  1423. X    {
  1424. X      wizard = FALSE;
  1425. X      msg_print("Wizard mode off.");
  1426. X    }
  1427. X      else if (enter_wiz_mode())
  1428. X    msg_print("Wizard mode on.");
  1429. X      prt_winner();
  1430. X      free_turn_flag = TRUE;
  1431. X      break;
  1432. X    case CTRL('X'):    /* e(^X)it and save */
  1433. X      if (total_winner)
  1434. X    {
  1435. X       msg_print("You are a Total Winner,  your character must be retired.");
  1436. X      if (rogue_like_commands)
  1437. X        msg_print("Use 'Q' to when you are ready to quit.");
  1438. X      else
  1439. X        msg_print ("Use <Control>-K when you are ready to quit.");
  1440. X    }
  1441. X      else
  1442. X    {
  1443. X      (void) strcpy (died_from, "(saved)");
  1444. X      msg_print ("Saving game...");
  1445. X#ifdef MAC
  1446. X      if (save_char (TRUE))
  1447. X        exit_game();
  1448. X#else
  1449. X      if (save_char ())
  1450. X        exit_game();
  1451. X#endif
  1452. X      (void) strcpy (died_from, "(alive and well)");
  1453. X    }
  1454. X      free_turn_flag = TRUE;
  1455. X      break;
  1456. X    case '=':        /* (=) set options */
  1457. X      save_screen();
  1458. X      set_options();
  1459. X      restore_screen();
  1460. X      free_turn_flag = TRUE;
  1461. X      break;
  1462. X    case '{':        /* ({) inscribe an object    */
  1463. X      scribe_object ();
  1464. X      free_turn_flag = TRUE;
  1465. X      break;
  1466. X    case '!':        /* (!) escape to the shell */
  1467. X    case '$':
  1468. X#ifdef SECURE
  1469. X      msg_print("Sorry, inferior shells are not allowed from Moria.");
  1470. X#else
  1471. X      shell_out();
  1472. X#endif
  1473. X      free_turn_flag = TRUE;
  1474. X      break;
  1475. X    case ESCAPE:    /* (ESC)   do nothing. */
  1476. X    case ' ':        /* (space) do nothing. */
  1477. X      free_turn_flag = TRUE;
  1478. X      break;
  1479. X    case 'b':        /* (b) down, left    (1) */
  1480. X      move_char(1, do_pickup);
  1481. X      break;
  1482. X    case 'j':        /* (j) down        (2) */
  1483. X      move_char(2, do_pickup);
  1484. X      break;
  1485. X    case 'n':        /* (n) down, right    (3) */
  1486. X      move_char(3, do_pickup);
  1487. X      break;
  1488. X    case 'h':        /* (h) left        (4) */
  1489. X      move_char(4, do_pickup);
  1490. X      break;
  1491. X    case 'l':        /* (l) right        (6) */
  1492. X      move_char(6, do_pickup);
  1493. X      break;
  1494. X    case 'y':        /* (y) up, left        (7) */
  1495. X      move_char(7, do_pickup);
  1496. X      break;
  1497. X    case 'k':        /* (k) up        (8) */
  1498. X      move_char(8, do_pickup);
  1499. X      break;
  1500. X    case 'u':        /* (u) up, right    (9) */
  1501. X      move_char(9, do_pickup);
  1502. X      break;
  1503. X    case 'B':        /* (B) run down, left    (. 1) */
  1504. X      find_init(1);
  1505. X      break;
  1506. X    case 'J':        /* (J) run down        (. 2) */
  1507. X      find_init(2);
  1508. X      break;
  1509. X    case 'N':        /* (N) run down, right    (. 3) */
  1510. X      find_init(3);
  1511. X      break;
  1512. X    case 'H':        /* (H) run left        (. 4) */
  1513. X      find_init(4);
  1514. X      break;
  1515. X    case 'L':        /* (L) run right    (. 6) */
  1516. X      find_init(6);
  1517. X      break;
  1518. X    case 'Y':        /* (Y) run up, left    (. 7) */
  1519. X      find_init(7);
  1520. X      break;
  1521. X    case 'K':        /* (K) run up        (. 8) */
  1522. X      find_init(8);
  1523. X      break;
  1524. X    case 'U':        /* (U) run up, right    (. 9) */
  1525. X      find_init(9);
  1526. X      break;
  1527. X    case '/':        /* (/) identify a symbol */
  1528. X      ident_char();
  1529. X      free_turn_flag = TRUE;
  1530. X      break;
  1531. X    case '.':        /* (.) stay in one place (5) */
  1532. X      move_char (5, do_pickup);
  1533. X      if (command_count > 1)
  1534. X    {
  1535. X      command_count--;
  1536. X      rest();
  1537. X    }
  1538. X      break;
  1539. X    case '<':        /* (<) go down a staircase */
  1540. X      go_up();
  1541. X      break;
  1542. X    case '>':        /* (>) go up a staircase */
  1543. X      go_down();
  1544. X      break;
  1545. X    case '?':        /* (?) help with commands */
  1546. X      if (rogue_like_commands)
  1547. X    helpfile(MORIA_HELP);
  1548. X      else
  1549. X    helpfile(MORIA_ORIG_HELP);
  1550. X      free_turn_flag = TRUE;
  1551. X      break;
  1552. X    case 'f':        /* (f)orce        (B)ash */
  1553. X      bash();
  1554. X      break;
  1555. X    case 'C':        /* (C)haracter description */
  1556. X      save_screen();
  1557. X      change_name();
  1558. X      restore_screen();
  1559. X      free_turn_flag = TRUE;
  1560. X      break;
  1561. X    case 'D':        /* (D)isarm trap */
  1562. X      disarm_trap();
  1563. X      break;
  1564. X    case 'E':        /* (E)at food */
  1565. X      eat();
  1566. X      break;
  1567. X    case 'F':        /* (F)ill lamp */
  1568. X      refill_lamp();
  1569. X      break;
  1570. X    case 'G':        /* (G)ain magic spells */
  1571. X      gain_spells();
  1572. X      break;
  1573. X    case 'V':        /* (V)iew scores */
  1574. X      if (last_command != 'V')
  1575. X    i = TRUE;
  1576. X      else
  1577. X    i = FALSE;
  1578. X      save_screen();
  1579. X      display_scores(i);
  1580. X      restore_screen();
  1581. X      free_turn_flag = TRUE;
  1582. X      break;
  1583. X    case 'W':        /* (W)here are we on the map    (L)ocate on map */
  1584. X      if ((py.flags.blind > 0) || no_light())
  1585. X    msg_print("You can't see your map.");
  1586. X      else
  1587. X    {
  1588. X      int cy, cx, p_y, p_x;
  1589. X
  1590. X      y = char_row;
  1591. X      x = char_col;
  1592. X      if (get_panel(y, x, TRUE))
  1593. X        prt_map();
  1594. X      cy = panel_row;
  1595. X      cx = panel_col;
  1596. X      for(;;)
  1597. X        {
  1598. X          p_y = panel_row;
  1599. X          p_x = panel_col;
  1600. X          if (p_y == cy && p_x == cx)
  1601. X        tmp_str[0] = '\0';
  1602. X          else
  1603. X        (void) sprintf(tmp_str, "%s%s of",
  1604. X                   p_y < cy ? " North" : p_y > cy ? " South" : "",
  1605. X                   p_x < cx ? " West" : p_x > cx ? " East" : "");
  1606. X          (void) sprintf(out_val,
  1607. X       "Map sector [%d,%d], which is%s your sector. Look which direction?",
  1608. X                 p_y, p_x, tmp_str);
  1609. X          if (!get_dir(out_val, &dir_val))
  1610. X        break;
  1611. X/*                                      -CJS-
  1612. X// Should really use the move function, but what the hell. This
  1613. X// is nicer, as it moves exactly to the same place in another
  1614. X// section. The direction calculation is not intuitive. Sorry.
  1615. X*/
  1616. X          for(;;){
  1617. X        x += ((dir_val-1)%3 - 1) * SCREEN_WIDTH/2;
  1618. X        y -= ((dir_val-1)/3 - 1) * SCREEN_HEIGHT/2;
  1619. X        if (x < 0 || y < 0 || x >= cur_width || y >= cur_width)
  1620. X          {
  1621. X            msg_print("You've gone past the end of your map.");
  1622. X            x -= ((dir_val-1)%3 - 1) * SCREEN_WIDTH/2;
  1623. X            y += ((dir_val-1)/3 - 1) * SCREEN_HEIGHT/2;
  1624. X            break;
  1625. X          }
  1626. X        if (get_panel(y, x, TRUE))
  1627. X          {
  1628. X            prt_map();
  1629. X            break;
  1630. X          }
  1631. X          }
  1632. X        }
  1633. X      /* Move to a new panel - but only if really necessary. */
  1634. X      if (get_panel(char_row, char_col, FALSE))
  1635. X        prt_map();
  1636. X    }
  1637. X      free_turn_flag = TRUE;
  1638. X      break;
  1639. X    case 'R':        /* (R)est a while */
  1640. X      rest();
  1641. X      break;
  1642. X    case '#':        /* (#) search toggle    (S)earch toggle */
  1643. X      if (py.flags.status & PY_SEARCH)
  1644. X    search_off();
  1645. X      else
  1646. X    search_on();
  1647. X      free_turn_flag = TRUE;
  1648. X      break;
  1649. X    case CTRL('B'):        /* (^B) tunnel down left    (T 1) */
  1650. X      tunnel(1);
  1651. X      break;
  1652. X    case CTRL('M'):        /* cr must be treated same as lf. */
  1653. X    case CTRL('J'):        /* (^J) tunnel down        (T 2) */
  1654. X      tunnel(2);
  1655. X      break;
  1656. X    case CTRL('N'):        /* (^N) tunnel down right    (T 3) */
  1657. X      tunnel(3);
  1658. X      break;
  1659. X    case CTRL('H'):        /* (^H) tunnel left        (T 4) */
  1660. X      tunnel(4);
  1661. X      break;
  1662. X    case CTRL('L'):        /* (^L) tunnel right        (T 6) */
  1663. X      tunnel(6);
  1664. X      break;
  1665. X    case CTRL('Y'):        /* (^Y) tunnel up left        (T 7) */
  1666. X      tunnel(7);
  1667. X      break;
  1668. X    case CTRL('K'):        /* (^K) tunnel up        (T 8) */
  1669. X      tunnel(8);
  1670. X      break;
  1671. X    case CTRL('U'):        /* (^U) tunnel up right        (T 9) */
  1672. X      tunnel(9);
  1673. X      break;
  1674. X    case 'z':        /* (z)ap a wand        (a)im a wand */
  1675. X      aim();
  1676. X      break;
  1677. X    case 'M':
  1678. X      screen_map();
  1679. X      free_turn_flag = TRUE;
  1680. X      break;
  1681. X    case 'P':        /* (P)eruse a book    (B)rowse in a book */
  1682. X      examine_book();
  1683. X      free_turn_flag = TRUE;
  1684. X      break;
  1685. X    case 'c':        /* (c)lose an object */
  1686. X      closeobject();
  1687. X      break;
  1688. X    case 'd':        /* (d)rop something */
  1689. X      inven_command('d');
  1690. X      break;
  1691. X    case 'e':        /* (e)quipment list */
  1692. X      inven_command('e');
  1693. X      break;
  1694. X    case 't':        /* (t)hrow something    (f)ire something */
  1695. X      throw_object();
  1696. X      break;
  1697. X    case 'i':        /* (i)nventory list */
  1698. X      inven_command('i');
  1699. X      break;
  1700. X    case 'S':        /* (S)pike a door    (j)am a door */
  1701. X      jamdoor();
  1702. X      break;
  1703. X    case 'x':        /* e(x)amine surrounds    (l)ook about */
  1704. X      look();
  1705. X      free_turn_flag = TRUE;
  1706. X      break;
  1707. X    case 'm':        /* (m)agic spells */
  1708. X      cast();
  1709. X      break;
  1710. X    case 'o':        /* (o)pen something */
  1711. X      openobject();
  1712. X      break;
  1713. X    case 'p':        /* (p)ray */
  1714. X      pray();
  1715. X      break;
  1716. X    case 'q':        /* (q)uaff */
  1717. X      quaff();
  1718. X      break;
  1719. X    case 'r':        /* (r)ead */
  1720. X      read_scroll();
  1721. X      break;
  1722. X    case 's':        /* (s)earch for a turn */
  1723. X      search(char_row, char_col, py.misc.srh);
  1724. X      break;
  1725. X    case 'T':        /* (T)ake off something    (t)ake off */
  1726. X      inven_command('t');
  1727. X      break;
  1728. X    case 'Z':        /* (Z)ap a staff    (u)se a staff */
  1729. X      use();
  1730. X      break;
  1731. X    case 'v':        /* (v)ersion of game */
  1732. X      helpfile(MORIA_VER);
  1733. X      free_turn_flag = TRUE;
  1734. X      break;
  1735. X    case 'w':        /* (w)ear or wield */
  1736. X      inven_command('w');
  1737. X      break;
  1738. X    case 'X':        /* e(X)change weapons    e(x)change */
  1739. X      inven_command('x');
  1740. X      break;
  1741. X    default:
  1742. X      if (wizard)
  1743. X    {
  1744. X      free_turn_flag = TRUE; /* Wizard commands are free moves*/
  1745. X      switch(com_val)
  1746. X        {
  1747. X        case CTRL('A'):    /*^A = Cure all*/
  1748. X          (void) remove_curse();
  1749. X          (void) cure_blindness();
  1750. X          (void) cure_confusion();
  1751. X          (void) cure_poison();
  1752. X          (void) remove_fear();
  1753. X          (void) res_stat(A_STR);
  1754. X          (void) res_stat(A_INT);
  1755. X          (void) res_stat(A_WIS);
  1756. X          (void) res_stat(A_CON);
  1757. X          (void) res_stat(A_DEX);
  1758. X          (void) res_stat(A_CHR);
  1759. X          f_ptr = &py.flags;
  1760. X          if (f_ptr->slow > 1)
  1761. X        f_ptr->slow = 1;
  1762. X          if (f_ptr->image > 1)
  1763. X        f_ptr->image = 1;
  1764. X          break;
  1765. X        case CTRL('E'):    /*^E = wizchar */
  1766. X          change_character();
  1767. X          erase_line(MSG_LINE, 0);
  1768. X          break;
  1769. X        case CTRL('F'):    /*^F = genocide*/
  1770. X          (void) mass_genocide();
  1771. X          break;
  1772. X        case CTRL('G'):    /*^G = treasure*/
  1773. X          if (command_count > 0)
  1774. X        {
  1775. X          i = command_count;
  1776. X          command_count = 0;
  1777. X        }
  1778. X          else
  1779. X        i = 1;
  1780. X          random_object(char_row, char_col, i);
  1781. X          prt_map();
  1782. X          break;
  1783. X        case CTRL('D'):    /*^D = up/down */
  1784. X          if (command_count > 0)
  1785. X        {
  1786. X          if (command_count > 99)
  1787. X            i = 0;
  1788. X          else
  1789. X            i = command_count;
  1790. X          command_count = 0;
  1791. X        }
  1792. X          else
  1793. X        {
  1794. X          prt("Go to which level (0-99) ? ", 0, 0);
  1795. X          i = -1;
  1796. X          if (get_string(tmp_str, 0, 27, 10))
  1797. X            i = atoi(tmp_str);
  1798. X        }
  1799. X          if (i > -1)
  1800. X        {
  1801. X          dun_level = i;
  1802. X          if (dun_level > 99)
  1803. X            dun_level = 99;
  1804. X          new_level_flag = TRUE;
  1805. X        }
  1806. X          else
  1807. X        erase_line(MSG_LINE, 0);
  1808. X          break;
  1809. X        case CTRL('O'):    /*^O = objects */
  1810. X          print_objects();
  1811. X          break;
  1812. X        case '\\': /* \ wizard help */
  1813. X          if (rogue_like_commands)
  1814. X        helpfile(MORIA_WIZ_HELP);
  1815. X          else
  1816. X        helpfile(MORIA_OWIZ_HELP);
  1817. X          break;
  1818. X        case CTRL('I'):    /*^I = identify*/
  1819. X          (void) ident_spell();
  1820. X          break;
  1821. X        case '*':
  1822. X          wizard_light();
  1823. X          break;
  1824. X        case ':':
  1825. X          map_area();
  1826. X          break;
  1827. X        case CTRL('T'):    /*^T = teleport*/
  1828. X          teleport(100);
  1829. X          break;
  1830. X        case '+':
  1831. X          if (command_count > 0)
  1832. X        {
  1833. X          py.misc.exp = command_count;
  1834. X          command_count = 0;
  1835. X        }
  1836. X          else if (py.misc.exp == 0)
  1837. X        py.misc.exp = 1;
  1838. X          else
  1839. X        py.misc.exp = py.misc.exp * 2;
  1840. X          prt_experience();
  1841. X          break;
  1842. X        case '&':    /*& = summon  */
  1843. X          y = char_row;
  1844. X          x = char_col;
  1845. X          (void) summon_monster(&y, &x, TRUE);
  1846. X          creatures(FALSE);
  1847. X          break;
  1848. X        case '@':
  1849. X          wizard_create();
  1850. X          break;
  1851. X        default:
  1852. X          if (rogue_like_commands)
  1853. X        prt("Type '?' or '\\' for help.", 0, 0);
  1854. X          else
  1855. X        prt("Type '?' or ^H for help.", 0, 0);
  1856. X        }
  1857. X    }
  1858. X      else
  1859. X    {
  1860. X      prt("Type '?' for help.", 0, 0);
  1861. X      free_turn_flag = TRUE;
  1862. X    }
  1863. X    }
  1864. X  last_command = com_val;
  1865. X}
  1866. X
  1867. X/* Check whether this command will accept a count.     -CJS-  */
  1868. Xstatic int valid_countcommand(c)
  1869. Xchar c;
  1870. X{
  1871. X  switch(c)
  1872. X    {
  1873. X    case 'Q':
  1874. X    case CTRL('W'):
  1875. X    case CTRL('X'):
  1876. X    case '=':
  1877. X    case '{':
  1878. X    case '/':
  1879. X    case '<':
  1880. X    case '>':
  1881. X    case '?':
  1882. X    case 'C':
  1883. X    case 'E':
  1884. X    case 'F':
  1885. X    case 'G':
  1886. X    case 'V':
  1887. X    case '#':
  1888. X    case 'z':
  1889. X    case 'P':
  1890. X    case 'c':
  1891. X    case 'd':
  1892. X    case 'e':
  1893. X    case 't':
  1894. X    case 'i':
  1895. X    case 'x':
  1896. X    case 'm':
  1897. X    case 'p':
  1898. X    case 'q':
  1899. X    case 'r':
  1900. X    case 'T':
  1901. X    case 'Z':
  1902. X    case 'v':
  1903. X    case 'w':
  1904. X    case 'W':
  1905. X    case 'X':
  1906. X    case CTRL('A'):
  1907. X    case '\\':
  1908. X    case CTRL('I'):
  1909. X    case '*':
  1910. X    case ':':
  1911. X    case CTRL('T'):
  1912. X    case CTRL('E'):
  1913. X    case CTRL('F'):
  1914. X    case CTRL('S'):
  1915. X    case CTRL('Q'):
  1916. X      return FALSE;
  1917. X    case CTRL('P'):
  1918. X    case ESCAPE:
  1919. X    case ' ':
  1920. X    case '-':
  1921. X    case 'b':
  1922. X    case 'f':
  1923. X    case 'j':
  1924. X    case 'n':
  1925. X    case 'h':
  1926. X    case 'l':
  1927. X    case 'y':
  1928. X    case 'k':
  1929. X    case 'u':
  1930. X    case '.':
  1931. X    case 'B':
  1932. X    case 'J':
  1933. X    case 'N':
  1934. X    case 'H':
  1935. X    case 'L':
  1936. X    case 'Y':
  1937. X    case 'K':
  1938. X    case 'U':
  1939. X    case 'D':
  1940. X    case 'R':
  1941. X    case CTRL('Y'):
  1942. X    case CTRL('K'):
  1943. X    case CTRL('U'):
  1944. X    case CTRL('L'):
  1945. X    case CTRL('N'):
  1946. X    case CTRL('J'):
  1947. X    case CTRL('B'):
  1948. X    case CTRL('H'):
  1949. X    case 'S':
  1950. X    case 'o':
  1951. X    case 's':
  1952. X    case CTRL('D'):
  1953. X    case CTRL('G'):
  1954. X    case '+':
  1955. X      return TRUE;
  1956. X    default:
  1957. X      return FALSE;
  1958. X    }
  1959. X}
  1960. X
  1961. X
  1962. X/* Regenerate hit points                -RAK-    */
  1963. Xstatic void regenhp(percent)
  1964. Xint percent;
  1965. X{
  1966. X  register struct misc *p_ptr;
  1967. X  register int32 new_chp, new_chp_frac;
  1968. X  int old_chp;
  1969. X
  1970. X  p_ptr = &py.misc;
  1971. X  old_chp = p_ptr->chp;
  1972. X  new_chp = ((long)p_ptr->mhp) * percent + PLAYER_REGEN_HPBASE;
  1973. X  p_ptr->chp += new_chp >> 16;    /* div 65536 */
  1974. X  /* check for overflow */
  1975. X  if (p_ptr->chp < 0 && old_chp > 0)
  1976. X    p_ptr->chp = MAX_SHORT;
  1977. X  new_chp_frac = (new_chp & 0xFFFF) + p_ptr->chp_frac; /* mod 65536 */
  1978. X  if (new_chp_frac >= 0x10000L)
  1979. X    {
  1980. X      p_ptr->chp_frac = new_chp_frac - 0x10000L;
  1981. X      p_ptr->chp++;
  1982. X    }
  1983. X  else
  1984. X    p_ptr->chp_frac = new_chp_frac;
  1985. X
  1986. X  /* must set frac to zero even if equal */
  1987. X  if (p_ptr->chp >= p_ptr->mhp)
  1988. X    {
  1989. X      p_ptr->chp = p_ptr->mhp;
  1990. X      p_ptr->chp_frac = 0;
  1991. X    }
  1992. X  if (old_chp != p_ptr->chp)
  1993. X    prt_chp();
  1994. X}
  1995. X
  1996. X
  1997. X/* Regenerate mana points                -RAK-    */
  1998. Xstatic void regenmana(percent)
  1999. Xint percent;
  2000. X{
  2001. X  register struct misc *p_ptr;
  2002. X  register int32 new_mana, new_mana_frac;
  2003. X  int old_cmana;
  2004. X
  2005. X  p_ptr = &py.misc;
  2006. X  old_cmana = p_ptr->cmana;
  2007. X  new_mana = ((long)p_ptr->mana) * percent + PLAYER_REGEN_MNBASE;
  2008. X  p_ptr->cmana += new_mana >> 16;  /* div 65536 */
  2009. X  /* check for overflow */
  2010. X  if (p_ptr->cmana < 0 && old_cmana > 0)
  2011. X    p_ptr->cmana = MAX_SHORT;
  2012. X  new_mana_frac = (new_mana & 0xFFFF) + p_ptr->cmana_frac; /* mod 65536 */
  2013. X  if (new_mana_frac >= 0x10000L)
  2014. X    {
  2015. X      p_ptr->cmana_frac = new_mana_frac - 0x10000L;
  2016. X      p_ptr->cmana++;
  2017. X    }
  2018. X  else
  2019. X    p_ptr->cmana_frac = new_mana_frac;
  2020. X
  2021. X  /* must set frac to zero even if equal */
  2022. X  if (p_ptr->cmana >= p_ptr->mana)
  2023. X    {
  2024. X      p_ptr->cmana = p_ptr->mana;
  2025. X      p_ptr->cmana_frac = 0;
  2026. X    }
  2027. X  if (old_cmana != p_ptr->cmana)
  2028. X    prt_cmana();
  2029. X}
  2030. X
  2031. X
  2032. X/* Is an item an enchanted weapon or armor and we don't know?  -CJS- */
  2033. X/* only returns true if it is a good enchantment */
  2034. Xstatic int enchanted (t_ptr)
  2035. Xregister inven_type *t_ptr;
  2036. X{
  2037. X#ifdef ATARIST_MWC
  2038. X  int32u holder;
  2039. X#endif
  2040. X
  2041. X  if (t_ptr->tval < TV_MIN_ENCHANT || t_ptr->tval > TV_MAX_ENCHANT
  2042. X#ifdef ATARIST_MWC
  2043. X      || t_ptr->flags & (holder = TR_CURSED))
  2044. X#else
  2045. X      || t_ptr->flags & TR_CURSED)
  2046. X#endif
  2047. X    return FALSE;
  2048. X  if (known2_p(t_ptr))
  2049. X    return FALSE;
  2050. X  if (t_ptr->ident & ID_MAGIK)
  2051. X    return FALSE;
  2052. X  if (t_ptr->tohit > 0 || t_ptr->todam > 0 || t_ptr->toac > 0)
  2053. X    return TRUE;
  2054. X  if ((0x4000107fL & t_ptr->flags) && t_ptr->p1 > 0)
  2055. X    return TRUE;
  2056. X  if (0x07ffe980L & t_ptr->flags)
  2057. X    return TRUE;
  2058. X
  2059. X  return FALSE;
  2060. X}
  2061. X
  2062. X
  2063. X/* Examine a Book                    -RAK-    */
  2064. Xstatic void examine_book()
  2065. X{
  2066. X  int32u j;
  2067. X  int i, k, item_val, flag;
  2068. X  int spell_index[31];
  2069. X  register inven_type *i_ptr;
  2070. X  register spell_type *s_ptr;
  2071. X
  2072. X  if (!find_range(TV_MAGIC_BOOK, TV_PRAYER_BOOK, &i, &k))
  2073. X    msg_print("You are not carrying any books.");
  2074. X  else if (py.flags.blind > 0)
  2075. X    msg_print("You can't see to read your spell book!");
  2076. X  else if (no_light())
  2077. X    msg_print("You have no light to read by.");
  2078. X  else if (py.flags.confused > 0)
  2079. X    msg_print("You are too confused.");
  2080. X  else if (get_item(&item_val, "Which Book?", i, k, CNIL, CNIL))
  2081. X    {
  2082. X      flag = TRUE;
  2083. X      i_ptr = &inventory[item_val];
  2084. X      if (class[py.misc.pclass].spell == MAGE)
  2085. X    {
  2086. X      if (i_ptr->tval != TV_MAGIC_BOOK)
  2087. X        flag = FALSE;
  2088. X    }
  2089. X      else if (class[py.misc.pclass].spell == PRIEST)
  2090. X    {
  2091. X      if (i_ptr->tval != TV_PRAYER_BOOK)
  2092. X        flag = FALSE;
  2093. X    }
  2094. X      else
  2095. X    flag = FALSE;
  2096. X
  2097. X      if (!flag)
  2098. X    msg_print("You do not understand the language.");
  2099. X      else
  2100. X    {
  2101. X      i = 0;
  2102. X      j = inventory[item_val].flags;
  2103. X      while (j)
  2104. X        {
  2105. X          k = bit_pos(&j);
  2106. X          s_ptr = &magic_spell[py.misc.pclass-1][k];
  2107. X          if (s_ptr->slevel < 99)
  2108. X        {
  2109. X          spell_index[i] = k;
  2110. X          i++;
  2111. X        }
  2112. X        }
  2113. X      save_screen();
  2114. X      print_spells(spell_index, i, TRUE, -1);
  2115. X      pause_line(0);
  2116. X      restore_screen();
  2117. X    }
  2118. X    }
  2119. X}
  2120. X
  2121. X
  2122. X/* Go up one level                    -RAK-    */
  2123. Xstatic void go_up()
  2124. X{
  2125. X  register cave_type *c_ptr;
  2126. X  register int no_stairs = FALSE;
  2127. X
  2128. X  c_ptr = &cave[char_row][char_col];
  2129. X  if (c_ptr->tptr != 0)
  2130. X    if (t_list[c_ptr->tptr].tval == TV_UP_STAIR)
  2131. X      {
  2132. X    dun_level--;
  2133. X    new_level_flag = TRUE;
  2134. X    msg_print("You enter a maze of up staircases.");
  2135. X    msg_print("You pass through a one-way door.");
  2136. X      }
  2137. X    else
  2138. X      no_stairs = TRUE;
  2139. X  else
  2140. X    no_stairs = TRUE;
  2141. X
  2142. X  if (no_stairs)
  2143. X    {
  2144. X      msg_print("I see no up staircase here.");
  2145. X      free_turn_flag = TRUE;
  2146. X    }
  2147. X}
  2148. X
  2149. X
  2150. X/* Go down one level                    -RAK-    */
  2151. Xstatic void go_down()
  2152. X{
  2153. X  register cave_type *c_ptr;
  2154. X  register int no_stairs = FALSE;
  2155. X
  2156. X  c_ptr = &cave[char_row][char_col];
  2157. X  if (c_ptr->tptr != 0)
  2158. X    if (t_list[c_ptr->tptr].tval == TV_DOWN_STAIR)
  2159. X      {
  2160. X    dun_level++;
  2161. X    new_level_flag = TRUE;
  2162. X    msg_print("You enter a maze of down staircases.");
  2163. X    msg_print("You pass through a one-way door.");
  2164. X      }
  2165. X    else
  2166. X      no_stairs = TRUE;
  2167. X  else
  2168. X    no_stairs = TRUE;
  2169. X
  2170. X  if (no_stairs)
  2171. X    {
  2172. X      msg_print("I see no down staircase here.");
  2173. X      free_turn_flag = TRUE;
  2174. X    }
  2175. X}
  2176. X
  2177. X
  2178. X/* Jam a closed door                    -RAK-    */
  2179. Xstatic void jamdoor()
  2180. X{
  2181. X  int y, x, dir, i, j;
  2182. X  register cave_type *c_ptr;
  2183. X  register inven_type *t_ptr, *i_ptr;
  2184. X  char tmp_str[80];
  2185. X
  2186. X  free_turn_flag = TRUE;
  2187. X  y = char_row;
  2188. X  x = char_col;
  2189. X  if (get_dir(CNIL, &dir))
  2190. X    {
  2191. X      (void) mmove(dir, &y, &x);
  2192. X      c_ptr = &cave[y][x];
  2193. X      if (c_ptr->tptr != 0)
  2194. X    {
  2195. X      t_ptr = &t_list[c_ptr->tptr];
  2196. X      if (t_ptr->tval == TV_CLOSED_DOOR)
  2197. X        if (c_ptr->cptr == 0)
  2198. X          {
  2199. X        if (find_range(TV_SPIKE, TV_NEVER, &i, &j))
  2200. X          {
  2201. X            free_turn_flag = FALSE;
  2202. X            count_msg_print("You jam the door with a spike.");
  2203. X            if (t_ptr->p1 > 0)
  2204. X              t_ptr->p1 = -t_ptr->p1;    /* Make locked to stuck. */
  2205. X            /* Successive spikes have a progressively smaller effect.
  2206. X               Series is: 0 20 30 37 43 48 52 56 60 64 67 70 ... */
  2207. X            t_ptr->p1 -= 1 + 190 / (10 - t_ptr->p1);
  2208. X            i_ptr = &inventory[i];
  2209. X            if (i_ptr->number > 1)
  2210. X              {
  2211. X            i_ptr->number--;
  2212. X            inven_weight -= i_ptr->weight;
  2213. X              }
  2214. X            else
  2215. X              inven_destroy(i);
  2216. X          }
  2217. X        else
  2218. X          msg_print("But you have no spikes.");
  2219. X          }
  2220. X        else
  2221. X          {
  2222. X        free_turn_flag = FALSE;
  2223. X        (void) sprintf(tmp_str, "The %s is in your way!",
  2224. X                   c_list[m_list[c_ptr->cptr].mptr].name);
  2225. X        msg_print(tmp_str);
  2226. X          }
  2227. X      else if (t_ptr->tval == TV_OPEN_DOOR)
  2228. X        msg_print("The door must be closed first.");
  2229. X      else
  2230. X        msg_print("That isn't a door!");
  2231. X    }
  2232. X      else
  2233. X    msg_print("That isn't a door!");
  2234. X    }
  2235. X}
  2236. X
  2237. X
  2238. X/* Refill the players lamp                -RAK-    */
  2239. Xstatic void refill_lamp()
  2240. X{
  2241. X  int i, j;
  2242. X  register int k;
  2243. X  register inven_type *i_ptr;
  2244. X
  2245. X  free_turn_flag = TRUE;
  2246. X  k = inventory[INVEN_LIGHT].subval;
  2247. X  if (k != 0)
  2248. X    msg_print("But you are not using a lamp.");
  2249. X  else if (!find_range(TV_FLASK, TV_NEVER, &i, &j))
  2250. X    msg_print("You have no oil.");
  2251. X  else
  2252. X    {
  2253. X      free_turn_flag = FALSE;
  2254. X      i_ptr = &inventory[INVEN_LIGHT];
  2255. X      i_ptr->p1 += inventory[i].p1;
  2256. X      if (i_ptr->p1 > OBJ_LAMP_MAX)
  2257. X    {
  2258. X      i_ptr->p1 = OBJ_LAMP_MAX;
  2259. X      msg_print ("Your lamp overflows, spilling oil on the ground.");
  2260. X      msg_print("Your lamp is full.");
  2261. X    }
  2262. X      else if (i_ptr->p1 > OBJ_LAMP_MAX/2)
  2263. X    msg_print ("Your lamp is more than half full.");
  2264. X      else if (i_ptr->p1 == OBJ_LAMP_MAX/2)
  2265. X    msg_print ("Your lamp is half full.");
  2266. X      else
  2267. X    msg_print ("Your lamp is less than half full.");
  2268. X      desc_remain(i);
  2269. X      inven_destroy(i);
  2270. X    }
  2271. X}
  2272. END_OF_FILE
  2273. if test 49774 -ne `wc -c <'source/dungeon.c'`; then
  2274.     echo shar: \"'source/dungeon.c'\" unpacked with wrong size!
  2275. fi
  2276. # end of 'source/dungeon.c'
  2277. fi
  2278. echo shar: End of archive 4 \(of 39\).
  2279. cp /dev/null ark4isdone
  2280. MISSING=""
  2281. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 ; do
  2282.     if test ! -f ark${I}isdone ; then
  2283.     MISSING="${MISSING} ${I}"
  2284.     fi
  2285. done
  2286. if test "${MISSING}" = "" ; then
  2287.     echo You have unpacked all 39 archives.
  2288.     echo "Now run "bldfiles.sh" to build split files"
  2289.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2290. else
  2291.     echo You still need to unpack the following archives:
  2292.     echo "        " ${MISSING}
  2293. fi
  2294. ##  End of shell archive.
  2295. exit 0
  2296.