home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #18 / NN_1992_18.iso / spool / comp / sources / games / 180 < prev    next >
Encoding:
Internet Message Format  |  1992-08-20  |  56.8 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: v14i050:  umoria4 - single player dungeon simulation (ver. 5.5), Part18/39
  5. Message-ID: <3408@master.CNA.TEK.COM>
  6. Date: 20 Aug 92 18:05:51 GMT
  7. Sender: news@master.CNA.TEK.COM
  8. Lines: 1980
  9. Approved: billr@saab.CNA.TEK.COM
  10.  
  11. Submitted-by: grabiner@math.harvard.edu (David Grabiner)
  12. Posting-number: Volume 14, Issue 50
  13. Archive-name: umoria4/Part18
  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 18 (of 39)."
  26. # Contents:  source/player.c source/spells.c.1 util/mc/st.h
  27. # Wrapped by billr@saab on Thu Aug 20 09:11:30 1992
  28. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  29. if test -f 'source/player.c' -a "${1}" != "-c" ; then 
  30.   echo shar: Will not clobber existing file \"'source/player.c'\"
  31. else
  32. echo shar: Extracting \"'source/player.c'\" \(19531 characters\)
  33. sed "s/^X//" >'source/player.c' <<'END_OF_FILE'
  34. X/* source/player.c: player specific variable definitions
  35. X
  36. X   Copyright (c) 1989-92 James E. Wilson, Robert A. Koeneke
  37. X
  38. X   This software may be copied and distributed for educational, research, and
  39. X   not for profit purposes provided that this copyright and statement are
  40. X   included in all such copies. */
  41. X
  42. X#include "config.h"
  43. X#include "constant.h"
  44. X#include "types.h"
  45. X
  46. X/* Player record for most player related info */
  47. Xplayer_type py;
  48. X/* player location in dungeon */
  49. Xint16 char_row;
  50. Xint16 char_col;
  51. X/* calculated base hp values for player at each level, store them so that
  52. X   drain life + restore life does not affect hit points */
  53. Xint16u player_hp[MAX_PLAYER_LEVEL];
  54. X
  55. X/* Class titles for different levels                */
  56. X#ifdef MACGAME
  57. Xchar *(*player_title)[MAX_PLAYER_LEVEL];
  58. X#else
  59. Xchar *player_title[MAX_CLASS][MAX_PLAYER_LEVEL] = {
  60. X    /* Warrior     */
  61. X{"Rookie","Private","Soldier","Mercenary","Veteran(1st)","Veteran(2nd)",
  62. X"Veteran(3rd)","Warrior(1st)","Warrior(2nd)","Warrior(3rd)","Warrior(4th)",
  63. X"Swordsman-1","Swordsman-2","Swordsman-3","Hero","Swashbuckler","Myrmidon",
  64. X"Champion-1","Champion-2","Champion-3","Superhero","Knight","Superior Knt",
  65. X"Gallant Knt","Knt Errant","Guardian Knt","Baron","Duke","Lord (1st)",
  66. X"Lord (2nd)","Lord (3rd)","Lord (4th)","Lord (5th)","Lord (6th)","Lord (7th)",
  67. X"Lord (8th)","Lord (9th)","Lord Gallant","Lord Keeper","Lord Noble"},
  68. X    /* Mage         */
  69. X{"Novice","Apprentice","Trickster-1","Trickster-2","Trickster-3","Cabalist-1",
  70. X"Cabalist-2","Cabalist-3","Visionist","Phantasmist","Shadowist","Spellbinder",
  71. X"Illusionist","Evoker (1st)","Evoker (2nd)","Evoker (3rd)","Evoker (4th)",
  72. X"Conjurer","Theurgist","Thaumaturge","Magician","Enchanter","Warlock",
  73. X"Sorcerer","Necromancer","Mage (1st)","Mage (2nd)","Mage (3rd)","Mage (4th)",
  74. X"Mage (5th)","Wizard (1st)","Wizard (2nd)","Wizard (3rd)","Wizard (4th)",
  75. X"Wizard (5th)","Wizard (6th)","Wizard (7th)","Wizard (8th)","Wizard (9th)",
  76. X"Wizard Lord"},
  77. X    /* Priests     */
  78. X{"Believer","Acolyte(1st)","Acolyte(2nd)","Acolyte(3rd)","Adept (1st)",
  79. X"Adept (2nd)","Adept (3rd)","Priest (1st)","Priest (2nd)","Priest (3rd)",
  80. X"Priest (4th)","Priest (5th)","Priest (6th)","Priest (7th)","Priest (8th)",
  81. X"Priest (9th)","Curate (1st)","Curate (2nd)","Curate (3rd)","Curate (4th)",
  82. X"Curate (5th)","Curate (6th)","Curate (7th)","Curate (8th)","Curate (9th)",
  83. X"Canon (1st)","Canon (2nd)","Canon (3rd)","Canon (4th)","Canon (5th)",
  84. X"Low Lama","Lama-1","Lama-2","Lama-3","High Lama","Great Lama","Patriarch",
  85. X"High Priest","Great Priest","Noble Priest"},
  86. X    /* Rogues     */
  87. X{"Vagabond","Footpad","Cutpurse","Robber","Burglar","Filcher","Sharper",
  88. X"Magsman","Common Rogue","Rogue (1st)","Rogue (2nd)","Rogue (3rd)",
  89. X"Rogue (4th)","Rogue (5th)","Rogue (6th)","Rogue (7th)","Rogue (8th)",
  90. X"Rogue (9th)","Master Rogue","Expert Rogue","Senior Rogue","Chief Rogue",
  91. X"Prime Rogue","Low Thief","Thief (1st)","Thief (2nd)","Thief (3rd)",
  92. X"Thief (4th)","Thief (5th)","Thief (6th)","Thief (7th)","Thief (8th)",
  93. X"Thief (9th)","High Thief","Master Thief","Executioner","Low Assassin",
  94. X"Assassin","High Assassin","Guildsmaster"},
  95. X    /* Rangers     */
  96. X{"Runner (1st)","Runner (2nd)","Runner (3rd)","Strider (1st)","Strider (2nd)",
  97. X"Strider (3rd)","Scout (1st)","Scout (2nd)","Scout (3rd)","Scout (4th)",
  98. X"Scout (5th)","Courser (1st)","Courser (2nd)","Courser (3rd)","Courser (4th)",
  99. X"Courser (5th)","Tracker (1st)","Tracker (2nd)","Tracker (3rd)",
  100. X"Tracker (4th)","Tracker (5th)","Tracker (6th)","Tracker (7th)",
  101. X"Tracker (8th)","Tracker (9th)","Guide (1st)","Guide (2nd)","Guide (3rd)",
  102. X"Guide (4th)","Guide (5th)","Guide (6th)","Guide (7th)","Guide (8th)",
  103. X"Guide (9th)","Pathfinder-1","Pathfinder-2","Pathfinder-3","Ranger",
  104. X"High Ranger","Ranger Lord"},
  105. X    /* Paladins     */
  106. X{"Gallant","Keeper (1st)","Keeper (2nd)","Keeper (3rd)","Keeper (4th)",
  107. X"Keeper (5th)","Keeper (6th)","Keeper (7th)","Keeper (8th)","Keeper (9th)",
  108. X"Protector-1","Protector-2","Protector-3","Protector-4","Protector-5",
  109. X"Protector-6","Protector-7","Protector-8","Defender-1","Defender-2",
  110. X"Defender-3","Defender-4","Defender-5","Defender-6","Defender-7","Defender-8",
  111. X"Warder (1st)","Warder (2nd)","Warder (3rd)","Warder (4th)","Warder (5th)",
  112. X"Warder (6th)","Warder (7th)","Warder (8th)","Warder (9th)","Guardian",
  113. X"Chevalier","Justiciar","Paladin","High Lord"}
  114. X};
  115. X#endif
  116. X
  117. X/* Base experience levels, may be adjusted up for race and/or class*/
  118. Xint32u player_exp[MAX_PLAYER_LEVEL] = {
  119. X      10,      25,    45,     70,      100,        140,      200,    280,
  120. X     380,     500,     650,    850,     1100,       1400,     1800,     2300,
  121. X    2900,    3600,    4400,    5400,     6800,       8400,    10200,    12500,
  122. X   17500,   25000,  35000L,  50000L,   75000L,    100000L,  150000L,  200000L,
  123. X 300000L, 400000L, 500000L, 750000L, 1500000L, 2500000L, 5000000L, 10000000L
  124. X};
  125. X
  126. X/*Race    STR,INT,WIS,DEX,CON,CHR,
  127. X    Ages, heights, and weights (male then female)
  128. X    Racial Bases for: dis,srh,stl,fos,bth,bthb,bsav,hitdie,
  129. X    infra, exp base, choice-classes */
  130. X#ifdef MACGAME
  131. Xrace_type *race;
  132. X#else
  133. Xrace_type race[MAX_RACES] = {
  134. X   {"Human",     0,  0,     0,  0,     0,  0,
  135. X      14,  6, 72,  6,180, 25, 66,  4,150, 20,
  136. X      0,  0,  0,  0,  0,  0,  0, 10,  0, 100, 0x3F,
  137. X    },
  138. X   {"Half-Elf", -1,  1,     0,  1, -1,  1,
  139. X      24, 16, 66,  6,130, 15, 62,  6,100, 10,
  140. X      2,  6,  1, -1, -1,  5,  3,  9,  2, 110, 0x3F,
  141. X    },
  142. X   {"Elf",    -1,  2,     1,  1, -2,  1,
  143. X      75, 75, 60,  4,100,  6, 54,  4, 80,  6,
  144. X      5,  8,  1, -2, -5, 15,  6,  8,  3, 120, 0x1F,
  145. X    },
  146. X   {"Halfling", -2,  2,     1,  3,     1,  1,
  147. X      21, 12, 36,  3, 60,  3, 33,  3, 50,  3,
  148. X      15, 12,  4, -5,-10, 20, 18,  6,  4, 110, 0x0B,
  149. X    },
  150. X   {"Gnome",    -1,  2,     0,  2,     1, -2,
  151. X      50, 40, 42,  3, 90,  6, 39,  3, 75,  3,
  152. X      10,  6,  3, -3, -8, 12, 12,  7,  4, 125, 0x0F,
  153. X    },
  154. X   {"Dwarf",     2, -3,     1, -2,     2, -3,
  155. X      35, 15, 48,  3,150, 10, 46,  3,120, 10,
  156. X      2,  7,  -1,  0, 15,  0,  9,  9,  5, 120, 0x05,
  157. X    },
  158. X   {"Half-Orc",     2, -1,     0,  0,     1, -4,
  159. X      11,  4, 66,  1,150,  5, 62,  1,120,  5,
  160. X      -3,  0, -1,  3, 12, -5, -3, 10,  3, 110, 0x0D,
  161. X    },
  162. X   {"Half-Troll",4, -4, -2, -4,     3, -6,
  163. X      20, 10, 96, 10,255, 50, 84,  8,225, 40,
  164. X      -5, -1, -2,  5, 20,-10, -8, 12,  3, 120, 0x05,
  165. X    }
  166. X };
  167. X#endif
  168. X
  169. X/* Background information                    */
  170. X#ifdef MACGAME
  171. Xbackground_type *background;
  172. X#else
  173. Xbackground_type background[MAX_BACKGROUND] = {
  174. X{"You are the illegitimate and unacknowledged child ",         10, 1, 2, 25},
  175. X{"You are the illegitimate but acknowledged child ",         20, 1, 2, 35},
  176. X{"You are one of several children ",                 95, 1, 2, 45},
  177. X{"You are the first child ",                    100, 1, 2, 50},
  178. X{"of a Serf.  ",                         40, 2, 3, 65},
  179. X{"of a Yeoman.  ",                         65, 2, 3, 80},
  180. X{"of a Townsman.  ",                         80, 2, 3, 90},
  181. X{"of a Guildsman.  ",                         90, 2, 3,105},
  182. X{"of a Landed Knight.  ",                     96, 2, 3,120},
  183. X{"of a Titled Noble.  ",                     99, 2, 3,130},
  184. X{"of a Royal Blood Line.  ",                    100, 2, 3,140},
  185. X{"You are the black sheep of the family.  ",             20, 3,50, 20},
  186. X{"You are a credit to the family.  ",                 80, 3,50, 55},
  187. X{"You are a well liked child.  ",                100, 3,50, 60},
  188. X{"Your mother was a Green-Elf.  ",                 40, 4, 1, 50},
  189. X{"Your father was a Green-Elf.  ",                 75, 4, 1, 55},
  190. X{"Your mother was a Grey-Elf.  ",                 90, 4, 1, 55},
  191. X{"Your father was a Grey-Elf.  ",                 95, 4, 1, 60},
  192. X{"Your mother was a High-Elf.  ",                 98, 4, 1, 65},
  193. X{"Your father was a High-Elf.  ",                100, 4, 1, 70},
  194. X{"You are one of several children ",                 60, 7, 8, 50},
  195. X{"You are the only child ",                    100, 7, 8, 55},
  196. X{"of a Green-Elf ",                         75, 8, 9, 50},
  197. X{"of a Grey-Elf ",                         95, 8, 9, 55},
  198. X{"of a High-Elf ",                        100, 8, 9, 60},
  199. X{"Ranger.  ",                             40, 9,54, 80},
  200. X{"Archer.  ",                             70, 9,54, 90},
  201. X{"Warrior.  ",                             87, 9,54,110},
  202. X{"Mage.  ",                             95, 9,54,125},
  203. X{"Prince.  ",                             99, 9,54,140},
  204. X{"King.  ",                            100, 9,54,145},
  205. X{"You are one of several children of a Halfling ",         85,10,11, 45},
  206. X{"You are the only child of a Halfling ",            100,10,11, 55},
  207. X{"Bum.  ",                             20,11, 3, 55},
  208. X{"Tavern Owner.  ",                         30,11, 3, 80},
  209. X{"Miller.  ",                             40,11, 3, 90},
  210. X{"Home Owner.  ",                         50,11, 3,100},
  211. X{"Burglar.  ",                             80,11, 3,110},
  212. X{"Warrior.  ",                             95,11, 3,115},
  213. X{"Mage.  ",                             99,11, 3,125},
  214. X{"Clan Elder.  ",                        100,11, 3,140},
  215. X{"You are one of several children of a Gnome ",             85,13,14, 45},
  216. X{"You are the only child of a Gnome ",                100,13,14, 55},
  217. X{"Beggar.  ",                             20,14, 3, 55},
  218. X{"Braggart.  ",                             50,14, 3, 70},
  219. X{"Prankster.  ",                         75,14, 3, 85},
  220. X{"Warrior.  ",                             95,14, 3,100},
  221. X{"Mage.  ",                            100,14, 3,125},
  222. X{"You are one of two children of a Dwarven ",             25,16,17, 40},
  223. X{"You are the only child of a Dwarven ",            100,16,17, 50},
  224. X{"Thief.  ",                             10,17,18, 60},
  225. X{"Prison Guard.  ",                         25,17,18, 75},
  226. X{"Miner.  ",                             75,17,18, 90},
  227. X{"Warrior.  ",                             90,17,18,110},
  228. X{"Priest.  ",                             99,17,18,130},
  229. X{"King.  ",                            100,17,18,150},
  230. X{"You are the black sheep of the family.  ",             15,18,57, 10},
  231. X{"You are a credit to the family.  ",                 85,18,57, 50},
  232. X{"You are a well liked child.  ",                100,18,57, 55},
  233. X{"Your mother was an Orc, but it is unacknowledged.  ",         25,19,20, 25},
  234. X{"Your father was an Orc, but it is unacknowledged.  ",        100,19,20, 25},
  235. X{"You are the adopted child ",                    100,20, 2, 50},
  236. X{"Your mother was a Cave-Troll ",                 30,22,23, 20},
  237. X{"Your father was a Cave-Troll ",                 60,22,23, 25},
  238. X{"Your mother was a Hill-Troll ",                 75,22,23, 30},
  239. X{"Your father was a Hill-Troll ",                 90,22,23, 35},
  240. X{"Your mother was a Water-Troll ",                 95,22,23, 40},
  241. X{"Your father was a Water-Troll ",                100,22,23, 45},
  242. X{"Cook.  ",                              5,23,62, 60},
  243. X{"Warrior.  ",                             95,23,62, 55},
  244. X{"Shaman.  ",                             99,23,62, 65},
  245. X{"Clan Chief.  ",                        100,23,62, 80},
  246. X{"You have dark brown eyes, ",                     20,50,51, 50},
  247. X{"You have brown eyes, ",                     60,50,51, 50},
  248. X{"You have hazel eyes, ",                     70,50,51, 50},
  249. X{"You have green eyes, ",                     80,50,51, 50},
  250. X{"You have blue eyes, ",                     90,50,51, 50},
  251. X{"You have blue-gray eyes, ",                    100,50,51, 50},
  252. X{"straight ",                             70,51,52, 50},
  253. X{"wavy ",                             90,51,52, 50},
  254. X{"curly ",                            100,51,52, 50},
  255. X{"black hair, ",                         30,52,53, 50},
  256. X{"brown hair, ",                         70,52,53, 50},
  257. X{"auburn hair, ",                         80,52,53, 50},
  258. X{"red hair, ",                             90,52,53, 50},
  259. X{"blond hair, ",                        100,52,53, 50},
  260. X{"and a very dark complexion.",                     10,53, 0, 50},
  261. X{"and a dark complexion.",                     30,53, 0, 50},
  262. X{"and an average complexion.",                     80,53, 0, 50},
  263. X{"and a fair complexion.",                     90,53, 0, 50},
  264. X{"and a very fair complexion.",                    100,53, 0, 50},
  265. X{"You have light grey eyes, ",                     85,54,55, 50},
  266. X{"You have light blue eyes, ",                     95,54,55, 50},
  267. X{"You have light green eyes, ",                    100,54,55, 50},
  268. X{"straight ",                             75,55,56, 50},
  269. X{"wavy ",                            100,55,56, 50},
  270. X{"black hair, and a fair complexion.",                 75,56, 0, 50},
  271. X{"brown hair, and a fair complexion.",                 85,56, 0, 50},
  272. X{"blond hair, and a fair complexion.",                 95,56, 0, 50},
  273. X{"silver hair, and a fair complexion.",                100,56, 0, 50},
  274. X{"You have dark brown eyes, ",                     99,57,58, 50},
  275. X{"You have glowing red eyes, ",                    100,57,58, 60},
  276. X{"straight ",                             90,58,59, 50},
  277. X{"wavy ",                            100,58,59, 50},
  278. X{"black hair, ",                         75,59,60, 50},
  279. X{"brown hair, ",                        100,59,60, 50},
  280. X{"a one foot beard, ",                         25,60,61, 50},
  281. X{"a two foot beard, ",                         60,60,61, 51},
  282. X{"a three foot beard, ",                     90,60,61, 53},
  283. X{"a four foot beard, ",                        100,60,61, 55},
  284. X{"and a dark complexion.",                    100,61, 0, 50},
  285. X{"You have slime green eyes, ",                     60,62,63, 50},
  286. X{"You have puke yellow eyes, ",                     85,62,63, 50},
  287. X{"You have blue-bloodshot eyes, ",                 99,62,63, 50},
  288. X{"You have glowing red eyes, ",                    100,62,63, 55},
  289. X{"dirty ",                             33,63,64, 50},
  290. X{"mangy ",                             66,63,64, 50},
  291. X{"oily ",                            100,63,64, 50},
  292. X{"sea-weed green hair, ",                     33,64,65, 50},
  293. X{"bright red hair, ",                         66,64,65, 50},
  294. X{"dark purple hair, ",                        100,64,65, 50},
  295. X{"and green ",                             25,65,66, 50},
  296. X{"and blue ",                             50,65,66, 50},
  297. X{"and white ",                             75,65,66, 50},
  298. X{"and black ",                            100,65,66, 50},
  299. X{"ulcerous skin.",                         33,66, 0, 50},
  300. X{"scabby skin.",                         66,66, 0, 50},
  301. X{"leprous skin.",                        100,66, 0, 50}
  302. X};
  303. X#endif
  304. X
  305. X/* Classes.                            */
  306. Xclass_type class[MAX_CLASS] = {
  307. X/*      HP Dis Src Stl Fos bth btb sve S  I  W  D Co Ch  Spell Exp  spl */
  308. X{"Warrior",9, 25, 14, 1, 38, 70, 55, 18, 5,-2,-2, 2, 2,-1, NONE,    0, 0},
  309. X{"Mage",   0, 30, 16, 2, 20, 34, 20, 36,-5, 3, 0, 1,-2, 1, MAGE,   30, 1},
  310. X{"Priest", 2, 25, 16, 2, 32, 48, 35, 30,-3,-3, 3,-1, 0, 2, PRIEST, 20, 1},
  311. X{"Rogue",  6, 45, 32, 5, 16, 60, 66, 30, 2, 1,-2, 3, 1,-1, MAGE,    0, 5},
  312. X{"Ranger", 4, 30, 24, 3, 24, 56, 72, 30, 2, 2, 0, 1, 1, 1, MAGE,   40, 3},
  313. X{"Paladin",6, 20, 12, 1, 38, 68, 40, 24, 3,-3, 1, 0, 2, 2, PRIEST, 35, 1}
  314. X};
  315. X
  316. X/* making it 16 bits wastes a little space, but saves much signed/unsigned
  317. X   headaches in its use */
  318. X/* CLA_MISC_HIT is identical to CLA_SAVE, which takes advantage of
  319. X   the fact that the save values are independent of the class */
  320. Xint16 class_level_adj[MAX_CLASS][MAX_LEV_ADJ] = {
  321. X/*           bth    bthb   device  disarm   save/misc hit  */
  322. X/* Warrior */ {    4,    4,    2,    2,    3 },
  323. X/* Mage    */ { 2,    2,    4,    3,    3 },
  324. X/* Priest  */ { 2,    2,    4,    3,    3 },
  325. X/* Rogue   */ { 3,    4,    3,    4,    3 },
  326. X/* Ranger  */ { 3,    4,    3,    3,    3 },
  327. X/* Paladin */ { 3,    3,    3,    2,    3 }
  328. X};
  329. X
  330. Xint32u spell_learned = 0;    /* bit mask of spells learned */
  331. Xint32u spell_worked = 0;    /* bit mask of spells tried and worked */
  332. Xint32u spell_forgotten = 0;    /* bit mask of spells learned but forgotten */
  333. Xint8u spell_order[32];        /* order spells learned/remembered/forgotten */
  334. X
  335. X/* Warriors don't have spells, so there is no entry for them.  Note that
  336. X   this means you must always subtract one from the py.misc.pclass before
  337. X   indexing into magic_spell[]. */
  338. X#ifdef MACGAME
  339. Xspell_type (*magic_spell)[31];
  340. X#else
  341. Xspell_type magic_spell[MAX_CLASS-1][31] = {
  342. X  {          /* Mage       */
  343. X     {    1,  1, 22,   1},
  344. X     {    1,  1, 23,   1},
  345. X     {    1,  2, 24,   1},
  346. X     {    1,  2, 26,   1},
  347. X     {    3,  3, 25,   2},
  348. X     {    3,  3, 25,   1},
  349. X     {    3,  3, 27,   2},
  350. X     {    3,  4, 30,   1},
  351. X     {    5,  4, 30,   6},
  352. X     {    5,  5, 30,   8},
  353. X     {    5,  5, 30,   5},
  354. X     {    5,  5, 35,   6},
  355. X     {    7,  6, 35,   9},
  356. X     {    7,  6, 50,  10},
  357. X     {    7,  6, 40,  12},
  358. X     {    9,  7, 44,  19},
  359. X     {    9,  7, 45,  19},
  360. X     {    9,  7, 75,  22},
  361. X     {    9,  7, 45,  19},
  362. X     { 11,  7, 45,  25},
  363. X     { 11,  7, 99,  19},
  364. X     { 13,  7, 50,  22},
  365. X     { 15,  9, 50,  25},
  366. X     { 17,  9, 50,  31},
  367. X     { 19, 12, 55,  38},
  368. X     { 21, 12, 90,  44},
  369. X     { 23, 12, 60,  50},
  370. X     { 25, 12, 65,  63},
  371. X     { 29, 18, 65,  88},
  372. X     { 33, 21, 80, 125},
  373. X     { 37, 25, 95, 200}
  374. X   },
  375. X   {          /* Priest       */
  376. X     {    1,  1, 10,   1},
  377. X     {    1,  2, 15,   1},
  378. X     {    1,  2, 20,   1},
  379. X     {    1,  2, 25,   1},
  380. X     {    3,  2, 25,   1},
  381. X     {    3,  3, 27,   2},
  382. X     {    3,  3, 27,   2},
  383. X     {    3,  3, 28,   3},
  384. X     {    5,  4, 29,   4},
  385. X     {    5,  4, 30,   5},
  386. X     {    5,  4, 32,   5},
  387. X     {    5,  5, 34,   5},
  388. X     {    7,  5, 36,   6},
  389. X     {    7,  5, 38,   7},
  390. X     {    7,  6, 38,   9},
  391. X     {    7,  7, 38,   9},
  392. X     {    9,  6, 38,  10},
  393. X     {    9,  7, 38,  10},
  394. X     {    9,  7, 40,  10},
  395. X     { 11,  8, 42,  10},
  396. X     { 11,  8, 42,  12},
  397. X     { 11,  9, 55,  15},
  398. X     { 13, 10, 45,  15},
  399. X     { 13, 11, 45,  16},
  400. X     { 15, 12, 50,  20},
  401. X     { 15, 14, 50,  22},
  402. X     { 17, 14, 55,  32},
  403. X     { 21, 16, 60,  38},
  404. X     { 25, 20, 70,  75},
  405. X     { 33, 24, 90, 125},
  406. X     { 39, 32, 99, 200}
  407. X   },
  408. X   {          /* Rogue       */
  409. X     { 99, 99,    0,   0},
  410. X     {    5,  1, 50,   1},
  411. X     {    7,  2, 55,   1},
  412. X     {    9,  3, 60,   2},
  413. X     { 11,  4, 65,   2},
  414. X     { 13,  5, 70,   3},
  415. X     { 99, 99,    0,   0},
  416. X     { 15,  6, 75,   3},
  417. X     { 99, 99,    0,   0},
  418. X     { 17,  7, 80,   4},
  419. X     { 19,  8, 85,   5},
  420. X     { 21,  9, 90,   6},
  421. X     { 99, 99,    0,   0},
  422. X     { 23, 10, 95,   7},
  423. X     { 99, 99,    0,   0},
  424. X     { 99, 99,    0,   0},
  425. X     { 25, 12, 95,   9},
  426. X     { 27, 15, 99,  11},
  427. X     { 99, 99,    0,   0},
  428. X     { 99, 99,    0,   0},
  429. X     { 29, 18, 99,  19},
  430. X     { 99, 99,    0,   0},
  431. X     { 99, 99,    0,   0},
  432. X     { 99, 99,    0,   0},
  433. X     { 99, 99,    0,   0},
  434. X     { 99, 99,    0,   0},
  435. X     { 99, 99,    0,   0},
  436. X     { 99, 99,    0,   0},
  437. X     { 99, 99,    0,   0},
  438. X     { 99, 99,    0,   0},
  439. X     { 99, 99,    0,   0},
  440. X   },
  441. X   {           /* Ranger        */
  442. X     {    3,  1, 30,   1},
  443. X     {    3,  2, 35,   2},
  444. X     {    3,  2, 35,   2},
  445. X     {    5,  3, 35,   2},
  446. X     {    5,  3, 40,   2},
  447. X     {    5,  4, 45,   3},
  448. X     {    7,  5, 40,   6},
  449. X     {    7,  6, 40,   5},
  450. X     {    9,  7, 40,   7},
  451. X     {    9,  8, 45,   8},
  452. X     { 11,  8, 40,  10},
  453. X     { 11,  9, 45,  10},
  454. X     { 13, 10, 45,  12},
  455. X     { 13, 11, 55,  13},
  456. X     { 15, 12, 50,  15},
  457. X     { 15, 13, 50,  15},
  458. X     { 17, 17, 55,  15},
  459. X     { 17, 17, 90,  17},
  460. X     { 21, 17, 55,  17},
  461. X     { 21, 19, 60,  18},
  462. X     { 23, 25, 95,  20},
  463. X     { 23, 20, 60,  20},
  464. X     { 25, 20, 60,  20},
  465. X     { 25, 21, 65,  20},
  466. X     { 27, 21, 65,  22},
  467. X     { 29, 23, 95,  23},
  468. X     { 31, 25, 70,  25},
  469. X     { 33, 25, 75,  38},
  470. X     { 35, 25, 80,  50},
  471. X     { 37, 30, 95, 100},
  472. X     { 99, 99,    0,   0}
  473. X   },
  474. X   {          /* Paladin       */
  475. X     {    1,  1, 30,   1},
  476. X     {    2,  2, 35,   2},
  477. X     {    3,  3, 35,   3},
  478. X     {    5,  3, 35,   5},
  479. X     {    5,  4, 35,   5},
  480. X     {    7,  5, 40,   6},
  481. X     {    7,  5, 40,   6},
  482. X     {    9,  7, 40,   7},
  483. X     {    9,  7, 40,   8},
  484. X     {    9,  8, 40,   8},
  485. X     { 11,  9, 40,  10},
  486. X     { 11, 10, 45,  10},
  487. X     { 11, 10, 45,  10},
  488. X     { 13, 10, 45,  12},
  489. X     { 13, 11, 45,  13},
  490. X     { 15, 13, 45,  15},
  491. X     { 15, 15, 50,  15},
  492. X     { 17, 15, 50,  17},
  493. X     { 17, 15, 50,  18},
  494. X     { 19, 15, 50,  19},
  495. X     { 19, 15, 50,  19},
  496. X     { 21, 17, 50,  20},
  497. X     { 23, 17, 50,  20},
  498. X     { 25, 20, 50,  20},
  499. X     { 27, 21, 50,  22},
  500. X     { 29, 22, 50,  24},
  501. X     { 31, 24, 60,  25},
  502. X     { 33, 28, 60,  31},
  503. X     { 35, 32, 70,  38},
  504. X     { 37, 36, 90,  50},
  505. X     { 39, 38, 95, 100}
  506. X   }
  507. X };
  508. X#endif
  509. X
  510. Xchar *spell_names[62] = {
  511. X  /* Mage Spells */
  512. X  "Magic Missile",  "Detect Monsters",    "Phase Door",  "Light Area",
  513. X  "Cure Light Wounds",    "Find Hidden Traps/Doors",  "Stinking Cloud",
  514. X  "Confusion",    "Lightning Bolt",  "Trap/Door Destruction", "Sleep I",
  515. X  "Cure Poison",  "Teleport Self",  "Remove Curse",  "Frost Bolt",
  516. X  "Turn Stone to Mud",    "Create Food",    "Recharge Item I",  "Sleep II",
  517. X  "Polymorph Other",  "Identify",  "Sleep III",     "Fire Bolt",  "Slow Monster",
  518. X  "Frost Ball",     "Recharge Item II", "Teleport Other",    "Haste Self",
  519. X  "Fire Ball", "Word of Destruction", "Genocide",
  520. X  /* Priest Spells, start at index 31 */
  521. X  "Detect Evil",  "Cure Light Wounds",    "Bless",  "Remove Fear", "Call Light",
  522. X  "Find Traps",     "Detect Doors/Stairs",     "Slow Poison",     "Blind Creature",
  523. X  "Portal",  "Cure Medium Wounds",  "Chant",  "Sanctuary",  "Create Food",
  524. X  "Remove Curse",  "Resist Heat and Cold",  "Neutralize Poison",
  525. X  "Orb of Draining",  "Cure Serious Wounds",  "Sense Invisible",
  526. X  "Protection from Evil",  "Earthquake",  "Sense Surroundings",
  527. X  "Cure Critical Wounds",  "Turn Undead",  "Prayer",  "Dispel Undead",
  528. X  "Heal",  "Dispel Evil",  "Glyph of Warding",    "Holy Word"
  529. X};
  530. X
  531. X/* Each type of character starts out with a few provisions.    */
  532. X/* Note that the entries refer to elements of the object_list[] array*/
  533. X/* 344 = Food Ration, 365 = Wooden Torch, 123 = Cloak, 318 = Beginners-Majik,
  534. X   103 = Soft Leather Armor, 30 = Stiletto, 322 = Beginners Handbook */
  535. X
  536. Xint16u player_init[MAX_CLASS][5] = {
  537. X        { 344, 365, 123,  30, 103},    /* Warrior     */
  538. X        { 344, 365, 123,  30, 318},    /* Mage         */
  539. X        { 344, 365, 123,  30, 322},    /* Priest     */
  540. X        { 344, 365, 123,  30, 318},    /* Rogue     */
  541. X        { 344, 365, 123,  30, 318},    /* Ranger     */
  542. X        { 344, 365, 123,  30, 322}    /* Paladin     */
  543. X};
  544. END_OF_FILE
  545. if test 19531 -ne `wc -c <'source/player.c'`; then
  546.     echo shar: \"'source/player.c'\" unpacked with wrong size!
  547. fi
  548. # end of 'source/player.c'
  549. fi
  550. if test -f 'source/spells.c.1' -a "${1}" != "-c" ; then 
  551.   echo shar: Will not clobber existing file \"'source/spells.c.1'\"
  552. else
  553. echo shar: Extracting \"'source/spells.c.1'\" \(31713 characters\)
  554. sed "s/^X//" >'source/spells.c.1' <<'END_OF_FILE'
  555. X/* source/spells.c: player/creature spells, breaths, wands, scrolls, etc. code
  556. X
  557. X   Copyright (c) 1989-92 James E. Wilson, Robert A. Koeneke
  558. X
  559. X   This software may be copied and distributed for educational, research, and
  560. X   not for profit purposes provided that this copyright and statement are
  561. X   included in all such copies. */
  562. X
  563. X#ifdef __TURBOC__
  564. X#include    <stdio.h>
  565. X#include    <stdlib.h>
  566. X#endif /* __TURBOC__ */
  567. X 
  568. X#include "config.h"
  569. X#include "constant.h"
  570. X#include "types.h"
  571. X#include "externs.h"
  572. X
  573. X#ifdef USG
  574. X#ifndef ATARIST_MWC
  575. X#include <string.h>
  576. X#endif
  577. X#else
  578. X#include <strings.h>
  579. X#endif
  580. X
  581. X#if defined(LINT_ARGS)
  582. Xstatic void replace_spot(int, int, int);
  583. X#else
  584. Xstatic void replace_spot();
  585. X#endif
  586. X
  587. X/* Following are spell procedure/functions            -RAK-    */
  588. X/* These routines are commonly used in the scroll, potion, wands, and     */
  589. X/* staves routines, and are occasionally called from other areas.      */
  590. X/* Now included are creature spells also.               -RAK    */
  591. X
  592. Xvoid monster_name (m_name, m_ptr, r_ptr)
  593. Xchar *m_name;
  594. Xmonster_type *m_ptr;
  595. Xcreature_type *r_ptr;
  596. X{
  597. X  if (!m_ptr->ml)
  598. X    (void) strcpy (m_name, "It");
  599. X  else
  600. X    (void) sprintf (m_name, "The %s", r_ptr->name);
  601. X}
  602. X
  603. Xvoid lower_monster_name (m_name, m_ptr, r_ptr)
  604. Xchar *m_name;
  605. Xmonster_type *m_ptr;
  606. Xcreature_type *r_ptr;
  607. X{
  608. X  if (!m_ptr->ml)
  609. X    (void) strcpy (m_name, "it");
  610. X  else
  611. X    (void) sprintf (m_name, "the %s", r_ptr->name);
  612. X}
  613. X
  614. X/* Sleep creatures adjacent to player            -RAK-    */
  615. Xint sleep_monsters1(y, x)
  616. Xint y, x;
  617. X{
  618. X  register int i, j;
  619. X  register cave_type *c_ptr;
  620. X  register monster_type *m_ptr;
  621. X  register creature_type *r_ptr;
  622. X  int sleep;
  623. X  vtype out_val, m_name;
  624. X
  625. X  sleep = FALSE;
  626. X  for (i = y-1; i <= y+1; i++)
  627. X    for (j = x-1; j <= x+1; j++)
  628. X      {
  629. X    c_ptr = &cave[i][j];
  630. X    if (c_ptr->cptr > 1)
  631. X      {
  632. X        m_ptr = &m_list[c_ptr->cptr];
  633. X        r_ptr = &c_list[m_ptr->mptr];
  634. X
  635. X        monster_name (m_name, m_ptr, r_ptr);
  636. X        if ((randint(MAX_MONS_LEVEL) < r_ptr->level) ||
  637. X        (CD_NO_SLEEP & r_ptr->cdefense))
  638. X          {
  639. X        if (m_ptr->ml && (r_ptr->cdefense & CD_NO_SLEEP))
  640. X          c_recall[m_ptr->mptr].r_cdefense |= CD_NO_SLEEP;
  641. X        (void) sprintf(out_val, "%s is unaffected.", m_name);
  642. X        msg_print(out_val);
  643. X          }
  644. X        else
  645. X          {
  646. X        sleep = TRUE;
  647. X        m_ptr->csleep = 500;
  648. X        (void) sprintf(out_val, "%s falls asleep.", m_name);
  649. X        msg_print(out_val);
  650. X          }
  651. X      }
  652. X      }
  653. X  return(sleep);
  654. X}
  655. X
  656. X/* Detect any treasure on the current panel        -RAK-    */
  657. Xint detect_treasure()
  658. X{
  659. X  register int i, j, detect;
  660. X  register cave_type *c_ptr;
  661. X
  662. X  detect = FALSE;
  663. X  for (i = panel_row_min; i <= panel_row_max; i++)
  664. X    for (j = panel_col_min; j <= panel_col_max; j++)
  665. X      {
  666. X    c_ptr = &cave[i][j];
  667. X    if ((c_ptr->tptr != 0) && (t_list[c_ptr->tptr].tval == TV_GOLD) &&
  668. X        !test_light(i, j))
  669. X      {
  670. X        c_ptr->fm = TRUE;
  671. X        lite_spot(i, j);
  672. X        detect = TRUE;
  673. X      }
  674. X      }
  675. X  return(detect);
  676. X}
  677. X
  678. X
  679. X/* Detect all objects on the current panel        -RAK-    */
  680. Xint detect_object()
  681. X{
  682. X  register int i, j, detect;
  683. X  register cave_type *c_ptr;
  684. X
  685. X  detect = FALSE;
  686. X  for (i = panel_row_min; i <= panel_row_max; i++)
  687. X    for (j = panel_col_min; j <= panel_col_max; j++)
  688. X      {
  689. X    c_ptr = &cave[i][j];
  690. X    if ((c_ptr->tptr != 0) && (t_list[c_ptr->tptr].tval < TV_MAX_OBJECT)
  691. X        && !test_light(i, j))
  692. X      {
  693. X        c_ptr->fm = TRUE;
  694. X        lite_spot(i, j);
  695. X        detect = TRUE;
  696. X      }
  697. X      }
  698. X  return(detect);
  699. X}
  700. X
  701. X
  702. X/* Locates and displays traps on current panel        -RAK-    */
  703. Xint detect_trap()
  704. X{
  705. X  register int i, j;
  706. X  int detect;
  707. X  register cave_type *c_ptr;
  708. X  register inven_type *t_ptr;
  709. X
  710. X  detect = FALSE;
  711. X  for (i = panel_row_min; i <= panel_row_max; i++)
  712. X    for (j = panel_col_min; j <= panel_col_max; j++)
  713. X      {
  714. X    c_ptr = &cave[i][j];
  715. X    if (c_ptr->tptr != 0)
  716. X      if (t_list[c_ptr->tptr].tval == TV_INVIS_TRAP)
  717. X        {
  718. X          c_ptr->fm = TRUE;
  719. X          change_trap(i, j);
  720. X          detect = TRUE;
  721. X        }
  722. X      else if (t_list[c_ptr->tptr].tval == TV_CHEST)
  723. X        {
  724. X          t_ptr = &t_list[c_ptr->tptr];
  725. X          known2(t_ptr);
  726. X        }
  727. X      }
  728. X  return(detect);
  729. X}
  730. X
  731. X
  732. X/* Locates and displays all secret doors on current panel -RAK-    */
  733. Xint detect_sdoor()
  734. X{
  735. X  register int i, j, detect;
  736. X  register cave_type *c_ptr;
  737. X
  738. X  detect = FALSE;
  739. X  for (i = panel_row_min; i <= panel_row_max; i++)
  740. X    for (j = panel_col_min; j <= panel_col_max; j++)
  741. X      {
  742. X    c_ptr = &cave[i][j];
  743. X    if (c_ptr->tptr != 0)
  744. X      /* Secret doors  */
  745. X      if (t_list[c_ptr->tptr].tval == TV_SECRET_DOOR)
  746. X        {
  747. X          c_ptr->fm = TRUE;
  748. X          change_trap(i, j);
  749. X          detect = TRUE;
  750. X        }
  751. X    /* Staircases     */
  752. X      else if (((t_list[c_ptr->tptr].tval == TV_UP_STAIR) ||
  753. X            (t_list[c_ptr->tptr].tval == TV_DOWN_STAIR)) &&
  754. X           !c_ptr->fm)
  755. X        {
  756. X          c_ptr->fm = TRUE;
  757. X          lite_spot(i, j);
  758. X          detect = TRUE;
  759. X        }
  760. X      }
  761. X  return(detect);
  762. X}
  763. X
  764. X
  765. X/* Locates and displays all invisible creatures on current panel -RAK-*/
  766. Xint detect_invisible()
  767. X{
  768. X  register int i, flag;
  769. X  register monster_type *m_ptr;
  770. X#ifdef ATARIST_MWC
  771. X  int32u holder;
  772. X#endif
  773. X
  774. X  flag = FALSE;
  775. X  for (i = mfptr - 1; i >= MIN_MONIX; i--)
  776. X    {
  777. X      m_ptr = &m_list[i];
  778. X      if (panel_contains((int)m_ptr->fy, (int)m_ptr->fx) &&
  779. X#ifdef ATARIST_MWC
  780. X      ((holder = CM_INVISIBLE) & c_list[m_ptr->mptr].cmove))
  781. X#else
  782. X      (CM_INVISIBLE & c_list[m_ptr->mptr].cmove))
  783. X#endif
  784. X    {
  785. X      m_ptr->ml = TRUE;
  786. X      /* works correctly even if hallucinating */
  787. X      print((char)c_list[m_ptr->mptr].cchar, (int)m_ptr->fy,
  788. X        (int)m_ptr->fx);
  789. X      flag = TRUE;
  790. X    }
  791. X    }
  792. X  if (flag)
  793. X    {
  794. X      msg_print("You sense the presence of invisible creatures!");
  795. X      msg_print(CNIL);
  796. X      /* must unlight every monster just lighted */
  797. X      creatures(FALSE);
  798. X    }
  799. X  return(flag);
  800. X}
  801. X
  802. X
  803. X/* Light an area: 1.  If corridor  light immediate area -RAK-*/
  804. X/*          2.  If room  light entire room plus immediate area.     */
  805. Xint light_area(y, x)
  806. Xregister int y, x;
  807. X{
  808. X  register int i, j, light;
  809. X
  810. X  if (py.flags.blind < 1)
  811. X    msg_print("You are surrounded by a white light.");
  812. X  light = TRUE;
  813. X  if (cave[y][x].lr && (dun_level > 0))
  814. X    light_room(y, x);
  815. X  /* Must always light immediate area, because one might be standing on
  816. X     the edge of a room, or next to a destroyed area, etc.  */
  817. X  for (i = y-1; i <= y+1; i++)
  818. X    for (j = x-1; j <=  x+1; j++)
  819. X      {
  820. X    cave[i][j].pl = TRUE;
  821. X    lite_spot(i, j);
  822. X      }
  823. X  return(light);
  824. X}
  825. X
  826. X
  827. X/* Darken an area, opposite of light area        -RAK-    */
  828. Xint unlight_area(y, x)
  829. Xint y, x;
  830. X{
  831. X  register int i, j;
  832. X  int tmp1, tmp2, unlight;
  833. X  int start_row, start_col, end_row, end_col;
  834. X  register cave_type *c_ptr;
  835. X
  836. X  unlight = FALSE;
  837. X  if (cave[y][x].lr && (dun_level > 0))
  838. X    {
  839. X      tmp1 = (SCREEN_HEIGHT/2);
  840. X      tmp2 = (SCREEN_WIDTH /2);
  841. X      start_row = (y/tmp1)*tmp1 + 1;
  842. X      start_col = (x/tmp2)*tmp2 + 1;
  843. X      end_row = start_row + tmp1 - 1;
  844. X      end_col = start_col + tmp2 - 1;
  845. X      for (i = start_row; i <= end_row; i++)
  846. X    {
  847. X      for (j = start_col; j <= end_col; j++)
  848. X        {
  849. X          c_ptr = &cave[i][j];
  850. X          if (c_ptr->lr && c_ptr->fval <= MAX_CAVE_FLOOR)
  851. X        {
  852. X          c_ptr->pl = FALSE;
  853. X          c_ptr->fval = DARK_FLOOR;
  854. X          lite_spot (i, j);
  855. X          if (!test_light(i, j))
  856. X            unlight = TRUE;
  857. X        }
  858. X        }
  859. X    }
  860. X    }
  861. X  else
  862. X    for (i = y-1; i <= y+1; i++)
  863. X      for (j = x-1; j <= x+1; j++)
  864. X    {
  865. X      c_ptr = &cave[i][j];
  866. X      if ((c_ptr->fval == CORR_FLOOR) && c_ptr->pl)
  867. X        {
  868. X          /* pl could have been set by star-lite wand, etc */
  869. X          c_ptr->pl = FALSE;
  870. X          unlight = TRUE;
  871. X        }
  872. X    }
  873. X
  874. X  if (unlight && py.flags.blind <= 0)
  875. X    msg_print("Darkness surrounds you.");
  876. X
  877. X  return(unlight);
  878. X}
  879. X
  880. X
  881. X/* Map the current area plus some            -RAK-    */
  882. Xvoid map_area()
  883. X{
  884. X  register cave_type *c_ptr;
  885. X  register int i7, i8, n, m;
  886. X  int i, j, k, l;
  887. X
  888. X  i = panel_row_min - randint(10);
  889. X  j = panel_row_max + randint(10);
  890. X  k = panel_col_min - randint(20);
  891. X  l = panel_col_max + randint(20);
  892. X  for (m = i; m <= j; m++)
  893. X    for (n = k; n <= l; n++)
  894. X      if (in_bounds(m, n) && (cave[m][n].fval <= MAX_CAVE_FLOOR))
  895. X    for (i7 = m-1; i7 <= m+1; i7++)
  896. X      for (i8 = n-1; i8 <= n+1; i8++)
  897. X        {
  898. X          c_ptr = &cave[i7][i8];
  899. X          if (c_ptr->fval >= MIN_CAVE_WALL)
  900. X        c_ptr->pl = TRUE;
  901. X          else if ((c_ptr->tptr != 0) &&
  902. X               (t_list[c_ptr->tptr].tval >= TV_MIN_VISIBLE) &&
  903. X               (t_list[c_ptr->tptr].tval <= TV_MAX_VISIBLE))
  904. X        c_ptr->fm = TRUE;
  905. X        }
  906. X  prt_map();
  907. X}
  908. X
  909. X
  910. X/* Identify an object                    -RAK-    */
  911. Xint ident_spell()
  912. X{
  913. X  int item_val;
  914. X  bigvtype out_val, tmp_str;
  915. X  register int ident;
  916. X  register inven_type *i_ptr;
  917. X
  918. X  ident = FALSE;
  919. X  if (get_item(&item_val, "Item you wish identified?", 0, INVEN_ARRAY_SIZE,
  920. X           CNIL, CNIL))
  921. X    {
  922. X      ident = TRUE;
  923. X      identify(&item_val);
  924. X      i_ptr = &inventory[item_val];
  925. X      known2(i_ptr);
  926. X      objdes(tmp_str, i_ptr, TRUE);
  927. X      if (item_val >= INVEN_WIELD)
  928. X    {
  929. X      calc_bonuses();
  930. X      (void) sprintf (out_val, "%s: %s", describe_use(item_val), tmp_str);
  931. X    }
  932. X      else
  933. X    (void) sprintf(out_val, "%c %s", item_val+97, tmp_str);
  934. X      msg_print(out_val);
  935. X    }
  936. X  return(ident);
  937. X}
  938. X
  939. X
  940. X/* Get all the monsters on the level pissed off.    -RAK-    */
  941. Xint aggravate_monster (dis_affect)
  942. Xint dis_affect;
  943. X{
  944. X  register int i, aggravate;
  945. X  register monster_type *m_ptr;
  946. X
  947. X  aggravate = FALSE;
  948. X  for (i = mfptr - 1; i >= MIN_MONIX; i--)
  949. X    {
  950. X      m_ptr = &m_list[i];
  951. X      m_ptr->csleep = 0;
  952. X      if ((m_ptr->cdis <= dis_affect) && (m_ptr->cspeed < 2))
  953. X    {
  954. X      m_ptr->cspeed++;
  955. X      aggravate = TRUE;
  956. X    }
  957. X    }
  958. X  if (aggravate)
  959. X    msg_print ("You hear a sudden stirring in the distance!");
  960. X  return(aggravate);
  961. X}
  962. X
  963. X
  964. X/* Surround the fool with traps (chuckle)        -RAK-    */
  965. Xint trap_creation()
  966. X{
  967. X  register int i, j, trap;
  968. X  register cave_type *c_ptr;
  969. X
  970. X  trap = TRUE;
  971. X  for (i = char_row-1; i <= char_row+1; i++)
  972. X    for (j = char_col-1; j <= char_col+1; j++)
  973. X      {
  974. X    /* Don't put a trap under the player, since this can lead to
  975. X       strange situations, e.g. falling through a trap door while
  976. X       trying to rest, setting off a falling rock trap and ending
  977. X       up under the rock.  */
  978. X    if (i == char_row && j == char_col)
  979. X      continue;
  980. X    c_ptr = &cave[i][j];
  981. X    if (c_ptr->fval <= MAX_CAVE_FLOOR)
  982. X      {
  983. X        if (c_ptr->tptr != 0)
  984. X          (void) delete_object(i, j);
  985. X        place_trap(i, j, randint(MAX_TRAP)-1);
  986. X        /* don't let player gain exp from the newly created traps */
  987. X        t_list[c_ptr->tptr].p1 = 0;
  988. X        /* open pits are immediately visible, so call lite_spot */
  989. X        lite_spot(i, j);
  990. X      }
  991. X      }
  992. X  return(trap);
  993. X}
  994. X
  995. X
  996. X/* Surround the player with doors.            -RAK-    */
  997. Xint door_creation()
  998. X{
  999. X  register int i, j, door;
  1000. X  int k;
  1001. X  register cave_type *c_ptr;
  1002. X
  1003. X  door = FALSE;
  1004. X  for (i = char_row-1; i <= char_row+1; i++)
  1005. X    for (j = char_col-1; j <=  char_col+1; j++)
  1006. X      if ((i != char_row) || (j != char_col))
  1007. X    {
  1008. X      c_ptr = &cave[i][j];
  1009. X      if (c_ptr->fval <= MAX_CAVE_FLOOR)
  1010. X        {
  1011. X          door = TRUE;
  1012. X          if (c_ptr->tptr != 0)
  1013. X        (void) delete_object(i, j);
  1014. X          k = popt();
  1015. X          c_ptr->fval = BLOCKED_FLOOR;
  1016. X          c_ptr->tptr = k;
  1017. X          invcopy(&t_list[k], OBJ_CLOSED_DOOR);
  1018. X          lite_spot(i, j);
  1019. X        }
  1020. X    }
  1021. X  return(door);
  1022. X}
  1023. X
  1024. X
  1025. X/* Destroys any adjacent door(s)/trap(s)        -RAK-    */
  1026. Xint td_destroy()
  1027. X{
  1028. X  register int i, j, destroy;
  1029. X  register cave_type *c_ptr;
  1030. X
  1031. X  destroy = FALSE;
  1032. X  for (i = char_row-1; i <= char_row+1; i++)
  1033. X    for (j = char_col-1; j <= char_col+1; j++)
  1034. X      {
  1035. X    c_ptr = &cave[i][j];
  1036. X    if (c_ptr->tptr != 0)
  1037. X      {
  1038. X        if (((t_list[c_ptr->tptr].tval >= TV_INVIS_TRAP) &&
  1039. X         (t_list[c_ptr->tptr].tval <= TV_CLOSED_DOOR) &&
  1040. X         (t_list[c_ptr->tptr].tval != TV_RUBBLE)) ||
  1041. X        (t_list[c_ptr->tptr].tval == TV_SECRET_DOOR))
  1042. X          {
  1043. X        if (delete_object(i, j))
  1044. X          destroy = TRUE;
  1045. X          }
  1046. X        else if (t_list[c_ptr->tptr].tval == TV_CHEST)
  1047. X          {
  1048. X        /* destroy traps on chest and unlock */
  1049. X        t_list[c_ptr->tptr].flags &= ~(CH_TRAPPED|CH_LOCKED);
  1050. X        t_list[c_ptr->tptr].name2 = SN_UNLOCKED;
  1051. X        msg_print ("You have disarmed the chest.");
  1052. X        known2(&t_list[c_ptr->tptr]);
  1053. X        destroy = TRUE;
  1054. X          }
  1055. X      }
  1056. X      }
  1057. X  return(destroy);
  1058. X}
  1059. X
  1060. X
  1061. X/* Display all creatures on the current panel        -RAK-    */
  1062. Xint detect_monsters()
  1063. X{
  1064. X  register int i, detect;
  1065. X  register monster_type *m_ptr;
  1066. X#ifdef ATARIST_MWC
  1067. X  int32u holder;
  1068. X#endif
  1069. X
  1070. X  detect = FALSE;
  1071. X  for (i = mfptr - 1; i >= MIN_MONIX; i--)
  1072. X    {
  1073. X      m_ptr = &m_list[i];
  1074. X      if (panel_contains((int)m_ptr->fy, (int)m_ptr->fx) &&
  1075. X#ifdef ATARIST_MWC
  1076. X      (((holder = CM_INVISIBLE) & c_list[m_ptr->mptr].cmove) == 0))
  1077. X#else
  1078. X      ((CM_INVISIBLE & c_list[m_ptr->mptr].cmove) == 0))
  1079. X#endif
  1080. X    {
  1081. X      m_ptr->ml = TRUE;
  1082. X      /* works correctly even if hallucinating */
  1083. X      print((char)c_list[m_ptr->mptr].cchar, (int)m_ptr->fy,
  1084. X        (int)m_ptr->fx);
  1085. X      detect = TRUE;
  1086. X    }
  1087. X    }
  1088. X  if (detect)
  1089. X    {
  1090. X      msg_print("You sense the presence of monsters!");
  1091. X      msg_print(CNIL);
  1092. X      /* must unlight every monster just lighted */
  1093. X      creatures(FALSE);
  1094. X    }
  1095. X  return(detect);
  1096. X}
  1097. X
  1098. X
  1099. X/* Leave a line of light in given dir, blue light can sometimes    */
  1100. X/* hurt creatures.                       -RAK-   */
  1101. Xvoid light_line(dir, y, x)
  1102. Xint dir, y, x;
  1103. X{
  1104. X  register int i;
  1105. X  register cave_type *c_ptr;
  1106. X  register monster_type *m_ptr;
  1107. X  register creature_type *r_ptr;
  1108. X  int dist, flag;
  1109. X  vtype out_val, m_name;
  1110. X
  1111. X  dist = -1;
  1112. X  flag = FALSE;
  1113. X  do
  1114. X    {
  1115. X      /* put mmove at end because want to light up current spot */
  1116. X      dist++;
  1117. X      c_ptr = &cave[y][x];
  1118. X      if ((dist > OBJ_BOLT_RANGE) || c_ptr->fval >= MIN_CLOSED_SPACE)
  1119. X    flag = TRUE;
  1120. X      else
  1121. X    {
  1122. X      if (!c_ptr->pl && !c_ptr->tl)
  1123. X        {
  1124. X          /* set pl so that lite_spot will work */
  1125. X          c_ptr->pl = TRUE;
  1126. X          if (c_ptr->fval == LIGHT_FLOOR)
  1127. X        {
  1128. X          if (panel_contains(y, x))
  1129. X            light_room(y, x);
  1130. X        }
  1131. X          else
  1132. X        lite_spot(y, x);
  1133. X        }
  1134. X      /* set pl in case tl was true above */
  1135. X      c_ptr->pl = TRUE;
  1136. X      if (c_ptr->cptr > 1)
  1137. X        {
  1138. X          m_ptr = &m_list[c_ptr->cptr];
  1139. X          r_ptr = &c_list[m_ptr->mptr];
  1140. X          /* light up and draw monster */
  1141. X          update_mon ((int)c_ptr->cptr);
  1142. X          monster_name (m_name, m_ptr, r_ptr);
  1143. X          if (CD_LIGHT & r_ptr->cdefense)
  1144. X        {
  1145. X          if (m_ptr->ml)
  1146. X            c_recall[m_ptr->mptr].r_cdefense |= CD_LIGHT;
  1147. X          i = mon_take_hit((int)c_ptr->cptr, damroll(2, 8));
  1148. X          if (i >= 0)
  1149. X            {
  1150. X              (void) sprintf(out_val,
  1151. X                 "%s shrivels away in the light!", m_name);
  1152. X              msg_print(out_val);
  1153. X              prt_experience();
  1154. X            }
  1155. X          else
  1156. X            {
  1157. X              (void) sprintf(out_val, "%s cringes from the light!",
  1158. X                     m_name);
  1159. X              msg_print (out_val);
  1160. X            }
  1161. X        }
  1162. X        }
  1163. X    }
  1164. X      (void) mmove(dir, &y, &x);
  1165. X    }
  1166. X  while (!flag);
  1167. X}
  1168. X
  1169. X
  1170. X/* Light line in all directions                -RAK-    */
  1171. Xvoid starlite(y, x)
  1172. Xregister int y, x;
  1173. X{
  1174. X  register int i;
  1175. X
  1176. X  if (py.flags.blind < 1)
  1177. X    msg_print("The end of the staff bursts into a blue shimmering light.");
  1178. X  for (i = 1; i <= 9; i++)
  1179. X    if (i != 5)
  1180. X      light_line(i, y, x);
  1181. X}
  1182. X
  1183. X
  1184. X/* Disarms all traps/chests in a given direction    -RAK-    */
  1185. Xint disarm_all(dir, y, x)
  1186. Xint dir, y, x;
  1187. X{
  1188. X  register cave_type *c_ptr;
  1189. X  register inven_type *t_ptr;
  1190. X  register int disarm, dist;
  1191. X
  1192. X  disarm = FALSE;
  1193. X  dist = -1;
  1194. X  do
  1195. X    {
  1196. X      /* put mmove at end, in case standing on a trap */
  1197. X      dist++;
  1198. X      c_ptr = &cave[y][x];
  1199. X      /* note, must continue upto and including the first non open space,
  1200. X     because secret doors have fval greater than MAX_OPEN_SPACE */
  1201. X      if (c_ptr->tptr != 0)
  1202. X    {
  1203. X      t_ptr = &t_list[c_ptr->tptr];
  1204. X      if ((t_ptr->tval == TV_INVIS_TRAP) || (t_ptr->tval == TV_VIS_TRAP))
  1205. X        {
  1206. X          if (delete_object(y, x))
  1207. X        disarm = TRUE;
  1208. X        }
  1209. X      else if (t_ptr->tval == TV_CLOSED_DOOR)
  1210. X        t_ptr->p1 = 0;  /* Locked or jammed doors become merely closed. */
  1211. X      else if (t_ptr->tval == TV_SECRET_DOOR)
  1212. X        {
  1213. X          c_ptr->fm = TRUE;
  1214. X          change_trap(y, x);
  1215. X          disarm = TRUE;
  1216. X        }
  1217. X      else if ((t_ptr->tval == TV_CHEST) && (t_ptr->flags != 0))
  1218. X        {
  1219. X          msg_print("Click!");
  1220. X          t_ptr->flags &= ~(CH_TRAPPED|CH_LOCKED);
  1221. X          disarm = TRUE;
  1222. X          t_ptr->name2 = SN_UNLOCKED;
  1223. X          known2(t_ptr);
  1224. X        }
  1225. X    }
  1226. X      (void) mmove(dir, &y, &x);
  1227. X    }
  1228. X  while ((dist <= OBJ_BOLT_RANGE) && c_ptr->fval <= MAX_OPEN_SPACE);
  1229. X  return(disarm);
  1230. X}
  1231. X
  1232. X
  1233. X/* Return flags for given type area affect        -RAK-    */
  1234. Xvoid get_flags(typ, weapon_type, harm_type, destroy)
  1235. Xint typ;
  1236. Xint32u *weapon_type; int *harm_type;
  1237. Xint (**destroy)();
  1238. X{
  1239. X  switch(typ)
  1240. X    {
  1241. X    case GF_MAGIC_MISSILE:
  1242. X      *weapon_type = 0;
  1243. X      *harm_type   = 0;
  1244. X      *destroy       = set_null;
  1245. X      break;
  1246. X    case GF_LIGHTNING:
  1247. X      *weapon_type = CS_BR_LIGHT;
  1248. X      *harm_type   = CD_LIGHT;
  1249. X      *destroy       = set_lightning_destroy;
  1250. X      break;
  1251. X    case GF_POISON_GAS:
  1252. X      *weapon_type = CS_BR_GAS;
  1253. X      *harm_type   = CD_POISON;
  1254. X      *destroy       = set_null;
  1255. X      break;
  1256. X    case GF_ACID:
  1257. X      *weapon_type = CS_BR_ACID;
  1258. X      *harm_type   = CD_ACID;
  1259. X      *destroy       = set_acid_destroy;
  1260. X      break;
  1261. X    case GF_FROST:
  1262. X      *weapon_type = CS_BR_FROST;
  1263. X      *harm_type   = CD_FROST;
  1264. X      *destroy       = set_frost_destroy;
  1265. X      break;
  1266. X    case GF_FIRE:
  1267. X      *weapon_type = CS_BR_FIRE;
  1268. X      *harm_type   = CD_FIRE;
  1269. X      *destroy       = set_fire_destroy;
  1270. X      break;
  1271. X    case GF_HOLY_ORB:
  1272. X      *weapon_type = 0;
  1273. X      *harm_type   = CD_EVIL;
  1274. X      *destroy       = set_null;
  1275. X      break;
  1276. X    default:
  1277. X      msg_print("ERROR in get_flags()\n");
  1278. X    }
  1279. X}
  1280. X
  1281. X
  1282. X/* Shoot a bolt in a given direction            -RAK-    */
  1283. Xvoid fire_bolt(typ, dir, y, x, dam, bolt_typ)
  1284. Xint typ, dir, y, x, dam;
  1285. Xchar *bolt_typ;
  1286. X{
  1287. X  int i, oldy, oldx, dist, flag;
  1288. X  int32u weapon_type; int harm_type;
  1289. X  int (*dummy)();
  1290. X  register cave_type *c_ptr;
  1291. X  register monster_type *m_ptr;
  1292. X  register creature_type *r_ptr;
  1293. X  vtype out_val, m_name;
  1294. X
  1295. X  flag = FALSE;
  1296. X  get_flags(typ, &weapon_type, &harm_type, &dummy);
  1297. X  oldy = y;
  1298. X  oldx = x;
  1299. X  dist = 0;
  1300. X  do
  1301. X    {
  1302. X      (void) mmove(dir, &y, &x);
  1303. X      dist++;
  1304. X      c_ptr = &cave[y][x];
  1305. X      lite_spot(oldy, oldx);
  1306. X      if ((dist > OBJ_BOLT_RANGE) || c_ptr->fval >= MIN_CLOSED_SPACE)
  1307. X    flag = TRUE;
  1308. X      else
  1309. X    {
  1310. X      if (c_ptr->cptr > 1)
  1311. X        {
  1312. X          flag = TRUE;
  1313. X          m_ptr = &m_list[c_ptr->cptr];
  1314. X          r_ptr = &c_list[m_ptr->mptr];
  1315. X
  1316. X          /* light up monster and draw monster, temporarily set
  1317. X         pl so that update_mon() will work */
  1318. X          i = c_ptr->pl;
  1319. X          c_ptr->pl = TRUE;
  1320. X          update_mon ((int)c_ptr->cptr);
  1321. X          c_ptr->pl = i;
  1322. X          /* draw monster and clear previous bolt */
  1323. X          put_qio();
  1324. X
  1325. X          lower_monster_name(m_name, m_ptr, r_ptr);
  1326. X          (void) sprintf(out_val, "The %s strikes %s.", bolt_typ, m_name);
  1327. X          msg_print(out_val);
  1328. X          if (harm_type & r_ptr->cdefense)
  1329. X        {
  1330. X          dam = dam*2;
  1331. X          if (m_ptr->ml)
  1332. X            c_recall[m_ptr->mptr].r_cdefense |= harm_type;
  1333. X        }
  1334. X          else if (weapon_type & r_ptr->spells)
  1335. X        {
  1336. X          dam = dam / 4;
  1337. X          if (m_ptr->ml)
  1338. X            c_recall[m_ptr->mptr].r_spells |= weapon_type;
  1339. X        }
  1340. X          monster_name(m_name, m_ptr, r_ptr);
  1341. X          i = mon_take_hit((int)c_ptr->cptr, dam);
  1342. X          if (i >= 0)
  1343. X        {
  1344. X          (void) sprintf(out_val, "%s dies in a fit of agony.",
  1345. X                 m_name);
  1346. X          msg_print(out_val);
  1347. X          prt_experience();
  1348. X        }
  1349. X          else if (dam > 0)
  1350. X        {
  1351. X          (void) sprintf (out_val, "%s screams in agony.", m_name);
  1352. X          msg_print (out_val);
  1353. X        }
  1354. X        }
  1355. X      else if (panel_contains(y, x) && (py.flags.blind < 1))
  1356. X        {
  1357. X          print('*', y, x);
  1358. X          /* show the bolt */
  1359. X          put_qio();
  1360. X        }
  1361. X    }
  1362. X      oldy = y;
  1363. X      oldx = x;
  1364. X    }
  1365. X  while (!flag);
  1366. X}
  1367. X
  1368. X
  1369. X/* Shoot a ball in a given direction.  Note that balls have an    */
  1370. X/* area affect.                          -RAK-   */
  1371. Xvoid fire_ball(typ, dir, y, x, dam_hp, descrip)
  1372. Xint typ, dir, y, x, dam_hp;
  1373. Xchar *descrip;
  1374. X{
  1375. X  register int i, j;
  1376. X  int dam, max_dis, thit, tkill, k, tmp;
  1377. X  int oldy, oldx, dist, flag, harm_type;
  1378. X  int32u weapon_type;
  1379. X  int (*destroy)();
  1380. X  register cave_type *c_ptr;
  1381. X  register monster_type *m_ptr;
  1382. X  register creature_type *r_ptr;
  1383. X  vtype out_val;
  1384. X
  1385. X  thit     = 0;
  1386. X  tkill     = 0;
  1387. X  max_dis = 2;
  1388. X  get_flags(typ, &weapon_type, &harm_type, &destroy);
  1389. X  flag = FALSE;
  1390. X  oldy = y;
  1391. X  oldx = x;
  1392. X  dist = 0;
  1393. X  do
  1394. X    {
  1395. X      (void) mmove(dir, &y, &x);
  1396. X      dist++;
  1397. X      lite_spot(oldy, oldx);
  1398. X      if (dist > OBJ_BOLT_RANGE)
  1399. X    flag = TRUE;
  1400. X      else
  1401. X    {
  1402. X      c_ptr = &cave[y][x];
  1403. X      if ((c_ptr->fval >= MIN_CLOSED_SPACE) || (c_ptr->cptr > 1))
  1404. X        {
  1405. X          flag = TRUE;
  1406. X          if (c_ptr->fval >= MIN_CLOSED_SPACE)
  1407. X        {
  1408. X          y = oldy;
  1409. X          x = oldx;
  1410. X        }
  1411. X          /* The ball hits and explodes.             */
  1412. X          /* The explosion.                 */
  1413. X          for (i = y-max_dis; i <= y+max_dis; i++)
  1414. X        for (j = x-max_dis; j <= x+max_dis; j++)
  1415. X          if (in_bounds(i, j) && (distance(y, x, i, j) <= max_dis)
  1416. X              && los(y, x, i, j))
  1417. X            {
  1418. X              c_ptr = &cave[i][j];
  1419. X              if ((c_ptr->tptr != 0) &&
  1420. X              (*destroy)(&t_list[c_ptr->tptr]))
  1421. X            (void) delete_object(i, j);
  1422. X              if (c_ptr->fval <= MAX_OPEN_SPACE)
  1423. X            {
  1424. X              if (c_ptr->cptr > 1)
  1425. X                {
  1426. X                  m_ptr = &m_list[c_ptr->cptr];
  1427. X                  r_ptr = &c_list[m_ptr->mptr];
  1428. X
  1429. X                  /* lite up creature if visible, temp
  1430. X                 set pl so that update_mon works */
  1431. X                  tmp = c_ptr->pl;
  1432. X                  c_ptr->pl = TRUE;
  1433. X                  update_mon((int)c_ptr->cptr);
  1434. X
  1435. X                  thit++;
  1436. X                  dam = dam_hp;
  1437. X                  if (harm_type & r_ptr->cdefense)
  1438. X                {
  1439. X                  dam = dam*2;
  1440. X                  if (m_ptr->ml)
  1441. X                    c_recall[m_ptr->mptr].r_cdefense |=harm_type;
  1442. X                }
  1443. X                  else if (weapon_type & r_ptr->spells)
  1444. X                {
  1445. X                  dam = dam / 4;
  1446. X                  if (m_ptr->ml)
  1447. X                    c_recall[m_ptr->mptr].r_spells |=weapon_type;
  1448. X                }
  1449. X                  dam = (dam/(distance(i, j, y, x)+1));
  1450. X                  k = mon_take_hit((int)c_ptr->cptr, dam);
  1451. X                  if (k >= 0)
  1452. X                tkill++;
  1453. X                  c_ptr->pl = tmp;
  1454. X                }
  1455. X              else if (panel_contains(i, j) &&(py.flags.blind < 1))
  1456. X                print('*', i, j);
  1457. X            }
  1458. X            }
  1459. X          /* show ball of whatever */
  1460. X          put_qio();
  1461. X
  1462. X          for (i = (y - 2); i <= (y + 2); i++)
  1463. X        for (j = (x - 2); j <= (x + 2); j++)
  1464. X          if (in_bounds(i, j) && panel_contains(i, j) &&
  1465. X              (distance(y, x, i, j) <= max_dis))
  1466. X            lite_spot(i, j);
  1467. X
  1468. X          /* End  explosion.             */
  1469. X          if (thit == 1)
  1470. X        {
  1471. X          (void) sprintf(out_val,
  1472. X                 "The %s envelops a creature!",
  1473. X                 descrip);
  1474. X          msg_print(out_val);
  1475. X        }
  1476. X          else if (thit > 1)
  1477. X        {
  1478. X          (void) sprintf(out_val,
  1479. X                 "The %s envelops several creatures!",
  1480. X                 descrip);
  1481. X          msg_print(out_val);
  1482. X        }
  1483. X          if (tkill == 1)
  1484. X        msg_print("There is a scream of agony!");
  1485. X          else if (tkill > 1)
  1486. X        msg_print("There are several screams of agony!");
  1487. X          if (tkill >= 0)
  1488. X        prt_experience();
  1489. X          /* End ball hitting.             */
  1490. X        }
  1491. X      else if (panel_contains(y, x) && (py.flags.blind < 1))
  1492. X        {
  1493. X          print('*', y, x);
  1494. X          /* show bolt */
  1495. X          put_qio();
  1496. X        }
  1497. X      oldy = y;
  1498. X      oldx = x;
  1499. X    }
  1500. X    }
  1501. X  while (!flag);
  1502. X}
  1503. X
  1504. X
  1505. X/* Breath weapon works like a fire_ball, but affects the player. */
  1506. X/* Note the area affect.                  -RAK-   */
  1507. Xvoid breath(typ, y, x, dam_hp, ddesc, monptr)
  1508. Xint typ, y, x, dam_hp;
  1509. Xchar *ddesc;
  1510. Xint monptr;
  1511. X{
  1512. X  register int i, j;
  1513. X  int dam, max_dis, harm_type;
  1514. X  int32u weapon_type;
  1515. X  int32u tmp, treas;
  1516. X  int (*destroy)();
  1517. X  register cave_type *c_ptr;
  1518. X  register monster_type *m_ptr;
  1519. X  register creature_type *r_ptr;
  1520. X#ifdef ATARIST_MWC
  1521. X  int32u holder;
  1522. X#endif
  1523. X
  1524. X  max_dis = 2;
  1525. X  get_flags(typ, &weapon_type, &harm_type, &destroy);
  1526. X  for (i = y-2; i <= y+2; i++)
  1527. X    for (j = x-2; j <= x+2; j++)
  1528. X      if (in_bounds(i, j) && (distance(y, x, i, j) <= max_dis)
  1529. X      && los(y, x, i, j))
  1530. X    {
  1531. X      c_ptr = &cave[i][j];
  1532. X      if ((c_ptr->tptr != 0) &&
  1533. X          (*destroy)(&t_list[c_ptr->tptr]))
  1534. X        (void) delete_object(i, j);
  1535. X      if (c_ptr->fval <= MAX_OPEN_SPACE)
  1536. X        {
  1537. X          /* must test status bit, not py.flags.blind here, flag could have
  1538. X         been set by a previous monster, but the breath should still
  1539. X         be visible until the blindness takes effect */
  1540. X          if (panel_contains(i, j) && !(py.flags.status & PY_BLIND))
  1541. X        print('*', i, j);
  1542. X          if (c_ptr->cptr > 1)
  1543. X        {
  1544. X          m_ptr = &m_list[c_ptr->cptr];
  1545. X          r_ptr = &c_list[m_ptr->mptr];
  1546. X          dam = dam_hp;
  1547. X          if (harm_type & r_ptr->cdefense)
  1548. X            dam = dam*2;
  1549. X          else if (weapon_type & r_ptr->spells)
  1550. X            dam = (dam / 4);
  1551. X          dam = (dam/(distance(i, j, y, x)+1));
  1552. X          /* can not call mon_take_hit here, since player does not
  1553. X             get experience for kill */
  1554. X          m_ptr->hp = m_ptr->hp - dam;
  1555. X          m_ptr->csleep = 0;
  1556. X          if (m_ptr->hp < 0)
  1557. X            {
  1558. X              treas = monster_death((int)m_ptr->fy, (int)m_ptr->fx,
  1559. X                        r_ptr->cmove);
  1560. X              if (m_ptr->ml)
  1561. X            {
  1562. X#ifdef ATARIST_MWC
  1563. X              holder = CM_TREASURE;
  1564. X              tmp = (c_recall[m_ptr->mptr].r_cmove & holder)
  1565. X                >> CM_TR_SHIFT;
  1566. X              if (tmp > ((treas & holder) >> CM_TR_SHIFT))
  1567. X                treas = (treas & ~holder)|(tmp << CM_TR_SHIFT);
  1568. X              c_recall[m_ptr->mptr].r_cmove = treas |
  1569. X                (c_recall[m_ptr->mptr].r_cmove & ~holder);
  1570. X#else
  1571. X              tmp = (c_recall[m_ptr->mptr].r_cmove & CM_TREASURE)
  1572. X                >> CM_TR_SHIFT;
  1573. X              if (tmp > ((treas & CM_TREASURE) >> CM_TR_SHIFT))
  1574. X                treas = (treas & ~CM_TREASURE)|(tmp<<CM_TR_SHIFT);
  1575. X              c_recall[m_ptr->mptr].r_cmove = treas |
  1576. X                (c_recall[m_ptr->mptr].r_cmove & ~CM_TREASURE);
  1577. X#endif
  1578. X            }
  1579. X
  1580. X              /* It ate an already processed monster.Handle normally.*/
  1581. X              if (monptr < c_ptr->cptr)
  1582. X            delete_monster((int) c_ptr->cptr);
  1583. X              /* If it eats this monster, an already processed monster
  1584. X             will take its place, causing all kinds of havoc.
  1585. X             Delay the kill a bit. */
  1586. X              else
  1587. X            fix1_delete_monster((int) c_ptr->cptr);
  1588. X            }
  1589. X        }
  1590. X          else if (c_ptr->cptr == 1)
  1591. X        {
  1592. X          dam = (dam_hp/(distance(i, j, y, x)+1));
  1593. X          /* let's do at least one point of damage */
  1594. X          /* prevents randint(0) problem with poison_gas, also */
  1595. X          if (dam == 0)
  1596. X            dam = 1;
  1597. X          switch(typ)
  1598. X            {
  1599. X            case GF_LIGHTNING: light_dam(dam, ddesc); break;
  1600. X            case GF_POISON_GAS: poison_gas(dam, ddesc); break;
  1601. X            case GF_ACID: acid_dam(dam, ddesc); break;
  1602. X            case GF_FROST: cold_dam(dam, ddesc); break;
  1603. X            case GF_FIRE: fire_dam(dam, ddesc); break;
  1604. X            }
  1605. X        }
  1606. X        }
  1607. X    }
  1608. X  /* show the ball of gas */
  1609. X  put_qio();
  1610. X
  1611. X  for (i = (y - 2); i <= (y + 2); i++)
  1612. X    for (j = (x - 2); j <= (x + 2); j++)
  1613. X      if (in_bounds(i, j) && panel_contains(i, j) &&
  1614. X      (distance(y, x, i, j) <= max_dis))
  1615. X    lite_spot(i, j);
  1616. X}
  1617. X
  1618. X
  1619. X/* Recharge a wand, staff, or rod.  Sometimes the item breaks. -RAK-*/
  1620. Xint recharge(num)
  1621. Xregister int num;
  1622. X{
  1623. X  int i, j, item_val;
  1624. X  register int res;
  1625. X  register inven_type *i_ptr;
  1626. X
  1627. X  res = FALSE;
  1628. X  if (!find_range(TV_STAFF, TV_WAND, &i, &j))
  1629. X    msg_print("You have nothing to recharge.");
  1630. X  else if (get_item(&item_val, "Recharge which item?", i, j, CNIL, CNIL))
  1631. X    {
  1632. X      i_ptr = &inventory[item_val];
  1633. X      res = TRUE;
  1634. X      /* recharge I = recharge(20) = 1/6 failure for empty 10th level wand */
  1635. X      /* recharge II = recharge(60) = 1/10 failure for empty 10th level wand*/
  1636. X      /* make it harder to recharge high level, and highly charged wands, note
  1637. X     that i can be negative, so check its value before trying to call
  1638. X     randint().  */
  1639. X      i = num + 50 - (int)i_ptr->level - i_ptr->p1;
  1640. X      if (i < 19)
  1641. X    i = 1;    /* Automatic failure.  */
  1642. X      else
  1643. X    i = randint (i/10);
  1644. X
  1645. X      if (i == 1)
  1646. X    {
  1647. X      msg_print("There is a bright flash of light.");
  1648. X      inven_destroy(item_val);
  1649. X    }
  1650. X      else
  1651. X    {
  1652. X      num = (num/(i_ptr->level+2)) + 1;
  1653. X      i_ptr->p1 += 2 + randint(num);
  1654. X      if (known2_p(i_ptr))
  1655. X        clear_known2(i_ptr);
  1656. X      clear_empty(i_ptr);
  1657. X    }
  1658. X    }
  1659. X  return(res);
  1660. X}
  1661. X
  1662. X
  1663. X/* Increase or decrease a creatures hit points        -RAK-    */
  1664. Xint hp_monster(dir, y, x, dam)
  1665. Xint dir, y, x, dam;
  1666. X{
  1667. X  register int i;
  1668. X  int flag, dist, monster;
  1669. X  register cave_type *c_ptr;
  1670. X  register monster_type *m_ptr;
  1671. X  register creature_type *r_ptr;
  1672. X  vtype out_val, m_name;
  1673. X
  1674. X  monster = FALSE;
  1675. X  flag = FALSE;
  1676. X  dist = 0;
  1677. X  do
  1678. X    {
  1679. X      (void) mmove(dir, &y, &x);
  1680. X      dist++;
  1681. X      c_ptr = &cave[y][x];
  1682. X      if ((dist > OBJ_BOLT_RANGE) || c_ptr->fval >= MIN_CLOSED_SPACE)
  1683. X    flag = TRUE;
  1684. X      else if (c_ptr->cptr > 1)
  1685. X    {
  1686. X      flag = TRUE;
  1687. X      m_ptr = &m_list[c_ptr->cptr];
  1688. X      r_ptr = &c_list[m_ptr->mptr];
  1689. X      monster_name (m_name, m_ptr, r_ptr);
  1690. X      monster = TRUE;
  1691. X      i = mon_take_hit((int)c_ptr->cptr, dam);
  1692. X      if (i >= 0)
  1693. X        {
  1694. X          (void) sprintf(out_val, "%s dies in a fit of agony.", m_name);
  1695. X          msg_print(out_val);
  1696. X          prt_experience();
  1697. X        }
  1698. X      else if (dam > 0)
  1699. X        {
  1700. X          (void) sprintf(out_val, "%s screams in agony.", m_name);
  1701. X          msg_print(out_val);
  1702. X        }
  1703. X    }
  1704. X    }
  1705. X  while (!flag);
  1706. X  return(monster);
  1707. X}
  1708. X
  1709. X
  1710. X/* Drains life; note it must be living.        -RAK-    */
  1711. Xint drain_life(dir, y, x)
  1712. Xint dir, y, x;
  1713. X{
  1714. X  register int i;
  1715. X  int flag, dist, drain;
  1716. X  register cave_type *c_ptr;
  1717. X  register monster_type *m_ptr;
  1718. X  register creature_type *r_ptr;
  1719. X  vtype out_val, m_name;
  1720. X
  1721. X  drain = FALSE;
  1722. X  flag = FALSE;
  1723. X  dist = 0;
  1724. X  do
  1725. X    {
  1726. X      (void) mmove(dir, &y, &x);
  1727. X      dist++;
  1728. X      c_ptr = &cave[y][x];
  1729. X      if ((dist > OBJ_BOLT_RANGE) || c_ptr->fval >= MIN_CLOSED_SPACE)
  1730. X    flag = TRUE;
  1731. X      else if (c_ptr->cptr > 1)
  1732. X    {
  1733. X      flag = TRUE;
  1734. X      m_ptr = &m_list[c_ptr->cptr];
  1735. X      r_ptr = &c_list[m_ptr->mptr];
  1736. X      if ((r_ptr->cdefense & CD_UNDEAD) == 0)
  1737. X        {
  1738. X          drain = TRUE;
  1739. X          monster_name (m_name, m_ptr, r_ptr);
  1740. X          i = mon_take_hit((int)c_ptr->cptr, 75);
  1741. X          if (i >= 0)
  1742. X        {
  1743. X          (void) sprintf(out_val, "%s dies in a fit of agony.",m_name);
  1744. X          msg_print(out_val);
  1745. X          prt_experience();
  1746. X        }
  1747. X          else
  1748. X        {
  1749. X          (void) sprintf(out_val, "%s screams in agony.", m_name);
  1750. X          msg_print(out_val);
  1751. X        }
  1752. X        }
  1753. X      else
  1754. X        c_recall[m_ptr->mptr].r_cdefense |= CD_UNDEAD;
  1755. X    }
  1756. X    }
  1757. X  while (!flag);
  1758. X  return(drain);
  1759. X}
  1760. X
  1761. X
  1762. X/* Increase or decrease a creatures speed        -RAK-    */
  1763. X/* NOTE: cannot slow a winning creature (BALROG)         */
  1764. Xint speed_monster(dir, y, x, spd)
  1765. Xint dir, y, x, spd;
  1766. X{
  1767. X  int flag, dist, speed;
  1768. X  register cave_type *c_ptr;
  1769. X  register monster_type *m_ptr;
  1770. X  register creature_type *r_ptr;
  1771. X  vtype out_val, m_name;
  1772. X
  1773. X  speed = FALSE;
  1774. X  flag = FALSE;
  1775. X  dist = 0;
  1776. X  do
  1777. X    {
  1778. X      (void) mmove(dir, &y, &x);
  1779. X      dist++;
  1780. X      c_ptr = &cave[y][x];
  1781. X      if ((dist > OBJ_BOLT_RANGE) || c_ptr->fval >= MIN_CLOSED_SPACE)
  1782. X    flag = TRUE;
  1783. X      else if (c_ptr->cptr > 1)
  1784. X    {
  1785. X      flag = TRUE;
  1786. X      m_ptr = &m_list[c_ptr->cptr];
  1787. X      r_ptr = &c_list[m_ptr->mptr];
  1788. X      monster_name (m_name, m_ptr, r_ptr);
  1789. X      if (spd > 0)
  1790. X        {
  1791. X          m_ptr->cspeed += spd;
  1792. X          m_ptr->csleep = 0;
  1793. X          (void) sprintf (out_val, "%s starts moving faster.", m_name);
  1794. X          msg_print (out_val);
  1795. X          speed = TRUE;
  1796. X        }
  1797. X      else if (randint(MAX_MONS_LEVEL) > r_ptr->level)
  1798. X        {
  1799. X          m_ptr->cspeed += spd;
  1800. X          m_ptr->csleep = 0;
  1801. X          (void) sprintf (out_val, "%s starts moving slower.", m_name);
  1802. X          msg_print (out_val);
  1803. X          speed = TRUE;
  1804. X        }
  1805. X      else
  1806. X        {
  1807. X          m_ptr->csleep = 0;
  1808. X          (void) sprintf(out_val, "%s is unaffected.", m_name);
  1809. X          msg_print(out_val);
  1810. X        }
  1811. X    }
  1812. X    }
  1813. X  while (!flag);
  1814. X  return(speed);
  1815. X}
  1816. X
  1817. X
  1818. X/* Confuse a creature                    -RAK-    */
  1819. Xint confuse_monster(dir, y, x)
  1820. Xint dir, y, x;
  1821. X{
  1822. X  int flag, dist, confuse;
  1823. X  register cave_type *c_ptr;
  1824. X  register monster_type *m_ptr;
  1825. X  register creature_type *r_ptr;
  1826. X  vtype out_val, m_name;
  1827. X
  1828. X  confuse = FALSE;
  1829. X  flag = FALSE;
  1830. X  dist = 0;
  1831. X  do
  1832. X    {
  1833. X      (void) mmove(dir, &y, &x);
  1834. X      dist++;
  1835. X      c_ptr = &cave[y][x];
  1836. X      if ((dist > OBJ_BOLT_RANGE) || c_ptr->fval >= MIN_CLOSED_SPACE)
  1837. X    flag = TRUE;
  1838. X      else if (c_ptr->cptr > 1)
  1839. X    {
  1840. X      m_ptr = &m_list[c_ptr->cptr];
  1841. X      r_ptr = &c_list[m_ptr->mptr];
  1842. X      monster_name (m_name, m_ptr, r_ptr);
  1843. X      flag = TRUE;
  1844. X      if ((randint(MAX_MONS_LEVEL) < r_ptr->level) ||
  1845. X          (CD_NO_SLEEP & r_ptr->cdefense))
  1846. X        {
  1847. X          if (m_ptr->ml && (r_ptr->cdefense & CD_NO_SLEEP))
  1848. X        c_recall[m_ptr->mptr].r_cdefense |= CD_NO_SLEEP;
  1849. X          /* Monsters which resisted the attack should wake up.
  1850. X         Monsters with inane resistence ignore the attack.  */
  1851. X          if (! (CD_NO_SLEEP & r_ptr->cdefense))
  1852. X        m_ptr->csleep = 0;
  1853. X          (void) sprintf(out_val, "%s is unaffected.", m_name);
  1854. X          msg_print(out_val);
  1855. X        }
  1856. X      else
  1857. X        {
  1858. X          m_ptr->confused = TRUE;
  1859. X          confuse = TRUE;
  1860. X          m_ptr->csleep = 0;
  1861. X          (void) sprintf(out_val, "%s appears confused.", m_name);
  1862. X          msg_print(out_val);
  1863. X        }
  1864. X    }
  1865. END_OF_FILE
  1866. if test 31713 -ne `wc -c <'source/spells.c.1'`; then
  1867.     echo shar: \"'source/spells.c.1'\" unpacked with wrong size!
  1868. fi
  1869. # end of 'source/spells.c.1'
  1870. fi
  1871. if test -f 'util/mc/st.h' -a "${1}" != "-c" ; then 
  1872.   echo shar: Will not clobber existing file \"'util/mc/st.h'\"
  1873. else
  1874. echo shar: Extracting \"'util/mc/st.h'\" \(2080 characters\)
  1875. sed "s/^X//" >'util/mc/st.h' <<'END_OF_FILE'
  1876. X/* util/mc/st.h: definitions for the symbol table module
  1877. X *
  1878. X * Copyright (c) 1989 by Joseph Hall.
  1879. X * All rights reserved except as stated below.
  1880. X *
  1881. X * Jim Wilson and any other holders of copyright on substantial portions
  1882. X * of Moria are granted rights to use, modify, and distribute this program
  1883. X * as they see fit, so long as the terms of its use, modification and/or
  1884. X * distribution are no less restrictive than those applying to Moria,
  1885. X * version 5.0 or later, itself, and so long as this use is related to
  1886. X * the further development of Moria.
  1887. X *
  1888. X * Anyone having any other use in mind for this code should contact the
  1889. X * author at 4116 Brewster Dr., Raleigh NC 27606 (jnh@ecemwl.ncsu.edu).
  1890. X */
  1891. X
  1892. X#ifndef _ST_H_
  1893. X#define    _ST_H_
  1894. X
  1895. X#ifndef TRUE
  1896. X#define TRUE 1
  1897. X#endif
  1898. X
  1899. X#ifndef FALSE
  1900. X#define FALSE 0
  1901. X#endif
  1902. X
  1903. X/*
  1904. X * Needs generic_t
  1905. X */
  1906. X
  1907. X#include "generic.h"
  1908. X
  1909. X/*
  1910. X * maximum length of symbol strings
  1911. X */
  1912. X
  1913. X#define ST_MAX_SYM_LEN        32
  1914. X
  1915. X/*
  1916. X * Struct for individual entries
  1917. X */
  1918. X
  1919. Xtypedef    struct st_EntryStruct {
  1920. X
  1921. X    char    name[ST_MAX_SYM_LEN];    /* symbol string            */
  1922. X    int        type;            /* symbol type                */
  1923. X    struct st_EntryStruct *next_P;    /* next entry in chain            */
  1924. X    generic_t    gval;            /* symbol value                */
  1925. X
  1926. X} st_Entry_t, *st_Entry_Pt;
  1927. X
  1928. X/*
  1929. X * Struct for table header
  1930. X */
  1931. X
  1932. Xtypedef struct {
  1933. X
  1934. X    char    name[ST_MAX_SYM_LEN];
  1935. X                    /* table name                */
  1936. X    int        size,            /* size of table to be allocated        */
  1937. X        entryCt;        /* # of entries in table currently        */
  1938. X    st_Entry_Pt    *tab_A;            /* vector of ptrs to entries        */
  1939. X
  1940. X} st_Table_t, *st_Table_Pt;
  1941. X
  1942. X#define    ST_SYM_FOUND        0
  1943. X#define ST_OK            0
  1944. X#define ST_SYM_NOT_FOUND    1
  1945. X#define ST_NULL_TABLE        2
  1946. X
  1947. X#define ST_MAX_INPUT_LEN    256
  1948. X
  1949. X/*
  1950. X * functions defined in st_symtab.c
  1951. X */
  1952. X
  1953. Xextern st_Table_Pt St_NewTable();
  1954. Xextern void St_DelTable();
  1955. Xextern int St_GetSym();
  1956. Xextern int St_DefSym();
  1957. Xextern int St_ReplSym();
  1958. Xextern int St_DelSym();
  1959. Xextern st_Table_Pt St_GetTable();
  1960. Xextern void St_DumpTable();
  1961. Xextern char **St_ListTable();
  1962. Xextern char **St_SListTable();
  1963. Xextern int St_TableSize();
  1964. X
  1965. X#endif /* _ST_H_ */
  1966. X
  1967. END_OF_FILE
  1968. if test 2080 -ne `wc -c <'util/mc/st.h'`; then
  1969.     echo shar: \"'util/mc/st.h'\" unpacked with wrong size!
  1970. fi
  1971. # end of 'util/mc/st.h'
  1972. fi
  1973. echo shar: End of archive 18 \(of 39\).
  1974. cp /dev/null ark18isdone
  1975. MISSING=""
  1976. 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
  1977.     if test ! -f ark${I}isdone ; then
  1978.     MISSING="${MISSING} ${I}"
  1979.     fi
  1980. done
  1981. if test "${MISSING}" = "" ; then
  1982.     echo You have unpacked all 39 archives.
  1983.     echo "Now run "bldfiles.sh" to build split files"
  1984.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1985. else
  1986.     echo You still need to unpack the following archives:
  1987.     echo "        " ${MISSING}
  1988. fi
  1989. ##  End of shell archive.
  1990. exit 0
  1991.