home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / games / volume16 / nethck31 / part62 < prev    next >
Encoding:
Internet Message Format  |  1993-02-03  |  58.9 KB
  1. Path: uunet!news.tek.com!master!saab!billr
  2. From: billr@saab.CNA.TEK.COM (Bill Randle)
  3. Newsgroups: comp.sources.games
  4. Subject: v16i070:  nethack31 - display oriented dungeons & dragons (Ver. 3.1), Part62/108
  5. Message-ID: <4373@master.CNA.TEK.COM>
  6. Date: 1 Feb 93 19:49:56 GMT
  7. Sender: news@master.CNA.TEK.COM
  8. Lines: 2113
  9. Approved: billr@saab.CNA.TEK.COM
  10. Xref: uunet comp.sources.games:1620
  11.  
  12. Submitted-by: izchak@linc.cis.upenn.edu (Izchak Miller)
  13. Posting-number: Volume 16, Issue 70
  14. Archive-name: nethack31/Part62
  15. Supersedes: nethack3p9: Volume 10, Issue 46-102
  16. Environment: Amiga, Atari, Mac, MS-DOS, OS2, Unix, VMS, X11
  17.  
  18.  
  19.  
  20. #! /bin/sh
  21. # This is a shell archive.  Remove anything before this line, then unpack
  22. # it by saving it into a file and typing "sh file".  To overwrite existing
  23. # files, type "sh file -c".  You can also feed this as standard input via
  24. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  25. # will see the following message at the end:
  26. #        "End of archive 62 (of 108)."
  27. # Contents:  dat/gehennom.des include/os2conf.h src/sp_lev.c2
  28. # Wrapped by billr@saab on Wed Jan 27 16:09:11 1993
  29. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  30. if test -f 'dat/gehennom.des' -a "${1}" != "-c" ; then 
  31.   echo shar: Will not clobber existing file \"'dat/gehennom.des'\"
  32. else
  33. echo shar: Extracting \"'dat/gehennom.des'\" \(19835 characters\)
  34. sed "s/^X//" >'dat/gehennom.des' <<'END_OF_FILE'
  35. X#    SCCS Id: @(#)gehennom.des    3.1    91/12/27
  36. X#    Copyright (c) 1989 by Jean-Christophe Collet
  37. X#    Copyright (c) 1992 by M. Stephenson and Izchak Miller
  38. X# NetHack may be freely redistributed.  See license for details.
  39. X#
  40. X
  41. XMAZE: "valley", ' '
  42. XFLAGS: hardfloor
  43. XGEOMETRY:center,center
  44. XMAP
  45. X----------------------------------------------------------------------------
  46. X|...S.|..|.....|  |.....-|      |................|   |...............| |...|
  47. X|---|.|.--.---.|  |......--- ----..........-----.-----....---........---.-.|
  48. X|   |.|.|..| |.| --........| |.............|   |.......---| |-...........--|
  49. X|   |...S..| |.| |.......-----.......------|   |--------..---......------- |
  50. X|----------- |.| |-......| |....|...-- |...-----................----       |
  51. X|.....S....---.| |.......| |....|...|  |..............-----------          |
  52. X|.....|.|......| |.....--- |......---  |....---.......|                    |
  53. X|.....|.|------| |....--   --....-- |-------- ----....---------------      |
  54. X|.....|--......---BBB-|     |...--  |.......|    |..................|      |
  55. X|..........||........-|    --...|   |.......|    |...||.............|      |
  56. X|.....|...-||-........------....|   |.......---- |...||.............--     |
  57. X|.....|--......---...........--------..........| |.......---------...--    |
  58. X|.....| |------| |--.......--|   |..B......----- -----....| |.|  |....---  |
  59. X|.....| |......--| ------..| |----..B......|       |.--------.-- |-.....---|
  60. X|------ |........|  |.|....| |.....----BBBB---------...........---.........|
  61. X|       |........|  |...|..| |.....|  |-.............--------...........---|
  62. X|       --.....-----------.| |....-----.....----------     |.........----  |
  63. X|        |..|..B...........| |.|..........|.|              |.|........|    |
  64. X----------------------------------------------------------------------------
  65. XENDMAP
  66. X# Dungeon Description
  67. X# The shrine to Moloch.
  68. XREGION:(01,06,05,14),lit,"temple"
  69. X# The Morgues
  70. XREGION:(19,01,24,08),unlit,"morgue",filled,true
  71. XREGION:(09,14,16,18),unlit,"morgue",filled,true
  72. XREGION:(37,09,43,14),unlit,"morgue",filled,true
  73. X# Stairs
  74. XSTAIR:(01,01),down
  75. X# Branch location
  76. XBRANCH:(66,17,66,17),(0,0,0,0)
  77. X
  78. X# Secret Doors
  79. XDOOR:locked,(04,01)
  80. XDOOR:locked,(08,04)
  81. XDOOR:locked,(06,06)
  82. X
  83. X# The altar of Moloch.
  84. XALTAR:(03,10),noalign,shrine
  85. X
  86. X# Non diggable walls - everywhere!
  87. XNON_DIGGABLE:(00,00,75,19)
  88. X
  89. X# Objects
  90. X# **LOTS** of dead bodies (all human).
  91. X# note: no priest(esse)s - maybe Moloch has a *special*
  92. X#       fate reserved for members of *that* class.
  93. X#
  94. XOBJECT:'%',"corpse",random,"archeologist",0
  95. XOBJECT:'%',"corpse",random,"archeologist",0
  96. XOBJECT:'%',"corpse",random,"barbarian",0
  97. XOBJECT:'%',"corpse",random,"barbarian",0
  98. XOBJECT:'%',"corpse",random,"caveman",0
  99. XOBJECT:'%',"corpse",random,"cavewoman",0
  100. XOBJECT:'%',"corpse",random,"healer",0
  101. XOBJECT:'%',"corpse",random,"healer",0
  102. XOBJECT:'%',"corpse",random,"knight",0
  103. XOBJECT:'%',"corpse",random,"knight",0
  104. XOBJECT:'%',"corpse",random,"rogue",0
  105. XOBJECT:'%',"corpse",random,"rogue",0
  106. XOBJECT:'%',"corpse",random,"samurai",0
  107. XOBJECT:'%',"corpse",random,"samurai",0
  108. XOBJECT:'%',"corpse",random,"tourist",0
  109. XOBJECT:'%',"corpse",random,"tourist",0
  110. XOBJECT:'%',"corpse",random,"valkyrie",0
  111. XOBJECT:'%',"corpse",random,"valkyrie",0
  112. XOBJECT:'%',"corpse",random,"wizard",0
  113. XOBJECT:'%',"corpse",random,"wizard",0
  114. X#
  115. X# Some random weapons and armor.
  116. X#
  117. XOBJECT:'[',random,random
  118. XOBJECT:'[',random,random
  119. XOBJECT:'[',random,random
  120. XOBJECT:'[',random,random
  121. XOBJECT:')',random,random
  122. XOBJECT:')',random,random
  123. XOBJECT:')',random,random
  124. XOBJECT:')',random,random
  125. X#
  126. X# Some random loot.
  127. X#
  128. XOBJECT:'*',"ruby",random
  129. XOBJECT:'*',random,random
  130. XOBJECT:'*',random,random
  131. XOBJECT:'!',random,random
  132. XOBJECT:'!',random,random
  133. XOBJECT:'!',random,random
  134. XOBJECT:'?',random,random
  135. XOBJECT:'?',random,random
  136. XOBJECT:'?',random,random
  137. XOBJECT:'/',random,random
  138. XOBJECT:'/',random,random
  139. XOBJECT:'=',random,random
  140. XOBJECT:'=',random,random
  141. XOBJECT:'+',random,random
  142. XOBJECT:'+',random,random
  143. XOBJECT:'(',random,random
  144. XOBJECT:'(',random,random
  145. XOBJECT:'(',random,random
  146. X
  147. X# (Not so) Random traps.
  148. XTRAP:"spiked pit", (05,02)
  149. XTRAP:"spiked pit", (14,05)
  150. XTRAP:"sleep gas", (03,01)
  151. XTRAP:"board", (21,12)
  152. XTRAP:"board", random
  153. XTRAP:"dart", (60,01)
  154. XTRAP:"dart", (26,17)
  155. XTRAP:"anti magic", random
  156. XTRAP:"anti magic", random
  157. XTRAP:"magic", random
  158. XTRAP:"magic", random
  159. X
  160. X# Random monsters.
  161. X# The ghosts.
  162. XMONSTER:' ',"ghost",random
  163. XMONSTER:' ',"ghost",random
  164. XMONSTER:' ',"ghost",random
  165. XMONSTER:' ',"ghost",random
  166. XMONSTER:' ',"ghost",random
  167. XMONSTER:' ',"ghost",random
  168. X# Add a few bats for atmosphere.
  169. XMONSTER:'B',"vampire bat",random
  170. XMONSTER:'B',"vampire bat",random
  171. XMONSTER:'B',"vampire bat",random
  172. X# And a lich for good measure.
  173. XMONSTER:'L',random,random
  174. X# Some undead nasties for good measure
  175. XMONSTER:'V',random,random
  176. XMONSTER:'V',random,random
  177. XMONSTER:'V',random,random
  178. XMONSTER:'Z',random,random
  179. XMONSTER:'Z',random,random
  180. XMONSTER:'Z',random,random
  181. XMONSTER:'Z',random,random
  182. XMONSTER:'M',random,random
  183. XMONSTER:'M',random,random
  184. XMONSTER:'M',random,random
  185. XMONSTER:'M',random,random
  186. X#
  187. X# The Juiblex level
  188. X#
  189. XMAZE:"juiblex",' '
  190. XFLAGS:noteleport
  191. XINIT_MAP:'.','}',true,true,unlit,false
  192. XGEOMETRY:center,center
  193. XMAP
  194. X..}}}}}.}}}}}.}}}}}.}}}}}.}}}}}.}}}}}.}}}}}.}}}}}..
  195. X.}}}.}}}}}..}}}..}}}}}..}}}..}}}}}..}}}..}}}}}.}}}.
  196. X}}}...}}..}}.}.}}.}}.}}}...}}}.}}}..}}}..}}}}...}}}
  197. X.}}}.}}.}}}.}}.}}.}}...}}.}}.....}}.....}....}.}}}.
  198. X..}}}..}}}.}}.}}.}}..}}.....}}.}}}.}}.}}}}}}}}}}}..
  199. X.}}}..}}}}}.}}.}}.}}...}}}}}.....}}.}}}}}}.....}}}.
  200. X}}}..}}...}}..}}.}}}.}}}...}}}.}}}.}.}}}}..P.P..}}}
  201. X}}.}}}}...}}}}}.}...}}}..P..}}}.}.}}}.}}}}.....}}}}
  202. X}.}}}}.}}.}..}.}}}}}}}..P.P..}}}.}}}.}}..}}...}}}}.
  203. X.}}}}.}}}}....}}}}}.}}}..P..}}}.}}}}.}}..}}...}}}.}
  204. X}}}}..}}.}}..}}}}...}}}}...}}}.}}}}}.}}}}.}}}}}}.}}
  205. X}}}...}}...}}}..}}}}}}}}}}}}.....}}}}.}}...}..}.}}}
  206. X.}}}..}}.}}}}....}}..}}}..}}.....}}}}.}}}.}....}}}.
  207. X..}}}.}}}}..}}..}}..}}..}}..}}.}}}..}.}..}}}..}}}..
  208. X.}}}.}}}}....}}}}..}}....}}}}}}}...}}}....}}}}.}}}.
  209. X}}}...}}}....}}}..}}}....}}}..}}...}}}....}}}...}}}
  210. X.}}}.}}}}}..}}}..}}}}}..}}}..}}}}}..}}}..}}}}}.}}}.
  211. X..}}}}}.}}}}}.}}}}}.}}}}}.}}}}}.}}}}}.}}}}}.}}}}}..
  212. XENDMAP
  213. X# Random registers
  214. XRANDOM_MONSTERS:'J','b','P','F'
  215. XRANDOM_PLACES:(04,02),(46,02),(04,15),(46,15)
  216. X# Dungeon description
  217. XREGION:(00,00,50,17),unlit,"swamp"
  218. XMAZEWALK:(00,09),west
  219. XMAZEWALK:(50,08),east
  220. XSTAIR:levregion(01,00,08,20),(0,0,50,17),down
  221. XSTAIR:levregion(69,00,79,20),(0,0,50,17),up
  222. XBRANCH:levregion(01,00,08,20),(0,0,50,17)
  223. XTELEPORT_REGION:levregion(01,00,08,20),(0,0,50,17),up
  224. XTELEPORT_REGION:levregion(69,00,79,20),(0,0,50,17),down
  225. XFOUNTAIN:place[0]
  226. XMONSTER:'m',"giant mimic",place[1],m_feature "fountain"
  227. XMONSTER:'m',"giant mimic",place[2],m_feature "fountain"
  228. XMONSTER:'m',"giant mimic",place[3],m_feature "fountain"
  229. X# The demon of the swamp
  230. XMONSTER:'&',"Juiblex",(25,08)
  231. X# And a couple demons
  232. XMONSTER:'i',"lemure",(43,08)
  233. XMONSTER:'i',"lemure",(44,08)
  234. XMONSTER:'i',"lemure",(45,08)
  235. X# Some liquids and gems
  236. XOBJECT:'*',random,(43,06)
  237. XOBJECT:'*',random,(45,06)
  238. XOBJECT:'!',random,(43,09)
  239. XOBJECT:'!',random,(44,09)
  240. XOBJECT:'!',random,(45,09)
  241. X# And lots of blobby monsters
  242. XMONSTER:monster[0],random,(25,06)
  243. XMONSTER:monster[1],random,(24,07)
  244. XMONSTER:monster[2],random,(26,07)
  245. XMONSTER:monster[3],random,(23,08)
  246. XMONSTER:monster[3],random,(27,08)
  247. XMONSTER:monster[2],random,(24,09)
  248. XMONSTER:monster[1],random,(26,09)
  249. XMONSTER:monster[0],random,(25,10)
  250. XMONSTER:'J',random,random
  251. XMONSTER:'J',random,random
  252. XMONSTER:'J',random,random
  253. XMONSTER:'J',random,random
  254. XMONSTER:'P',random,random
  255. XMONSTER:'P',random,random
  256. XMONSTER:'P',random,random
  257. XMONSTER:'P',random,random
  258. XMONSTER:'b',random,random
  259. XMONSTER:'b',random,random
  260. XMONSTER:'b',random,random
  261. XMONSTER:'F',random,random
  262. XMONSTER:'F',random,random
  263. XMONSTER:'F',random,random
  264. XMONSTER:'m',random,random
  265. XMONSTER:'m',random,random
  266. X# Some random objects
  267. XOBJECT:'!',random,random
  268. XOBJECT:'!',random,random
  269. XOBJECT:'!',random,random
  270. XOBJECT:'%',random,random
  271. XOBJECT:'%',random,random
  272. XOBJECT:'%',random,random
  273. X# Some traps
  274. XTRAP:"sleep gas",random
  275. XTRAP:"sleep gas",random
  276. XTRAP:"anti magic",random
  277. XTRAP:"anti magic",random
  278. XTRAP:"magic",random
  279. XTRAP:"magic",random
  280. X#
  281. X# The Orcus Level
  282. X#
  283. XMAZE:"orcus",random
  284. XFLAGS: noteleport,shortsighted
  285. XGEOMETRY:right,center
  286. X# A ghost town
  287. XMAP
  288. X.|....|....|....|..............|....|........
  289. X.|....|....|....|..............|....|........
  290. X.|....|....|....|--...-+-------|.............
  291. X.|....|....|....|..............+.............
  292. X.|.........|....|..............|....|........
  293. X.--+-...-+----+--....-------...--------.+----
  294. X.....................|.....|.................
  295. X.....................|.....|.................
  296. X.--+----....-+---....|.....|...----------+---
  297. X.|....|....|....|....---+---...|......|......
  298. X.|.........|....|..............|......|......
  299. X.----...---------.....-----....+......|......
  300. X.|........................|....|......|......
  301. X.----------+-...--+--|....|....----------+---
  302. X.|....|..............|....+....|.............
  303. X.|....+.......|......|....|....|.............
  304. X.|....|.......|......|....|....|.............
  305. XENDMAP
  306. XMAZEWALK:(00,06),west
  307. X# Entire main area
  308. XREGION:(01,00,44,16),unlit,"ordinary"
  309. XSTAIR:(33,15),down
  310. XSTAIR:levregion(01,00,12,20),levregion(20,01,70,20),up
  311. XBRANCH:levregion(01,00,12,20),levregion(20,01,70,20)
  312. XTELEPORT_REGION:levregion(01,00,12,20),levregion(20,01,70,20)
  313. X# Wall "ruins"
  314. XOBJECT:'`',"boulder",(19,02)
  315. XOBJECT:'`',"boulder",(20,02)
  316. XOBJECT:'`',"boulder",(21,02)
  317. XOBJECT:'`',"boulder",(36,02)
  318. XOBJECT:'`',"boulder",(36,03)
  319. XOBJECT:'`',"boulder",(06,04)
  320. XOBJECT:'`',"boulder",(05,05)
  321. XOBJECT:'`',"boulder",(06,05)
  322. XOBJECT:'`',"boulder",(07,05)
  323. XOBJECT:'`',"boulder",(39,05)
  324. XOBJECT:'`',"boulder",(08,08)
  325. XOBJECT:'`',"boulder",(09,08)
  326. XOBJECT:'`',"boulder",(10,08)
  327. XOBJECT:'`',"boulder",(11,08)
  328. XOBJECT:'`',"boulder",(06,10)
  329. XOBJECT:'`',"boulder",(05,11)
  330. XOBJECT:'`',"boulder",(06,11)
  331. XOBJECT:'`',"boulder",(07,11)
  332. XOBJECT:'`',"boulder",(21,11)
  333. XOBJECT:'`',"boulder",(21,12)
  334. XOBJECT:'`',"boulder",(13,13)
  335. XOBJECT:'`',"boulder",(14,13)
  336. XOBJECT:'`',"boulder",(15,13)
  337. XOBJECT:'`',"boulder",(14,14)
  338. X# Doors
  339. XDOOR:closed,(23,02)
  340. XDOOR:open,(31,03)
  341. XDOOR:nodoor,(03,05)
  342. XDOOR:closed,(09,05)
  343. XDOOR:closed,(14,05)
  344. XDOOR:closed,(40,05)
  345. XDOOR:open,(03,08)
  346. XDOOR:nodoor,(13,08)
  347. XDOOR:open,(41,08)
  348. XDOOR:closed,(24,09)
  349. XDOOR:closed,(31,11)
  350. XDOOR:open,(11,13)
  351. XDOOR:closed,(18,13)
  352. XDOOR:closed,(41,13)
  353. XDOOR:open,(26,14)
  354. XDOOR:closed,(06,15)
  355. X# Special rooms
  356. XALTAR:(24,07),noalign,sanctum
  357. XREGION:(22,12,25,16),unlit,"morgue"
  358. XREGION:(32,09,37,12),lit,"shop"
  359. XREGION:(12,00,15,04),lit,"shop"
  360. X# Some traps.
  361. XTRAP:"spiked pit", random
  362. XTRAP:"sleep gas", random
  363. XTRAP:"anti magic", random
  364. XTRAP:"fire", random
  365. XTRAP:"fire", random
  366. XTRAP:"fire", random
  367. XTRAP:"magic", random
  368. XTRAP:"magic", random
  369. X# Some random objects
  370. XOBJECT:random,random,random
  371. XOBJECT:random,random,random
  372. XOBJECT:random,random,random
  373. XOBJECT:random,random,random
  374. XOBJECT:random,random,random
  375. XOBJECT:random,random,random
  376. XOBJECT:random,random,random
  377. XOBJECT:random,random,random
  378. XOBJECT:random,random,random
  379. XOBJECT:random,random,random
  380. X# The resident nasty
  381. XMONSTER:'&',"Orcus",(33,15)
  382. X# And its preferred companions
  383. XMONSTER:'Z',"human zombie",(32,15)
  384. XMONSTER:' ',"shade",(32,14)
  385. XMONSTER:' ',"shade",(32,16)
  386. XMONSTER:'V',"vampire",(35,16)
  387. XMONSTER:'V',"vampire",(35,14)
  388. XMONSTER:'V',"vampire lord",(36,14)
  389. XMONSTER:'V',"vampire lord",(36,15)
  390. X# Randomly placed companions
  391. XMONSTER:'Z',"skeleton",random
  392. XMONSTER:'Z',"skeleton",random
  393. XMONSTER:'Z',"skeleton",random
  394. XMONSTER:'Z',"skeleton",random
  395. XMONSTER:'Z',"skeleton",random
  396. XMONSTER:' ',"shade",random
  397. XMONSTER:' ',"shade",random
  398. XMONSTER:' ',"shade",random
  399. XMONSTER:' ',"shade",random
  400. XMONSTER:'Z',"giant zombie",random
  401. XMONSTER:'Z',"giant zombie",random
  402. XMONSTER:'Z',"giant zombie",random
  403. XMONSTER:'Z',"ettin zombie",random
  404. XMONSTER:'Z',"ettin zombie",random
  405. XMONSTER:'Z',"ettin zombie",random
  406. XMONSTER:'Z',"human zombie",random
  407. XMONSTER:'Z',"human zombie",random
  408. XMONSTER:'Z',"human zombie",random
  409. XMONSTER:'V',"vampire",random
  410. XMONSTER:'V',"vampire",random
  411. XMONSTER:'V',"vampire",random
  412. XMONSTER:'V',"vampire lord",random
  413. XMONSTER:'V',"vampire lord",random
  414. X# A few more for the party
  415. XMONSTER:random,random,random
  416. XMONSTER:random,random,random
  417. XMONSTER:random,random,random
  418. XMONSTER:random,random,random
  419. XMONSTER:random,random,random
  420. X#
  421. X# The Asmodeus Level
  422. X#
  423. XMAZE:"asmodeus",random
  424. XFLAGS: noteleport
  425. X# First part
  426. XGEOMETRY:half-left,center
  427. XMAP
  428. X---------------------
  429. X|.............|.....|
  430. X|.............S.....|
  431. X|---+------------...|
  432. X|.....|.........|-+--
  433. X|..---|.........|....
  434. X|..|..S.........|....
  435. X|..|..|.........|....
  436. X|..|..|.........|-+--
  437. X|..|..-----------...|
  438. X|..S..........|.....|
  439. X---------------------
  440. XENDMAP
  441. XSTAIR:levregion(01,00,6,20),levregion(6,1,70,16),up
  442. XBRANCH:levregion(01,00,6,20),levregion(6,1,70,16)
  443. XTELEPORT_REGION:levregion(01,00,6,20),levregion(6,1,70,16)
  444. X
  445. X# Doors
  446. XDOOR:closed,(04,03)
  447. XDOOR:locked,(18,04)
  448. XDOOR:closed,(18,08)
  449. X#
  450. XSTAIR:(13,07),down
  451. X# Non diggable walls
  452. XNON_DIGGABLE:(00,00,20,11)
  453. X# Entire main area
  454. XREGION:(01,01,20,10),unlit,"ordinary"
  455. X# The fellow in residence
  456. XMONSTER:'&',"Asmodeus",(12,07)
  457. X# Some random weapons and armor.
  458. XOBJECT:'[',random,random
  459. XOBJECT:'[',random,random
  460. XOBJECT:')',random,random
  461. XOBJECT:')',random,random
  462. XOBJECT:'*',random,random
  463. XOBJECT:'!',random,random
  464. XOBJECT:'!',random,random
  465. XOBJECT:'?',random,random
  466. XOBJECT:'?',random,random
  467. XOBJECT:'?',random,random
  468. X# Some traps.
  469. XTRAP:"spiked pit", (05,02)
  470. XTRAP:"fire", (08,06)
  471. XTRAP:"sleep gas", random
  472. XTRAP:"anti magic", random
  473. XTRAP:"fire", random
  474. XTRAP:"magic", random
  475. XTRAP:"magic", random
  476. X# Random monsters.
  477. XMONSTER:' ',"ghost",(11,07)
  478. XMONSTER:'&',"horned devil",(10,05)
  479. XMONSTER:'L',random,random
  480. X# Some Vampires for good measure
  481. XMONSTER:'V',random,random
  482. XMONSTER:'V',random,random
  483. XMONSTER:'V',random,random
  484. X# Second part
  485. XGEOMETRY:half-right,center
  486. XMAP
  487. X---------------------------------
  488. X................................|
  489. X................................+
  490. X................................|
  491. X---------------------------------
  492. XENDMAP
  493. XMAZEWALK:(32,02),east
  494. X# Non diggable walls
  495. XNON_DIGGABLE:(00,00,32,04)
  496. XDOOR:closed,(32,02)
  497. XMONSTER:'&',random,random
  498. XMONSTER:'&',random,random
  499. XMONSTER:'&',random,random
  500. XTRAP:"anti magic", random
  501. XTRAP:"fire", random
  502. XTRAP:"magic", random
  503. X
  504. X#
  505. X# The Baalzebub level
  506. X#
  507. XMAZE:"baalz",random
  508. XFLAGS: noteleport
  509. XGEOMETRY:right,center
  510. XMAP
  511. X-------------------------------------------------
  512. X|                    ---               ----      
  513. X|          ----      |   ------------  |         
  514. X| ------      |  --------|..........|---         
  515. X| |....|  -------|...........--------------      
  516. X---....|--|..................S............|----  
  517. X....--....S..----------------|............S...|  
  518. X---....|--|..................|............|----  
  519. X| |....|  -------|...........-----S--------      
  520. X| ------      |  --------|..........|---         
  521. X|          ----     |    ------------  |         
  522. X|                   ---                ----      
  523. X-------------------------------------------------
  524. XENDMAP
  525. XSTAIR:levregion(01,00,15,20),levregion(15,1,70,16),up
  526. XBRANCH:levregion(01,00,15,20),levregion(15,1,70,16)
  527. XTELEPORT_REGION:levregion(01,00,15,20),levregion(15,1,70,16)
  528. XNON_DIGGABLE:(00,00,46,12)
  529. XMAZEWALK:(00,06),west
  530. XSTAIR:(44,06),down
  531. X# The fellow in residence
  532. XMONSTER:'&',"Baalzebub",(35,06)
  533. X# Some random weapons and armor.
  534. XOBJECT:'[',random,random
  535. XOBJECT:'[',random,random
  536. XOBJECT:')',random,random
  537. XOBJECT:')',random,random
  538. XOBJECT:'*',random,random
  539. XOBJECT:'!',random,random
  540. XOBJECT:'!',random,random
  541. XOBJECT:'?',random,random
  542. XOBJECT:'?',random,random
  543. XOBJECT:'?',random,random
  544. X# Some traps.
  545. XTRAP:"spiked pit", random
  546. XTRAP:"fire", random
  547. XTRAP:"sleep gas", random
  548. XTRAP:"anti magic", random
  549. XTRAP:"fire", random
  550. XTRAP:"magic", random
  551. XTRAP:"magic", random
  552. X# Random monsters.
  553. XMONSTER:' ',"ghost",(37,07)
  554. XMONSTER:'&',"horned devil",(32,05)
  555. XMONSTER:'&',"barbed devil",(38,07)
  556. XMONSTER:'L',random,random
  557. X# Some Vampires for good measure
  558. XMONSTER:'V',random,random
  559. XMONSTER:'V',random,random
  560. XMONSTER:'V',random,random
  561. X#
  562. X# The Sanctum Level
  563. X#
  564. XMAZE:"sanctum", ' '
  565. XFLAGS: noteleport,hardfloor
  566. XGEOMETRY:center,center
  567. XMAP
  568. X----------------------------------------------------------------------------
  569. X|             --------------                                               |
  570. X|             |............|             -------                           |
  571. X|       -------............-----         |.....|                           |
  572. X|       |......................|        --.....|            ---------      |
  573. X|    ----......................---------|......----         |.......|      |
  574. X|    |........---------..........|......+.........|     ------+---..|      |
  575. X|  ---........|.......|..........--S----|.........|     |........|..|      |
  576. X|  |..........|.......|.............|   |.........-------..----------      |
  577. X|  |..........|.......|..........----   |..........|....|..|......|        |
  578. X|  |..........|.......|..........|      --.......----+---S---S--..|        |
  579. X|  |..........---------..........|       |.......|.............|..|        |
  580. X|  ---...........................|       -----+-------S---------S---       |
  581. X|    |...........................|          |...| |......|    |....|--     |
  582. X|    ----.....................----          |...---....---  ---......|     |
  583. X|       |.....................|             |..........|    |.....----     |
  584. X|       -------...........-----             --...-------    |.....|        |
  585. X|             |...........|                  |...|          |.....|        |
  586. X|             -------------                  -----          -------        |
  587. X----------------------------------------------------------------------------
  588. XENDMAP
  589. XREGION:(15,07,21,10),lit,"temple"
  590. XALTAR:(18,08),noalign,sanctum
  591. XREGION:(41,06,48,11),unlit,"morgue",filled,true
  592. X# Non diggable walls
  593. XNON_DIGGABLE:(00,00,75,19)
  594. X# Doors
  595. XDOOR:closed,(40,06)
  596. XDOOR:locked,(62,06)
  597. XDOOR:closed,(46,12)
  598. XDOOR:closed,(53,10)
  599. X# Surround the temple with fire
  600. XTRAP:"fire",(13,05)
  601. XTRAP:"fire",(14,05)
  602. XTRAP:"fire",(15,05)
  603. XTRAP:"fire",(16,05)
  604. XTRAP:"fire",(17,05)
  605. XTRAP:"fire",(18,05)
  606. XTRAP:"fire",(19,05)
  607. XTRAP:"fire",(20,05)
  608. XTRAP:"fire",(21,05)
  609. XTRAP:"fire",(22,05)
  610. XTRAP:"fire",(23,05)
  611. XTRAP:"fire",(13,12)
  612. XTRAP:"fire",(14,12)
  613. XTRAP:"fire",(15,12)
  614. XTRAP:"fire",(16,12)
  615. XTRAP:"fire",(17,12)
  616. XTRAP:"fire",(18,12)
  617. XTRAP:"fire",(19,12)
  618. XTRAP:"fire",(20,12)
  619. XTRAP:"fire",(21,12)
  620. XTRAP:"fire",(22,12)
  621. XTRAP:"fire",(23,12)
  622. XTRAP:"fire",(13,06)
  623. XTRAP:"fire",(13,07)
  624. XTRAP:"fire",(13,08)
  625. XTRAP:"fire",(13,09)
  626. XTRAP:"fire",(13,10)
  627. XTRAP:"fire",(13,11)
  628. XTRAP:"fire",(23,06)
  629. XTRAP:"fire",(23,07)
  630. XTRAP:"fire",(23,08)
  631. XTRAP:"fire",(23,09)
  632. XTRAP:"fire",(23,10)
  633. XTRAP:"fire",(23,11)
  634. X# Some traps.
  635. XTRAP:"spiked pit", random
  636. XTRAP:"fire", random
  637. XTRAP:"sleep gas", random
  638. XTRAP:"anti magic", random
  639. XTRAP:"fire", random
  640. XTRAP:"magic", random
  641. X# Some random objects
  642. XOBJECT:'[',random,random
  643. XOBJECT:'[',random,random
  644. XOBJECT:'[',random,random
  645. XOBJECT:'[',random,random
  646. XOBJECT:')',random,random
  647. XOBJECT:')',random,random
  648. XOBJECT:'*',random,random
  649. XOBJECT:'!',random,random
  650. XOBJECT:'!',random,random
  651. XOBJECT:'!',random,random
  652. XOBJECT:'!',random,random
  653. XOBJECT:'?',random,random
  654. XOBJECT:'?',random,random
  655. XOBJECT:'?',random,random
  656. XOBJECT:'?',random,random
  657. XOBJECT:'?',random,random
  658. X# Some monsters.
  659. XMONSTER:'&',"horned devil",(14,12),hostile
  660. XMONSTER:'&',"barbed devil",(18,08),hostile
  661. XMONSTER:'&',"erinyes",(10,04),hostile
  662. XMONSTER:'&',"marilith",(15,04),hostile
  663. XMONSTER:'&',"nalfeshnee",(27,08),hostile
  664. X# Moloch's horde
  665. XMONSTER:'@',"aligned priest",(20,03),noalign,hostile
  666. XMONSTER:'@',"aligned priest",(15,04),noalign,hostile
  667. XMONSTER:'@',"aligned priest",(11,05),noalign,hostile
  668. XMONSTER:'@',"aligned priest",(11,07),noalign,hostile
  669. XMONSTER:'@',"aligned priest",(11,09),noalign,hostile
  670. XMONSTER:'@',"aligned priest",(11,12),noalign,hostile
  671. XMONSTER:'@',"aligned priest",(15,13),noalign,hostile
  672. XMONSTER:'@',"aligned priest",(17,13),noalign,hostile
  673. XMONSTER:'@',"aligned priest",(21,13),noalign,hostile
  674. X# A few nasties
  675. XMONSTER:'L',random,random
  676. XMONSTER:'L',random,random
  677. XMONSTER:'V',random,random
  678. XMONSTER:'V',random,random
  679. XMONSTER:'V',random,random
  680. XSTAIR:(63,15),up
  681. END_OF_FILE
  682. if test 19835 -ne `wc -c <'dat/gehennom.des'`; then
  683.     echo shar: \"'dat/gehennom.des'\" unpacked with wrong size!
  684. fi
  685. # end of 'dat/gehennom.des'
  686. fi
  687. if test -f 'include/os2conf.h' -a "${1}" != "-c" ; then 
  688.   echo shar: Will not clobber existing file \"'include/os2conf.h'\"
  689. else
  690. echo shar: Extracting \"'include/os2conf.h'\" \(2442 characters\)
  691. sed "s/^X//" >'include/os2conf.h' <<'END_OF_FILE'
  692. X/*    SCCS Id: @(#)os2conf.h    3.1    93/01/18 */
  693. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  694. X/* Copyright (c) Timo Hakulinen, 1990, 1991, 1992, 1993. */
  695. X/* NetHack may be freely redistributed.  See license for details. */
  696. X
  697. X#ifdef OS2
  698. X#ifndef OS2CONF_H
  699. X#define OS2CONF_H
  700. X
  701. X/*
  702. X * Compiler configuration.  Compiler may be
  703. X * selected either here or in Makefile.os2.
  704. X */
  705. X
  706. X/* #define OS2_MSC        /* Microsoft C 5.1 and 6.0 */
  707. X/* #define OS2_GCC        /* GCC emx 0.8f */
  708. X/* #define OS2_CSET2        /* IBM C Set/2 (courtesy Jeff Urlwin) */
  709. X
  710. X/*
  711. X * System configuration.
  712. X */
  713. X
  714. X#define OS2_USESYSHEADERS    /* use compiler's own system headers */
  715. X
  716. X#if defined(OS2_GCC) || defined(OS2_CSET2)
  717. X# define OS2_32BITAPI        /* enable for compilation in OS/2 2.0 */
  718. X#endif
  719. X
  720. X/*
  721. X * Other configurable options.  Generally no
  722. X * reason to touch the defaults, I think.
  723. X */
  724. X
  725. X#define MFLOPPY            /* floppy and ramdisk support */
  726. X#define RANDOM            /* Berkeley random(3) */
  727. X#define SHELL            /* shell escape */
  728. X/* #define TERMLIB        /* use termcap file */
  729. X#define ANSI_DEFAULT        /* allows NetHack to run without termcap file */
  730. X#define TEXTCOLOR        /* allow color */
  731. X
  732. X/*
  733. X * The remaining code shouldn't need modification.
  734. X */
  735. X
  736. X#ifdef MSDOS
  737. X# undef MSDOS            /* MSC autodefines this but we don't want it */
  738. X#endif
  739. X
  740. X#ifndef MICRO
  741. X# define MICRO            /* must be defined to allow some inclusions */
  742. X#endif
  743. X
  744. X#if !defined(TERMLIB) && !defined(ANSI_DEFAULT)
  745. X# define ANSI_DEFAULT    /* have to have one or the other */
  746. X#endif
  747. X
  748. X#define PATHLEN     260    /* maximum pathlength (HPFS) */
  749. X#define FILENAME    260    /* maximum filename length (HPFS) */
  750. X#ifndef MICRO_H
  751. X#include "micro.h"        /* necessary externs for [os_name].c */
  752. X#endif
  753. X
  754. X#ifdef MFLOPPY
  755. X
  756. X# define FROMPERM    1    /* for ramdisk use */
  757. X# define TOPERM        2    /* - " - */
  758. X# define ACTIVE        1
  759. X# define SWAPPED    2
  760. X
  761. Xstruct finfo {
  762. X    int  where;
  763. X    long time;
  764. X    long size;
  765. X};
  766. Xextern struct finfo fileinfo[];
  767. X# define ZFINFO { 0, 0L, 0L }
  768. X
  769. X#endif /* MFLOPPY */
  770. X
  771. X#ifndef SYSTEM_H
  772. X# include "system.h"
  773. X#endif
  774. X
  775. X#define index    strchr
  776. X#define rindex    strrchr
  777. X
  778. X#include <time.h>
  779. X
  780. X/* the high quality random number routines */
  781. X
  782. X#ifdef RANDOM
  783. X# define Rand()    random()
  784. X#else
  785. X# define Rand()    rand()
  786. X#endif
  787. X
  788. X/* file creation mask */
  789. X
  790. X#include <sys\types.h>
  791. X#include <sys\stat.h>
  792. X
  793. X#define FCMASK    (S_IREAD | S_IWRITE)
  794. X
  795. X#include <fcntl.h>
  796. X
  797. X#define exit    msexit        /* do chdir first */
  798. X
  799. X#ifndef REDO
  800. X# undef    Getchar
  801. X# define Getchar nhgetch
  802. X#endif
  803. X
  804. X#endif /* OS2CONF_H */
  805. X#endif /* OS2 */
  806. END_OF_FILE
  807. if test 2442 -ne `wc -c <'include/os2conf.h'`; then
  808.     echo shar: \"'include/os2conf.h'\" unpacked with wrong size!
  809. fi
  810. # end of 'include/os2conf.h'
  811. fi
  812. if test -f 'src/sp_lev.c2' -a "${1}" != "-c" ; then 
  813.   echo shar: Will not clobber existing file \"'src/sp_lev.c2'\"
  814. else
  815. echo shar: Extracting \"'src/sp_lev.c2'\" \(32785 characters\)
  816. sed "s/^X//" >'src/sp_lev.c2' <<'END_OF_FILE'
  817. X/*
  818. X * Disgusting hack: since special levels have their rooms filled before
  819. X * sorting the rooms, we have to re-arrange the speed values upstairs_room
  820. X * and dnstairs_room after the rooms have been sorted.  On normal levels,
  821. X * stairs don't get created until _after_ sorting takes place.
  822. X */
  823. Xstatic void
  824. Xfix_stair_rooms()
  825. X{
  826. X    register i;
  827. X    register struct mkroom     *croom;
  828. X
  829. X    if(xdnstair &&
  830. X       !((dnstairs_room->lx <= xdnstair && xdnstair <= dnstairs_room->hx) &&
  831. X     (dnstairs_room->ly <= ydnstair && ydnstair <= dnstairs_room->hy))) {
  832. X    for(i=0; i < nroom; i++) {
  833. X        croom = &rooms[i];
  834. X        if((croom->lx <= xdnstair && xdnstair <= croom->hx) &&
  835. X           (croom->ly <= ydnstair && ydnstair <= croom->hy)) {
  836. X        dnstairs_room = croom;
  837. X        break;
  838. X        }
  839. X    }
  840. X    if(i == nroom)
  841. X        panic("Couldn't find dnstair room in fix_stair_rooms!");
  842. X    }
  843. X    if(xupstair &&
  844. X       !((upstairs_room->lx <= xupstair && xupstair <= upstairs_room->hx) &&
  845. X     (upstairs_room->ly <= yupstair && yupstair <= upstairs_room->hy))) {
  846. X    for(i=0; i < nroom; i++) {
  847. X        croom = &rooms[i];
  848. X        if((croom->lx <= xupstair && xupstair <= croom->hx) &&
  849. X           (croom->ly <= yupstair && yupstair <= croom->hy)) {
  850. X        upstairs_room = croom;
  851. X        break;
  852. X        }
  853. X    }
  854. X    if(i == nroom)
  855. X        panic("Couldn't find upstair room in fix_stair_rooms!");
  856. X    }
  857. X}
  858. X
  859. X/* 
  860. X * Corridors always start from a door. But it can end anywhere...
  861. X * Basically we search for door coordinates or for endpoints coordinates
  862. X * (from a distance).
  863. X */
  864. X
  865. Xstatic void
  866. Xcreate_corridor(c)
  867. Xcorridor    *c;
  868. X{
  869. X    coord org, dest;
  870. X
  871. X    if (c->src.room == -1) {
  872. X        sort_rooms();
  873. X        fix_stair_rooms();
  874. X        makecorridors();
  875. X        return;
  876. X    }
  877. X
  878. X    if( !search_door(&rooms[c->src.room], &org.x, &org.y, c->src.wall,
  879. X             c->src.door))
  880. X        return;
  881. X
  882. X    if (c->dest.room != -1) {
  883. X        if(!search_door(&rooms[c->dest.room], &dest.x, &dest.y,
  884. X                c->dest.wall, c->dest.door))
  885. X            return;
  886. X        switch(c->src.wall) {
  887. X              case W_NORTH: org.y--; break;
  888. X              case W_SOUTH: org.y++; break;
  889. X              case W_WEST:  org.x--; break;
  890. X              case W_EAST:  org.x++; break;
  891. X        }
  892. X        switch(c->dest.wall) {
  893. X              case W_NORTH: dest.y--; break;
  894. X              case W_SOUTH: dest.y++; break;
  895. X              case W_WEST:  dest.x--; break;
  896. X              case W_EAST:  dest.x++; break;
  897. X        }
  898. X        (void) dig_corridor(org, dest, FALSE, CORR, STONE);
  899. X    }
  900. X}
  901. X
  902. X
  903. X/* 
  904. X * Fill a room (shop, zoo, etc...) with appropriate stuff.
  905. X */
  906. X
  907. Xvoid
  908. Xfill_room(croom, prefilled)
  909. Xstruct mkroom     *croom;
  910. Xboolean prefilled;
  911. X{
  912. X    if (!croom || croom->rtype == OROOM)
  913. X        return;
  914. X
  915. X    if(prefilled) {
  916. X        switch(croom->rtype) {
  917. X        case COURT:
  918. X        level.flags.has_court = 1;
  919. X        break;
  920. X#ifdef ARMY
  921. X        case BARRACKS:
  922. X        level.flags.has_barracks = 1;
  923. X        break;
  924. X#endif
  925. X        case ZOO:
  926. X        level.flags.has_zoo = 1;
  927. X        break;
  928. X        case MORGUE:
  929. X        level.flags.has_morgue = 1;
  930. X        break;
  931. X        case SWAMP:
  932. X        level.flags.has_swamp = 1;
  933. X        break;
  934. X        case BEEHIVE:
  935. X        level.flags.has_beehive = 1;
  936. X        break;
  937. X        }
  938. X        return;
  939. X    }
  940. X    /* Vault ? */
  941. X    if (croom->rtype == VAULT) {
  942. X        int x,y;
  943. X        for (x=croom->lx;x<=croom->hx;x++)
  944. X            for (y=croom->ly;y<=croom->hy;y++)
  945. X            mkgold((long)rn1(depth(&u.uz)*100, 51), x, y);
  946. X        return;
  947. X    }
  948. X
  949. X    /* Shop ? */
  950. X    if (croom->rtype >= SHOPBASE) {
  951. X        stock_room(croom->rtype - SHOPBASE, croom);
  952. X        return;
  953. X    }
  954. X
  955. X    /* Zoo ? */
  956. X    switch (croom->rtype) {
  957. X          case COURT:
  958. X          case ZOO:
  959. X          case BEEHIVE:
  960. X          case MORGUE:
  961. X          case BARRACKS:
  962. X        fill_zoo(croom);
  963. X        break;
  964. X    }
  965. X}
  966. X
  967. Xstatic void
  968. Xfree_rooms(ro, n)
  969. Xroom **ro;
  970. Xint n;
  971. X{
  972. X    short j;
  973. X    room *r;
  974. X    
  975. X    while(n--) {
  976. X        r = ro[n];
  977. X        Free(r->name);
  978. X        Free(r->parent);
  979. X        if (j = r->ndoor) {
  980. X            while(j--)
  981. X                Free(r->doors[j]);
  982. X            Free(r->doors);
  983. X        }
  984. X        if (j = r->ntrap) {
  985. X            while (j--)
  986. X                Free(r->traps[j]);
  987. X            Free(r->traps);
  988. X        }
  989. X        if (j = r->nmonster) {
  990. X            while (j--) {
  991. X                Free(r->monsters[j]->name);
  992. X                Free(r->monsters[j]->appear_as);
  993. X                Free(r->monsters[j]);
  994. X            }
  995. X            Free(r->monsters);
  996. X        }
  997. X        if (j = r->nobject) {
  998. X            while(j--) {
  999. X                Free(r->objects[j]->name);
  1000. X                Free(r->objects[j]);
  1001. X            }
  1002. X            Free(r->objects);
  1003. X        }
  1004. X        if (j = r->nstair) {
  1005. X            while(j--)
  1006. X                Free(r->stairs[j]);
  1007. X            Free(r->stairs);
  1008. X        }
  1009. X        if (j = r->naltar) {
  1010. X            while (j--)
  1011. X                Free(r->altars[j]);
  1012. X            Free(r->altars);
  1013. X        }
  1014. X        if (j = r->ngold) {
  1015. X            while(j--)
  1016. X                Free(r->golds[j]);
  1017. X            Free(r->golds);
  1018. X        }
  1019. X        if (j = r->nengraving) {
  1020. X            while(j--) {
  1021. X                Free(r->engravings[j]->e.text);
  1022. X                Free(r->engravings[j]);
  1023. X            }
  1024. X            Free(r->engravings);
  1025. X        }
  1026. X        if (j = r->nfountain) {
  1027. X            while(j--)
  1028. X                Free(r->fountains[j]);
  1029. X            Free(r->fountains);
  1030. X        }
  1031. X        if (j = r->nsink) {
  1032. X            while(j--)
  1033. X                Free(r->sinks[j]);
  1034. X            Free(r->sinks);
  1035. X        }
  1036. X        if (j = r->npool) {
  1037. X            while(j--)
  1038. X                Free(r->pools[j]);
  1039. X            Free(r->pools);
  1040. X        }
  1041. X        Free(r);
  1042. X    }
  1043. X}
  1044. X
  1045. Xstatic void
  1046. Xbuild_room(r, pr)
  1047. Xroom *r, *pr;
  1048. X{
  1049. X    boolean okroom;
  1050. X    struct mkroom    *aroom;
  1051. X    short i;
  1052. X    xchar rtype = (!r->chance || rn2(100) < r->chance) ? r->rtype : OROOM;
  1053. X
  1054. X    if(pr) {
  1055. X        aroom = &subrooms[nsubroom];
  1056. X        okroom = create_subroom(pr->mkr, r->x, r->y, r->w, r->h,
  1057. X                    rtype, r->rlit);
  1058. X    } else {
  1059. X        aroom = &rooms[nroom];
  1060. X        okroom = create_room(r->x, r->y, r->w, r->h, r->xalign,
  1061. X                     r->yalign, rtype, r->rlit);
  1062. X        r->mkr = aroom;
  1063. X    }
  1064. X
  1065. X    if (okroom) {
  1066. X        /* Create subrooms if necessary... */
  1067. X        for(i=0; i < r->nsubroom; i++)
  1068. X            build_room(r->subrooms[i], r);
  1069. X        /* And now we can fill the room! */
  1070. X        
  1071. X        /* Priority to the stairs */
  1072. X
  1073. X        for(i=0; i <r->nstair; i++)
  1074. X            create_stairs(r->stairs[i], aroom);
  1075. X
  1076. X        /* Then to the various elements (sinks, etc..) */
  1077. X        for(i = 0; i<r->nsink; i++)
  1078. X            create_feature(r->sinks[i]->x, r->sinks[i]->y, aroom, SINK);
  1079. X        for(i = 0; i<r->npool; i++)
  1080. X            create_feature(r->pools[i]->x, r->pools[i]->y, aroom, POOL);
  1081. X        for(i = 0; i<r->nfountain; i++)
  1082. X            create_feature(r->fountains[i]->x, r->fountains[i]->y,
  1083. X                   aroom, FOUNTAIN);
  1084. X        for(i = 0; i<r->naltar; i++)
  1085. X            create_altar(r->altars[i], aroom);
  1086. X        for(i = 0; i<r->ndoor; i++)
  1087. X            create_door(r->doors[i], aroom);
  1088. X
  1089. X        /* The traps */
  1090. X        for(i = 0; i<r->ntrap; i++)
  1091. X            create_trap(r->traps[i], aroom);
  1092. X
  1093. X        /* The monsters */
  1094. X        for(i = 0; i<r->nmonster; i++)
  1095. X            create_monster(r->monsters[i], aroom);
  1096. X
  1097. X        /* The objects */
  1098. X        for(i = 0; i<r->nobject; i++)
  1099. X            create_object(r->objects[i], aroom);
  1100. X
  1101. X        /* The gold piles */
  1102. X        for(i = 0; i<r->ngold; i++)
  1103. X            create_gold(r->golds[i], aroom);
  1104. X
  1105. X        /* The engravings */
  1106. X        for(i = 0; i<r->nengraving; i++) {
  1107. X            schar xx, yy;
  1108. X
  1109. X            xx = r->engravings[i]->x;
  1110. X            yy = r->engravings[i]->y;
  1111. X            get_room_loc(&xx, &yy, aroom);
  1112. X            make_engr_at(xx, yy, r->engravings[i]->e.text,
  1113. X                     0L, r->engravings[i]->etype);
  1114. X        }
  1115. X#ifdef SPECIALIZATION
  1116. X        topologize(aroom,FALSE);        /* set roomno */
  1117. X#else
  1118. X        topologize(aroom);            /* set roomno */
  1119. X#endif
  1120. X        /* MRS - 07/04/91 - This is temporary but should result
  1121. X         * in proper filling of shops, etc.
  1122. X         * DLC - this can fail if corridors are added to this room
  1123. X         * at a later point.  Currently no good way to fix this.
  1124. X         */
  1125. X        if(aroom->rtype != OROOM && r->filled) fill_room(aroom, FALSE);
  1126. X    }
  1127. X}
  1128. X
  1129. X/*
  1130. X * set lighting in a region that will not become a room.
  1131. X */
  1132. Xstatic void
  1133. Xlight_region(tmpregion)
  1134. X    region  *tmpregion;
  1135. X{
  1136. X    register boolean litstate = tmpregion->rlit ? 1 : 0;
  1137. X    register int hiy = tmpregion->y2;
  1138. X    register int x, y;
  1139. X    register struct rm *lev;
  1140. X    int lowy = tmpregion->y1;
  1141. X    int lowx = tmpregion->x1, hix = tmpregion->x2;
  1142. X
  1143. X    if(litstate) {
  1144. X    /* adjust region size for walls, but only if lighted */
  1145. X    lowx = max(lowx-1,1);
  1146. X    hix = min(hix+1,COLNO-1);
  1147. X    lowy = max(lowy-1,0);
  1148. X    hiy = min(hiy+1, ROWNO-1);
  1149. X    }
  1150. X    for(x = lowx; x <= hix; x++) {
  1151. X    lev = &levl[x][lowy];
  1152. X    for(y = lowy; y <= hiy; y++)
  1153. X        lev++->lit = litstate;
  1154. X    }
  1155. X}
  1156. X
  1157. X/* initialization common to all special levels */
  1158. Xstatic void
  1159. Xload_common_data(fd, typ)
  1160. XFILE *fd;
  1161. Xint typ;
  1162. X{
  1163. X    uchar    n;
  1164. X    long    lev_flags;
  1165. X    int    i;
  1166. X
  1167. X      {
  1168. X    aligntyp atmp;
  1169. X    /* shuffle 3 alignments; can't use sp_lev_shuffle() on aligntyp's */
  1170. X    i = rn2(3);   atmp=ralign[2]; ralign[2]=ralign[i]; ralign[i]=atmp;
  1171. X    if (rn2(2)) { atmp=ralign[1]; ralign[1]=ralign[0]; ralign[0]=atmp; }
  1172. X      }
  1173. X
  1174. X    level.flags.is_maze_lev = typ == SP_LEV_MAZE;
  1175. X
  1176. X    /* free up old level regions */
  1177. X    if(num_lregions) {
  1178. X        for(i=0; i<num_lregions; i++)
  1179. X            if(lregions[i].rname) Free(lregions[i].rname);
  1180. X        Free(lregions);
  1181. X        num_lregions = 0;
  1182. X    }
  1183. X    lregions = (lev_region *) 0;
  1184. X
  1185. X    /* Read the level initialization data */
  1186. X    Fread((genericptr_t) &init_lev, 1, sizeof(lev_init), fd);
  1187. X    if(init_lev.init_present) {
  1188. X        if(init_lev.lit < 0)
  1189. X        init_lev.lit = rn2(2);
  1190. X        mkmap(&init_lev);
  1191. X    }
  1192. X
  1193. X    /* Read the per level flags */
  1194. X    Fread((genericptr_t) &lev_flags, 1, sizeof(lev_flags), fd);
  1195. X    if (lev_flags & NOTELEPORT)
  1196. X        level.flags.noteleport = 1;
  1197. X    if (lev_flags & HARDFLOOR)
  1198. X        level.flags.hardfloor = 1;
  1199. X    if (lev_flags & NOMMAP)
  1200. X        level.flags.nommap = 1;
  1201. X    if (lev_flags & SHORTSIGHTED)
  1202. X        level.flags.shortsighted = 1;
  1203. X
  1204. X    /* Read message */
  1205. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1206. X    if (n) {
  1207. X        lev_message = (char *) alloc(n + 1);
  1208. X        Fread((genericptr_t) lev_message, 1, (int) n, fd);
  1209. X        lev_message[n] = 0;
  1210. X    }
  1211. X}
  1212. X
  1213. Xstatic boolean
  1214. Xload_rooms(fd)
  1215. XFILE *fd;
  1216. X{
  1217. X    xchar        nrooms;
  1218. X    char        n;
  1219. X    short        size;
  1220. X    corridor    tmpcor;
  1221. X    room**        tmproom;
  1222. X    int        i, j, ncorr;
  1223. X
  1224. X    load_common_data(fd, SP_LEV_ROOMS);
  1225. X
  1226. X    Fread((genericptr_t) &n, 1, sizeof(n), fd); /* nrobjects */
  1227. X    if (n) {
  1228. X        Fread((genericptr_t)robjects, sizeof(*robjects), n, fd);
  1229. X        sp_lev_shuffle(robjects, (char *)0, (int)n);
  1230. X    }
  1231. X
  1232. X    Fread((genericptr_t) &n, 1, sizeof(n), fd); /* nrmonst */
  1233. X    if (n) {
  1234. X        Fread((genericptr_t)rmonst, sizeof(*rmonst), n, fd);
  1235. X        sp_lev_shuffle(rmonst, (char *)0, (int)n);
  1236. X    }
  1237. X
  1238. X    Fread((genericptr_t) &nrooms, 1, sizeof(nrooms), fd);
  1239. X                        /* Number of rooms to read */
  1240. X    tmproom = NewTab(room,nrooms);
  1241. X    for (i=0;i<nrooms;i++) {
  1242. X        room *r;
  1243. X
  1244. X        r = tmproom[i] = New(room);
  1245. X
  1246. X        /* Let's see if this room has a name */
  1247. X        Fread((genericptr_t) &size, 1, sizeof(size), fd);
  1248. X        if (size > 0) {    /* Yup, it does! */
  1249. X            r->name = (char *) alloc(size + 1);
  1250. X            Fread((genericptr_t) r->name, 1, size, fd);
  1251. X            r->name[size] = 0;
  1252. X        } else
  1253. X            r->name = (char *) 0;
  1254. X
  1255. X        /* Let's see if this room has a parent */
  1256. X        Fread((genericptr_t) &size, 1, sizeof(size), fd);
  1257. X        if (size > 0) {    /* Yup, it does! */
  1258. X            r->parent = (char *) alloc(size + 1);
  1259. X            Fread((genericptr_t) r->parent, 1, size, fd);
  1260. X            r->parent[size] = 0;
  1261. X        } else
  1262. X            r->parent = (char *) 0;
  1263. X        
  1264. X        Fread((genericptr_t) &r->x, 1, sizeof(r->x), fd);
  1265. X                    /* x pos on the grid (1-5) */
  1266. X        Fread((genericptr_t) &r->y, 1, sizeof(r->y), fd);
  1267. X                     /* y pos on the grid (1-5) */
  1268. X        Fread((genericptr_t) &r->w, 1, sizeof(r->w), fd);
  1269. X                     /* width of the room */
  1270. X        Fread((genericptr_t) &r->h, 1, sizeof(r->h), fd);
  1271. X                     /* height of the room */
  1272. X        Fread((genericptr_t) &r->xalign, 1, sizeof(r->xalign), fd);
  1273. X                     /* horizontal alignment */
  1274. X        Fread((genericptr_t) &r->yalign, 1, sizeof(r->yalign), fd);
  1275. X                     /* vertical alignment */
  1276. X        Fread((genericptr_t) &r->rtype, 1, sizeof(r->rtype), fd);
  1277. X                     /* type of room (zoo, shop, etc.) */
  1278. X        Fread((genericptr_t) &r->chance, 1, sizeof(r->chance), fd);
  1279. X                     /* chance of room being special. */
  1280. X        Fread((genericptr_t) &r->rlit, 1, sizeof(r->rlit), fd);
  1281. X                     /* lit or not ? */
  1282. X        Fread((genericptr_t) &r->filled, 1, sizeof(r->filled), fd);
  1283. X                     /* to be filled? */
  1284. X        r->nsubroom= 0;
  1285. X
  1286. X        /* read the doors */
  1287. X        Fread((genericptr_t) &r->ndoor, 1, sizeof(r->ndoor), fd);
  1288. X        if(n = r->ndoor)
  1289. X            r->doors = NewTab(room_door, n);
  1290. X        while(n--) {
  1291. X            r->doors[n] = New(room_door);
  1292. X            Fread((genericptr_t) r->doors[n], 1,
  1293. X                sizeof(room_door), fd);
  1294. X        }
  1295. X
  1296. X        /* read the traps */
  1297. X        Fread((genericptr_t) &r->ntrap, 1, sizeof(r->ntrap), fd);
  1298. X        if(n = r->ntrap)
  1299. X            r->traps = NewTab(trap, n);
  1300. X        while(n--) {
  1301. X            r->traps[n] = New(trap);
  1302. X            Fread((genericptr_t) r->traps[n], 1, sizeof(trap), fd);
  1303. X        }
  1304. X
  1305. X        /* read the monsters */
  1306. X        Fread((genericptr_t) &r->nmonster, 1, sizeof(r->nmonster), fd);
  1307. X        if(n = r->nmonster)
  1308. X            r->monsters = NewTab(monster, n);
  1309. X        while(n--) {
  1310. X            r->monsters[n] = New(monster);
  1311. X            Fread((genericptr_t) r->monsters[n], 1,
  1312. X                sizeof(monster), fd);
  1313. X            Fread((genericptr_t) &size, sizeof(size), 1, fd);
  1314. X            if (size) {
  1315. X                r->monsters[n]->name= (char *) alloc(size + 1);
  1316. X                Fread((genericptr_t)r->monsters[n]->name,
  1317. X                    1, size, fd);
  1318. X                r->monsters[n]->name[size] = 0;
  1319. X            } else
  1320. X                r->monsters[n]->name = (char *) 0;
  1321. X
  1322. X            Fread((genericptr_t) &size, sizeof(size), 1, fd);
  1323. X            if (size) {
  1324. X                r->monsters[n]->appear_as=
  1325. X                            (char *) alloc(size + 1);
  1326. X                Fread((genericptr_t)r->monsters[n]->appear_as,
  1327. X                    1, size, fd);
  1328. X                r->monsters[n]->appear_as[size] = 0;
  1329. X            } else
  1330. X                r->monsters[n]->appear_as = (char *) 0;
  1331. X         }
  1332. X
  1333. X        /* read the objects */
  1334. X        Fread((genericptr_t) &r->nobject, 1, sizeof(r->nobject), fd);
  1335. X        if(n = r->nobject)
  1336. X            r->objects = NewTab(object, n);
  1337. X        while (n--) {
  1338. X            r->objects[n] = New(object);
  1339. X            Fread((genericptr_t) r->objects[n], 1,
  1340. X                sizeof(object), fd);
  1341. X            Fread((genericptr_t) &size, 1, sizeof(size), fd);
  1342. X            if (size) {
  1343. X                r->objects[n]->name = (char *) alloc(size + 1);
  1344. X                Fread((genericptr_t)r->objects[n]->name,
  1345. X                    1, size, fd);
  1346. X                r->objects[n]->name[size] = 0;
  1347. X            } else
  1348. X                r->objects[n]->name = (char *) 0;
  1349. X        }
  1350. X
  1351. X        /* read the stairs */
  1352. X        Fread((genericptr_t) &r->nstair, 1, sizeof(r->nstair), fd);
  1353. X        if (n = r->nstair)
  1354. X            r->stairs = NewTab(stair, n);
  1355. X        while (n--) {
  1356. X            r->stairs[n] = New(stair);
  1357. X            Fread((genericptr_t) r->stairs[n], 1,
  1358. X                sizeof(stair), fd);
  1359. X        }
  1360. X
  1361. X        /* read the altars */
  1362. X        Fread((genericptr_t) &r->naltar, 1, sizeof(r->naltar), fd);
  1363. X        if (n = r->naltar)
  1364. X            r->altars = NewTab(altar, n);
  1365. X        while (n--) {
  1366. X            r->altars[n] = New(altar);
  1367. X            Fread((genericptr_t) r->altars[n], 1,
  1368. X                sizeof(altar), fd);
  1369. X        }
  1370. X
  1371. X        /* read the gold piles */
  1372. X        Fread((genericptr_t) &r->ngold, 1, sizeof(r->ngold), fd);
  1373. X        if (n = r->ngold)
  1374. X            r->golds = NewTab(gold, n);
  1375. X        while (n--) {
  1376. X            r->golds[n] = New(gold);
  1377. X            Fread((genericptr_t) r->golds[n], 1, sizeof(gold), fd);
  1378. X        }
  1379. X
  1380. X        /* read the engravings */
  1381. X        Fread((genericptr_t) &r->nengraving, 1,
  1382. X            sizeof(r->nengraving), fd);
  1383. X        if (n = r->nengraving)
  1384. X            r->engravings = NewTab(engraving,n);
  1385. X        while(n--) {
  1386. X            r->engravings[n] = New(engraving);
  1387. X            Fread((genericptr_t) r->engravings[n],
  1388. X                1, sizeof *r->engravings[n], fd);
  1389. X            size = r->engravings[n]->e.length;
  1390. X            r->engravings[n]->e.text = (char *) alloc(size+1);
  1391. X            Fread((genericptr_t) r->engravings[n]->e.text,
  1392. X                1, size, fd);
  1393. X            r->engravings[n]->e.text[size] = '\0';
  1394. X        }
  1395. X
  1396. X        /* read the fountains */
  1397. X        Fread((genericptr_t) &r->nfountain, 1,
  1398. X            sizeof(r->nfountain), fd);
  1399. X        if (n = r->nfountain)
  1400. X            r->fountains = NewTab(fountain, n);
  1401. X        while (n--) {
  1402. X            r->fountains[n] = New(fountain);
  1403. X            Fread((genericptr_t) r->fountains[n], 1,
  1404. X                sizeof(fountain), fd);
  1405. X        }
  1406. X
  1407. X        /* read the sinks */
  1408. X        Fread((genericptr_t) &r->nsink, 1, sizeof(r->nsink), fd);
  1409. X        if (n = r->nsink)
  1410. X            r->sinks = NewTab(sink, n);
  1411. X        while (n--) {
  1412. X            r->sinks[n] = New(sink);
  1413. X            Fread((genericptr_t) r->sinks[n], 1, sizeof(sink), fd);
  1414. X        }
  1415. X
  1416. X        /* read the pools */
  1417. X        Fread((genericptr_t) &r->npool, 1, sizeof(r->npool), fd);
  1418. X        if (n = r->npool)
  1419. X            r->pools = NewTab(pool,n);
  1420. X        while (n--) {
  1421. X            r->pools[n] = New(pool);
  1422. X            Fread((genericptr_t) r->pools[n], 1, sizeof(pool), fd);
  1423. X        }
  1424. X
  1425. X    }
  1426. X
  1427. X    /* Now that we have loaded all the rooms, search the
  1428. X     * subrooms and create the links.
  1429. X     */
  1430. X
  1431. X    for (i = 0; i<nrooms; i++)
  1432. X        if (tmproom[i]->parent) {
  1433. X            /* Search the parent room */
  1434. X            for(j=0; j<nrooms; j++)
  1435. X            if (tmproom[j]->name && !strcmp(tmproom[j]->name,
  1436. X                               tmproom[i]->parent)) {
  1437. X                n = tmproom[j]->nsubroom++;
  1438. X                tmproom[j]->subrooms[n] = tmproom[i];
  1439. X                break;
  1440. X            }
  1441. X        }
  1442. X
  1443. X    /* 
  1444. X     * Create the rooms now...
  1445. X     */
  1446. X
  1447. X    for (i=0; i < nrooms; i++)
  1448. X        if(!tmproom[i]->parent)
  1449. X        build_room(tmproom[i], (room *) 0);
  1450. X
  1451. X    free_rooms(tmproom, nrooms);
  1452. X
  1453. X    /* read the corridors */
  1454. X
  1455. X    Fread((genericptr_t) &ncorr, sizeof(ncorr), 1, fd);
  1456. X    for (i=0; i<ncorr; i++) {
  1457. X        Fread((genericptr_t) &tmpcor, 1, sizeof(tmpcor), fd);
  1458. X        create_corridor(&tmpcor);
  1459. X    }
  1460. X
  1461. X    return TRUE;
  1462. X}
  1463. X
  1464. X/*
  1465. X * Select a random coordinate in the maze.
  1466. X *
  1467. X * We want a place not 'touched' by the loader.  That is, a place in
  1468. X * the maze outside every part of the special level.
  1469. X */
  1470. X
  1471. Xstatic void
  1472. Xmaze1xy(m)
  1473. Xcoord *m;
  1474. X{
  1475. X    do {
  1476. X        m->x = rn1(x_maze_max - 3, 3);
  1477. X        m->y = rn1(y_maze_max - 3, 3);
  1478. X    } while (!(m->x % 2) || !(m->y % 2) || Map[m->x][m->y]);
  1479. X}
  1480. X
  1481. X/* 
  1482. X * The Big Thing: special maze loader
  1483. X *
  1484. X * Could be cleaner, but it works.
  1485. X */
  1486. X
  1487. Xstatic boolean
  1488. Xload_maze(fd)
  1489. XFILE *fd;
  1490. X{
  1491. X    xchar   x, y, typ;
  1492. X    boolean prefilled;
  1493. X
  1494. X    char    n, numpart = 0;
  1495. X    xchar   nwalk = 0, nwalk_sav;
  1496. X    short   filling;
  1497. X    char    halign, valign;
  1498. X
  1499. X    int     xi, yi, dir;
  1500. X    coord   mm;
  1501. X    int     mapcount, mapcountmax, mapfact;
  1502. X
  1503. X    lev_region  tmplregion;
  1504. X    region  tmpregion;
  1505. X    door    tmpdoor;
  1506. X    trap    tmptrap;
  1507. X    monster tmpmons;
  1508. X    object  tmpobj;
  1509. X    drawbridge tmpdb;
  1510. X    walk    tmpwalk;
  1511. X    digpos  tmpdig;
  1512. X    lad     tmplad;
  1513. X    stair   tmpstair, prevstair;
  1514. X    altar   tmpaltar;
  1515. X    gold    tmpgold;
  1516. X    fountain tmpfountain;
  1517. X    engraving tmpengraving;
  1518. X    xchar   mustfill[(MAXNROFROOMS+1)*2];
  1519. X    struct trap *badtrap;
  1520. X    boolean has_bounds;
  1521. X
  1522. X    load_common_data(fd, SP_LEV_MAZE);
  1523. X
  1524. X    /* Initialize map */
  1525. X    Fread((genericptr_t) &filling, 1, sizeof(filling), fd);
  1526. X    if(!init_lev.init_present) /* don't init if mkmap() has been called */
  1527. X      for(x = 2; x <= x_maze_max; x++)
  1528. X    for(y = 0; y <= y_maze_max; y++)
  1529. X        if (filling == -1) {
  1530. X#ifndef WALLIFIED_MAZE
  1531. X            levl[x][y].typ = STONE;
  1532. X#else
  1533. X            levl[x][y].typ =
  1534. X            (y < 2 || ((x % 2) && (y % 2))) ? STONE : HWALL;
  1535. X#endif
  1536. X            Map[x][y] = 0;
  1537. X        } else {
  1538. X            levl[x][y].typ = filling;
  1539. X            Map[x][y] = 0;
  1540. X        }
  1541. X
  1542. X    /* Start reading the file */
  1543. X    Fread((genericptr_t) &numpart, 1, sizeof(numpart), fd);
  1544. X                        /* Number of parts */
  1545. X    if (!numpart || numpart > 9)
  1546. X    panic("load_maze error: numpart = %d", (int) numpart);
  1547. X
  1548. X    while (numpart--) {
  1549. X    Fread((genericptr_t) &halign, 1, sizeof(halign), fd);
  1550. X                    /* Horizontal alignment */
  1551. X    Fread((genericptr_t) &valign, 1, sizeof(valign), fd);
  1552. X                    /* Vertical alignment */
  1553. X    Fread((genericptr_t) &xsize, 1, sizeof(xsize), fd);
  1554. X                    /* size in X */
  1555. X    Fread((genericptr_t) &ysize, 1, sizeof(ysize), fd);
  1556. X                    /* size in Y */
  1557. X    switch((int) halign) {
  1558. X        case LEFT:        xstart = 3;                 break;
  1559. X        case H_LEFT:    xstart = 2+((x_maze_max-2-xsize)/4);    break;
  1560. X        case CENTER:    xstart = 2+((x_maze_max-2-xsize)/2);    break;
  1561. X        case H_RIGHT:   xstart = 2+((x_maze_max-2-xsize)*3/4);    break;
  1562. X        case RIGHT:     xstart = x_maze_max-xsize-1;        break;
  1563. X    }
  1564. X    switch((int) valign) {
  1565. X        case TOP:        ystart = 3;                 break;
  1566. X        case CENTER:    ystart = 2+((y_maze_max-2-ysize)/2);    break;
  1567. X        case BOTTOM:    ystart = y_maze_max-ysize-1;        break;
  1568. X    }
  1569. X    if (!(xstart % 2)) xstart++;
  1570. X    if (!(ystart % 2)) ystart++;
  1571. X    if ((ystart < 0) || (ystart + ysize > ROWNO)) {
  1572. X        /* try to move the start a bit */
  1573. X        ystart += (ystart > 0) ? -2 : 2;
  1574. X        if(ysize == ROWNO) ystart = 0;
  1575. X        if(ystart < 0 || ystart + ysize > ROWNO)
  1576. X        panic("reading special level with ysize to large");
  1577. X    }
  1578. X
  1579. X    /*
  1580. X     * If any CROSSWALLs are found, must change to ROOM after REGION's
  1581. X     * are laid out.  CROSSWALLS are used to specify "invisible"
  1582. X     * boundaries where DOOR syms look bad or aren't desirable.
  1583. X     */
  1584. X    has_bounds = FALSE;
  1585. X
  1586. X    if(init_lev.init_present && xsize <= 1 && ysize <= 1) {
  1587. X        xstart = 1;
  1588. X        ystart = 0;
  1589. X        xsize = COLNO-1;
  1590. X        ysize = ROWNO;
  1591. X    } else {
  1592. X        /* Load the map */
  1593. X        for(y = ystart; y < ystart+ysize; y++)
  1594. X        for(x = xstart; x < xstart+xsize; x++) {
  1595. X            levl[x][y].typ = (schar) fgetc(fd);
  1596. X            levl[x][y].lit = FALSE;
  1597. X            /*
  1598. X             * Note: Even though levl[x][y].typ is type schar,
  1599. X             *     lev_comp.y saves it as type char. Since schar != char
  1600. X             *     all the time we must make this exception or hack
  1601. X             *     through lev_comp.y to fix.
  1602. X             */
  1603. X
  1604. X            /*
  1605. X             *  Set secret doors to closed (why not trapped too?).  Set
  1606. X             *  the horizontal bit.
  1607. X             */
  1608. X            if (levl[x][y].typ == SDOOR || IS_DOOR(levl[x][y].typ)) {
  1609. X            if(levl[x][y].typ == SDOOR)
  1610. X                levl[x][y].doormask = D_CLOSED;
  1611. X            /*
  1612. X             *  If there is a wall to the left that connects to a
  1613. X             *  (secret) door, then it is horizontal.  This does
  1614. X             *  not allow (secret) doors to be corners of rooms.
  1615. X             */
  1616. X            if (x != xstart && (IS_WALL(levl[x-1][y].typ) ||
  1617. X                        levl[x-1][y].horizontal))
  1618. X                levl[x][y].horizontal = 1;
  1619. X            } else if(levl[x][y].typ == HWALL)
  1620. X            levl[x][y].horizontal = 1;
  1621. X            else if(levl[x][y].typ == LAVAPOOL)
  1622. X            levl[x][y].lit = 1;
  1623. X            else if(levl[x][y].typ == CROSSWALL)
  1624. X            has_bounds = TRUE;
  1625. X            Map[x][y] = 1;
  1626. X        }
  1627. X    }
  1628. X
  1629. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1630. X                        /* Number of level regions */
  1631. X    if(n) {
  1632. X        if(num_lregions) {
  1633. X        /* realloc the lregion space to add the new ones */
  1634. X        /* don't really free it up until the whole level is done */
  1635. X        lev_region *newl = (lev_region *) alloc(sizeof(lev_region) *
  1636. X                            (n+num_lregions));
  1637. X        (void) memcpy((genericptr_t)(newl+n), (genericptr_t)lregions,
  1638. X                    sizeof(lev_region) * num_lregions);
  1639. X        Free(lregions);
  1640. X        num_lregions += n;
  1641. X        lregions = newl;
  1642. X        } else {
  1643. X        num_lregions = n;
  1644. X        lregions = (lev_region *) alloc(sizeof(lev_region) * n);
  1645. X        }
  1646. X    }
  1647. X
  1648. X    while(n--) {
  1649. X        Fread((genericptr_t) &tmplregion, sizeof(tmplregion), 1, fd);
  1650. X        if(tmplregion.rname) {
  1651. X        char len;
  1652. X
  1653. X        Fread((genericptr_t) &len, sizeof(len), 1, fd);
  1654. X        tmplregion.rname = (char *) alloc(len + 1);
  1655. X        Fread((genericptr_t) tmplregion.rname, len, 1, fd);
  1656. X        tmplregion.rname[len] = 0;
  1657. X        }
  1658. X        if(!tmplregion.in_islev) {
  1659. X        get_location(&tmplregion.inarea.x1, &tmplregion.inarea.y1,
  1660. X                                DRY|WET);
  1661. X        get_location(&tmplregion.inarea.x2, &tmplregion.inarea.y2,
  1662. X                                DRY|WET);
  1663. X        }
  1664. X        if(!tmplregion.del_islev) {
  1665. X        get_location(&tmplregion.delarea.x1, &tmplregion.delarea.y1,
  1666. X                                DRY|WET);
  1667. X        get_location(&tmplregion.delarea.x2, &tmplregion.delarea.y2,
  1668. X                                DRY|WET);
  1669. X        }
  1670. X        lregions[n] = tmplregion;
  1671. X    }
  1672. X
  1673. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1674. X                        /* Random objects */
  1675. X    if(n) {
  1676. X        Fread((genericptr_t)robjects, sizeof(*robjects), (int) n, fd);
  1677. X        sp_lev_shuffle(robjects, (char *)0, (int)n);
  1678. X    }
  1679. X
  1680. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1681. X                        /* Random locations */
  1682. X    if(n) {
  1683. X        Fread((genericptr_t)rloc_x, sizeof(*rloc_x), (int) n, fd);
  1684. X        Fread((genericptr_t)rloc_y, sizeof(*rloc_y), (int) n, fd);
  1685. X        sp_lev_shuffle(rloc_x, rloc_y, (int)n);
  1686. X    }
  1687. X
  1688. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1689. X                        /* Random monsters */
  1690. X    if(n) {
  1691. X        Fread((genericptr_t)rmonst, sizeof(*rmonst), (int) n, fd);
  1692. X        sp_lev_shuffle(rmonst, (char *)0, (int)n);
  1693. X    }
  1694. X
  1695. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1696. X                        /* Number of subrooms */
  1697. X
  1698. X    (void) memset((genericptr_t)mustfill, 0, sizeof(mustfill));
  1699. X
  1700. X    while(n--) {
  1701. X        register struct mkroom *troom;
  1702. X
  1703. X        Fread((genericptr_t)&tmpregion, 1, sizeof(tmpregion), fd);
  1704. X
  1705. X        if(tmpregion.rtype > MAXRTYPE) {
  1706. X            tmpregion.rtype -= MAXRTYPE+1;
  1707. X            prefilled = TRUE;
  1708. X        } else
  1709. X            prefilled = FALSE;
  1710. X
  1711. X        if(tmpregion.rlit < 0)
  1712. X            tmpregion.rlit = (rnd(1+abs(depth(&u.uz))) < 11 && rn2(77))
  1713. X            ? TRUE : FALSE;
  1714. X
  1715. X        get_location(&tmpregion.x1, &tmpregion.y1, DRY|WET);
  1716. X        get_location(&tmpregion.x2, &tmpregion.y2, DRY|WET);
  1717. X
  1718. X        if (((tmpregion.rtype == OROOM) && !tmpregion.rirreg) ||
  1719. X            (nroom >= MAXNROFROOMS)) {
  1720. X            if(tmpregion.rtype != OROOM || tmpregion.rirreg)
  1721. X            impossible("Too many rooms on new level!");
  1722. X            light_region(&tmpregion);
  1723. X            continue;
  1724. X        }
  1725. X
  1726. X        troom = &rooms[nroom];
  1727. X
  1728. X        /* mark rooms that must be filled, but do it later */
  1729. X        if (tmpregion.rtype != OROOM)
  1730. X            mustfill[nroom] = (prefilled ? 2 : 1);
  1731. X
  1732. X        if(tmpregion.rirreg) {
  1733. X            min_rx = max_rx = tmpregion.x1;
  1734. X            min_ry = max_ry = tmpregion.y1;
  1735. X            flood_fill_rm(tmpregion.x1, tmpregion.y1,
  1736. X                  nroom+ROOMOFFSET, tmpregion.rlit, TRUE);
  1737. X            add_room(min_rx, min_ry, max_rx, max_ry,
  1738. X                 FALSE, tmpregion.rtype, TRUE);
  1739. X            troom->rlit = tmpregion.rlit;
  1740. X            troom->irregular = TRUE;
  1741. X        } else {
  1742. X            add_room(tmpregion.x1, tmpregion.y1,
  1743. X                 tmpregion.x2, tmpregion.y2,
  1744. X                 tmpregion.rlit, tmpregion.rtype, TRUE);
  1745. X#ifdef SPECIALIZATION
  1746. X            topologize(troom,FALSE);        /* set roomno */
  1747. X#else
  1748. X            topologize(troom);            /* set roomno */
  1749. X#endif
  1750. X        }
  1751. X    }
  1752. X
  1753. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1754. X                        /* Number of doors */
  1755. X    while(n--) {
  1756. X        struct mkroom *croom = &rooms[0];
  1757. X
  1758. X        Fread((genericptr_t)&tmpdoor, 1, sizeof(tmpdoor), fd);
  1759. X
  1760. X        x = tmpdoor.x;    y = tmpdoor.y;
  1761. X        typ = tmpdoor.mask == -1 ? rnddoor() : tmpdoor.mask;
  1762. X
  1763. X        get_location(&x, &y, DRY);
  1764. X        if(levl[x][y].typ != SDOOR)
  1765. X            levl[x][y].typ = DOOR;
  1766. X        else {
  1767. X            if(typ < D_CLOSED)
  1768. X                typ = D_CLOSED; /* force it to be closed */
  1769. X        }
  1770. X        levl[x][y].doormask = typ;
  1771. X
  1772. X        /* Now the complicated part, list it with each subroom */
  1773. X        /* The dog move and mail daemon routines use this */
  1774. X        while(croom->hx >= 0 && doorindex < DOORMAX) {
  1775. X            if(croom->hx >= x-1 && croom->lx <= x+1 &&
  1776. X               croom->hy >= y-1 && croom->ly <= y+1) {
  1777. X            /* Found it */
  1778. X            add_door(x, y, croom);
  1779. X            }
  1780. X            croom++;
  1781. X        }
  1782. X    }
  1783. X
  1784. X    /* now that we have rooms _and_ associated doors, fill the rooms */
  1785. X    for(n = 0; n < SIZE(mustfill); n++)
  1786. X        if(mustfill[n])
  1787. X        fill_room(&rooms[n], (mustfill[n] == 2));
  1788. X
  1789. X    /* if special boundary syms (CROSSWALL) in map, remove them now */
  1790. X    if(has_bounds) {
  1791. X        for(x = xstart; x < xstart+xsize; x++)
  1792. X        for(y = ystart; y < ystart+ysize; y++)
  1793. X            if(levl[x][y].typ == CROSSWALL)
  1794. X            levl[x][y].typ = ROOM;
  1795. X    }
  1796. X
  1797. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1798. X                        /* Number of traps */
  1799. X    while(n--) {
  1800. X        Fread((genericptr_t)&tmptrap, 1, sizeof(tmptrap), fd);
  1801. X
  1802. X        create_trap(&tmptrap, (struct mkroom *)0);
  1803. X    }
  1804. X
  1805. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1806. X                        /* Number of monsters */
  1807. X    while(n--) {
  1808. X        short size;
  1809. X
  1810. X        Fread((genericptr_t) &tmpmons, 1, sizeof(tmpmons), fd);
  1811. X        Fread((genericptr_t) &size, 1, sizeof(size), fd);
  1812. X        if (size) {
  1813. X            tmpmons.name = (char *) alloc(size + 1);
  1814. X            Fread((genericptr_t) tmpmons.name, 1, size, fd);
  1815. X            tmpmons.name[size] = 0;
  1816. X        } else
  1817. X            tmpmons.name = (char *) 0;
  1818. X        Fread((genericptr_t) &size, 1, sizeof(size), fd);
  1819. X        if (size) {
  1820. X            tmpmons.appear_as = (char *) alloc(size + 1);
  1821. X            Fread((genericptr_t) tmpmons.appear_as, 1, size, fd);
  1822. X            tmpmons.appear_as[size] = 0;
  1823. X        } else
  1824. X            tmpmons.appear_as = (char *) 0;
  1825. X
  1826. X        create_monster(&tmpmons, (struct mkroom *)0);
  1827. X
  1828. X        if (tmpmons.name)
  1829. X            free((genericptr_t) tmpmons.name);
  1830. X        if (tmpmons.appear_as)
  1831. X            free((genericptr_t) tmpmons.appear_as);
  1832. X    }
  1833. X
  1834. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1835. X                        /* Number of objects */
  1836. X    while(n--) {
  1837. X        short size;
  1838. X
  1839. X        Fread((genericptr_t) &tmpobj, 1, sizeof(object), fd);
  1840. X        Fread((genericptr_t) &size, 1, sizeof(size), fd);
  1841. X        if (size) {
  1842. X            tmpobj.name = (char *) alloc(size + 1);
  1843. X            Fread((genericptr_t) tmpobj.name, 1, size, fd);
  1844. X            tmpobj.name[size] = 0;
  1845. X        } else
  1846. X            tmpobj.name = (char *) 0;
  1847. X
  1848. X        create_object(&tmpobj, (struct mkroom *)0);
  1849. X
  1850. X        if (size)
  1851. X            free((genericptr_t) tmpobj.name);
  1852. X    }
  1853. X
  1854. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1855. X                        /* Number of drawbridges */
  1856. X    while(n--) {
  1857. X        Fread((genericptr_t)&tmpdb, 1, sizeof(tmpdb), fd);
  1858. X
  1859. X        x = tmpdb.x;  y = tmpdb.y;
  1860. X        get_location(&x, &y, DRY|WET);
  1861. X
  1862. X        if (!create_drawbridge(x, y, tmpdb.dir, tmpdb.db_open))
  1863. X            impossible("Cannot create drawbridge.");
  1864. X    }
  1865. X
  1866. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1867. X                        /* Number of mazewalks */
  1868. X    while(n--) {
  1869. X        Fread((genericptr_t)&tmpwalk, 1, sizeof(tmpwalk), fd);
  1870. X
  1871. X        get_location(&tmpwalk.x, &tmpwalk.y, DRY|WET);
  1872. X
  1873. X        walklist[nwalk++] = tmpwalk;
  1874. X    }
  1875. X
  1876. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1877. X                        /* Number of non_diggables */
  1878. X    while(n--) {
  1879. X        Fread((genericptr_t)&tmpdig, 1, sizeof(tmpdig), fd);
  1880. X
  1881. X        get_location(&tmpdig.x1, &tmpdig.y1, DRY|WET);
  1882. X        get_location(&tmpdig.x2, &tmpdig.y2, DRY|WET);
  1883. X
  1884. X        make_walls_nondiggable(tmpdig.x1, tmpdig.y1,
  1885. X                       tmpdig.x2, tmpdig.y2);
  1886. X    }
  1887. X
  1888. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1889. X                        /* Number of ladders */
  1890. X    while(n--) {
  1891. X        Fread((genericptr_t)&tmplad, 1, sizeof(tmplad), fd);
  1892. X
  1893. X        x = tmplad.x;  y = tmplad.y;
  1894. X        get_location(&x, &y, DRY);
  1895. X
  1896. X        levl[x][y].typ = LADDER;
  1897. X        if (tmplad.up == 1) {
  1898. X            xupladder = x;    yupladder = y;
  1899. X            levl[x][y].ladder = LA_UP;
  1900. X        } else {
  1901. X            xdnladder = x;    ydnladder = y;
  1902. X            levl[x][y].ladder = LA_DOWN;
  1903. X        }
  1904. X    }
  1905. X
  1906. X    prevstair.x = prevstair.y = 0;
  1907. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1908. X                        /* Number of stairs */
  1909. X    while(n--) {
  1910. X        Fread((genericptr_t)&tmpstair, 1, sizeof(tmpstair), fd);
  1911. X
  1912. X        xi = 0;
  1913. X        do {
  1914. X            x = tmpstair.x;  y = tmpstair.y;
  1915. X            get_location(&x, &y, DRY);
  1916. X        } while(prevstair.x && xi++ < 100 &&
  1917. X            distmin(x,y,prevstair.x,prevstair.y) <= 8);
  1918. X        if ((badtrap = t_at(x,y)) != 0) deltrap(badtrap);
  1919. X        mkstairs(x, y, (char)tmpstair.up, (struct mkroom *)0);
  1920. X        prevstair.x = x;
  1921. X        prevstair.y = y;
  1922. X    }
  1923. X
  1924. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1925. X                        /* Number of altars */
  1926. X    while(n--) {
  1927. X        Fread((genericptr_t)&tmpaltar, 1, sizeof(tmpaltar), fd);
  1928. X
  1929. X        create_altar(&tmpaltar, (struct mkroom *)0);
  1930. X    }
  1931. X
  1932. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1933. X                        /* Number of gold pile */
  1934. X    while (n--) {
  1935. X        Fread((genericptr_t)&tmpgold, 1, sizeof(tmpgold), fd);
  1936. X
  1937. X        create_gold(&tmpgold, (struct mkroom *)0);
  1938. X    }
  1939. X
  1940. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1941. X                        /* Number of engravings */
  1942. X    while(n--) {
  1943. X        int size;
  1944. X        Fread((genericptr_t) &tmpengraving, 1,
  1945. X            sizeof(tmpengraving), fd);
  1946. X        size = tmpengraving.e.length;
  1947. X        tmpengraving.e.text = (char *) alloc(size+1);
  1948. X        Fread((genericptr_t) tmpengraving.e.text, 1, size, fd);
  1949. X        tmpengraving.e.text[size] = '\0';
  1950. X        
  1951. X        x = tmpengraving.x; y = tmpengraving.y;
  1952. X        get_location(&x, &y, DRY);
  1953. X        make_engr_at(x, y, tmpengraving.e.text, 0L, tmpengraving.etype);
  1954. X        free((genericptr_t) tmpengraving.e.text);
  1955. X    }
  1956. X
  1957. X    Fread((genericptr_t) &n, 1, sizeof(n), fd);
  1958. X                        /* Number of fountains */
  1959. X    while (n--) {
  1960. X        Fread((genericptr_t)&tmpfountain, 1, sizeof(tmpfountain), fd);
  1961. X
  1962. X        create_feature(tmpfountain.x, tmpfountain.y,
  1963. X                   (struct mkroom *)0, FOUNTAIN);
  1964. X    }
  1965. X    }
  1966. X
  1967. X    nwalk_sav = nwalk;
  1968. X    while(nwalk--) {
  1969. X        xi = walklist[nwalk].x;
  1970. X        yi = walklist[nwalk].y;
  1971. X        dir = walklist[nwalk].dir;
  1972. X
  1973. X        move(&xi, &yi, dir);
  1974. X        x = xi;
  1975. X        y = yi;
  1976. X
  1977. X        if(!IS_DOOR(levl[x][y].typ)) {
  1978. X#ifndef WALLIFIED_MAZE
  1979. X        levl[x][y].typ = CORR;
  1980. X#else
  1981. X        levl[x][y].typ = ROOM;
  1982. X#endif
  1983. X        levl[x][y].flags = 0;
  1984. X        }
  1985. X
  1986. X        /*
  1987. X         * We must be sure that the parity of the coordinates for
  1988. X         * walkfrom() is odd.  But we must also take into account
  1989. X         * what direction was chosen.
  1990. X         */
  1991. X        if(!(x % 2)) {
  1992. X        if (dir == W_EAST)
  1993. X            x++;
  1994. X        else
  1995. X            x--;
  1996. X
  1997. X        /* no need for IS_DOOR check; out of map bounds */
  1998. X#ifndef WALLIFIED_MAZE
  1999. X        levl[x][y].typ = CORR;
  2000. X#else
  2001. X        levl[x][y].typ = ROOM;
  2002. X#endif
  2003. X        levl[x][y].flags = 0;
  2004. X        }
  2005. X
  2006. X        if (!(y % 2))
  2007. X        if (dir == W_SOUTH)
  2008. X            y++;
  2009. X        else
  2010. X            y--;
  2011. X
  2012. X        walkfrom(x, y);
  2013. X    }
  2014. X    wallification(1, 0, COLNO-1, ROWNO-1);
  2015. X
  2016. X    /*
  2017. X     * If there's a significant portion of maze unused by the special level,
  2018. X     * we don't want it empty.
  2019. X     *
  2020. X     * Makes the number of traps, monsters, etc. proportional
  2021. X     * to the size of the maze.
  2022. X     */
  2023. X    mapcountmax = mapcount = (x_maze_max - 2) * (y_maze_max - 2);
  2024. X
  2025. X    for(x = 2; x < x_maze_max; x++)
  2026. X    for(y = 0; y < y_maze_max; y++)
  2027. X        if(Map[x][y]) mapcount--;
  2028. X
  2029. X    if (nwalk_sav && (mapcount > (int) (mapcountmax / 10))) {
  2030. X        mapfact = (int) ((mapcount * 100L) / mapcountmax);
  2031. X        for(x = rnd((int) (20 * mapfact) / 100); x; x--) {
  2032. X            maze1xy(&mm);
  2033. X            (void) mkobj_at(rn2(2) ? GEM_CLASS : RANDOM_CLASS,
  2034. X                            mm.x, mm.y, TRUE);
  2035. X        }
  2036. X        for(x = rnd((int) (12 * mapfact) / 100); x; x--) {
  2037. X            maze1xy(&mm);
  2038. X            (void) mksobj_at(BOULDER, mm.x, mm.y, TRUE);
  2039. X        }
  2040. X        maze1xy(&mm);
  2041. X        (void) makemon(&mons[PM_MINOTAUR], mm.x, mm.y);
  2042. X        for(x = rnd((int) (12 * mapfact) / 100); x; x--) {
  2043. X            maze1xy(&mm);
  2044. X            (void) makemon((struct permonst *) 0, mm.x, mm.y);
  2045. X        }
  2046. X        for(x = rn2((int) (15 * mapfact) / 100); x; x--) {
  2047. X            maze1xy(&mm);
  2048. X            mkgold(0L,mm.x,mm.y);
  2049. X        }
  2050. X        for(x = rn2((int) (15 * mapfact) / 100); x; x--) {
  2051. X            int trytrap = rndtrap();
  2052. X
  2053. X            maze1xy(&mm);
  2054. X            if (is_pool(mm.x,mm.y)) continue;
  2055. X            if (sobj_at(BOULDER, mm.x, mm.y))
  2056. X            while ((trytrap == PIT) || (trytrap == SPIKED_PIT)) 
  2057. X                trytrap = rndtrap();
  2058. X            (void) maketrap(mm.x, mm.y, trytrap);
  2059. X        }
  2060. X    }
  2061. X    return TRUE;
  2062. X}
  2063. X
  2064. X/*
  2065. X * General loader
  2066. X */
  2067. X
  2068. Xboolean
  2069. Xload_special(name)
  2070. Xconst char *name;
  2071. X{
  2072. X    FILE *fd;
  2073. X    boolean result;
  2074. X    char c;
  2075. X
  2076. X    fd = fopen_datafile(name, RDMODE);
  2077. X    if (!fd) return FALSE;
  2078. X
  2079. X    Fread((genericptr_t) &c, 1, sizeof(c), fd); /* c Header */
  2080. X
  2081. X    switch (c) {
  2082. X        case SP_LEV_ROOMS:
  2083. X            result = load_rooms(fd);
  2084. X            break;
  2085. X        case SP_LEV_MAZE:
  2086. X            result = load_maze(fd);
  2087. X            break;
  2088. X        default:    /* ??? */
  2089. X            result = FALSE;
  2090. X    }
  2091. X    (void)fclose(fd);
  2092. X    return result;
  2093. X}
  2094. X
  2095. X/*sp_lev.c*/
  2096. END_OF_FILE
  2097. if test 32785 -ne `wc -c <'src/sp_lev.c2'`; then
  2098.     echo shar: \"'src/sp_lev.c2'\" unpacked with wrong size!
  2099. fi
  2100. # end of 'src/sp_lev.c2'
  2101. fi
  2102. echo shar: End of archive 62 \(of 108\).
  2103. cp /dev/null ark62isdone
  2104. MISSING=""
  2105. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 \
  2106. 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 \
  2107. 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 \
  2108. 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 \
  2109. 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 \
  2110. 101 102 103 104 105 106 107 108 ; do
  2111.     if test ! -f ark${I}isdone ; then
  2112.     MISSING="${MISSING} ${I}"
  2113.     fi
  2114. done
  2115. if test "${MISSING}" = "" ; then
  2116.     echo You have unpacked all 108 archives.
  2117.     echo "Now execute 'rebuild.sh'"
  2118.     rm -f ark10[0-8]isdone ark[1-9]isdone ark[1-9][0-9]isdone
  2119. else
  2120.     echo You still need to unpack the following archives:
  2121.     echo "        " ${MISSING}
  2122. fi
  2123. ##  End of shell archive.
  2124. exit 0
  2125.