Below is the full text to mklev.c from the source code of NetHack 3.4.0. To link to a particular line, write [[NetHack 3.4.0/mklev.c#line123]], for example.
Warning! This is the source code from an old release. For the latest release, see Source code
| The NetHack General Public License applies to screenshots, source code and other content from NetHack. |
1. /* SCCS Id: @(#)mklev.c 3.4 2001/11/29 */ 2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */ 3. /* NetHack may be freely redistributed. See license for details. */ 4. 5. #include "hack.h" 6. /* #define DEBUG */ /* uncomment to enable code debugging */ 7. 8. #ifdef DEBUG 9. # ifdef WIZARD 10. #define debugpline if (wizard) pline 11. # else 12. #define debugpline pline 13. # endif 14. #endif 15. 16. /* for UNIX, Rand #def'd to (long)lrand48() or (long)random() */ 17. /* croom->lx etc are schar (width <= int), so % arith ensures that */ 18. /* conversion of result to int is reasonable */ 19. 20. 21. STATIC_DCL void FDECL(mkfount,(int,struct mkroom *)); 22. #ifdef SINKS 23. STATIC_DCL void FDECL(mksink,(struct mkroom *)); 24. #endif 25. STATIC_DCL void FDECL(mkaltar,(struct mkroom *)); 26. STATIC_DCL void FDECL(mkgrave,(struct mkroom *)); 27. STATIC_DCL void NDECL(makevtele); 28. STATIC_DCL void NDECL(clear_level_structures); 29. STATIC_DCL void NDECL(makelevel); 30. STATIC_DCL void NDECL(mineralize); 31. STATIC_DCL boolean FDECL(bydoor,(XCHAR_P,XCHAR_P)); 32. STATIC_DCL struct mkroom *FDECL(find_branch_room, (coord *)); 33. STATIC_DCL struct mkroom *FDECL(pos_to_room, (XCHAR_P, XCHAR_P)); 34. STATIC_DCL boolean FDECL(place_niche,(struct mkroom *,int*,int*,int*)); 35. STATIC_DCL void FDECL(makeniche,(int)); 36. STATIC_DCL void NDECL(make_niches); 37. 38. STATIC_PTR int FDECL(do_comp,(const genericptr,const genericptr)); 39. 40. STATIC_DCL void FDECL(dosdoor,(XCHAR_P,XCHAR_P,struct mkroom *,int)); 41. STATIC_DCL void FDECL(join,(int,int,BOOLEAN_P)); 42. STATIC_DCL void FDECL(do_room_or_subroom, (struct mkroom *,int,int,int,int, 43. BOOLEAN_P,SCHAR_P,BOOLEAN_P,BOOLEAN_P)); 44. STATIC_DCL void NDECL(makerooms); 45. STATIC_DCL void FDECL(finddpos,(coord *,XCHAR_P,XCHAR_P,XCHAR_P,XCHAR_P)); 46. STATIC_DCL void FDECL(mkinvpos, (XCHAR_P,XCHAR_P,int)); 47. STATIC_DCL void FDECL(mk_knox_portal, (XCHAR_P,XCHAR_P)); 48. 49. #define create_vault() create_room(-1, -1, 2, 2, -1, -1, VAULT, TRUE) 50. #define init_vault() vault_x = -1 51. #define do_vault() (vault_x != -1) 52. static xchar vault_x, vault_y; 53. boolean goldseen; 54. static boolean made_branch; /* used only during level creation */ 55. 56. /* Args must be (const genericptr) so that qsort will always be happy. */ 57. 58. STATIC_PTR int 59. do_comp(vx,vy) 60. const genericptr vx; 61. const genericptr vy; 62. { 63. #ifdef LINT 64. /* lint complains about possible pointer alignment problems, but we know 65. that vx and vy are always properly aligned. Hence, the following 66. bogus definition: 67. */ 68. return (vx == vy) ? 0 : -1; 69. #else 70. register const struct mkroom *x, *y; 71. 72. x = (const struct mkroom *)vx; 73. y = (const struct mkroom *)vy; 74. if(x->lx < y->lx) return(-1); 75. return(x->lx > y->lx); 76. #endif /* LINT */ 77. } 78. 79. STATIC_OVL void 80. finddpos(cc, xl,yl,xh,yh) 81. coord *cc; 82. xchar xl,yl,xh,yh; 83. { 84. register xchar x, y; 85. 86. x = (xl == xh) ? xl : (xl + rn2(xh-xl+1)); 87. y = (yl == yh) ? yl : (yl + rn2(yh-yl+1)); 88. if(okdoor(x, y)) 89. goto gotit; 90. 91. for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++) 92. if(okdoor(x, y)) 93. goto gotit; 94. 95. for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++) 96. if(IS_DOOR(levl[x][y].typ) || levl[x][y].typ == SDOOR) 97. goto gotit; 98. /* cannot find something reasonable -- strange */ 99. x = xl; 100. y = yh; 101. gotit: 102. cc->x = x; 103. cc->y = y; 104. return; 105. } 106. 107. void 108. sort_rooms() 109. { 110. #if defined(SYSV) || defined(DGUX) 111. qsort((genericptr_t) rooms, (unsigned)nroom, sizeof(struct mkroom), do_comp); 112. #else 113. qsort((genericptr_t) rooms, nroom, sizeof(struct mkroom), do_comp); 114. #endif 115. } 116. 117. STATIC_OVL void 118. do_room_or_subroom(croom, lowx, lowy, hix, hiy, lit, rtype, special, is_room) 119. register struct mkroom *croom; 120. int lowx, lowy; 121. register int hix, hiy; 122. boolean lit; 123. schar rtype; 124. boolean special; 125. boolean is_room; 126. { 127. register int x, y; 128. struct rm *lev; 129. 130. /* locations might bump level edges in wall-less rooms */ 131. /* add/subtract 1 to allow for edge locations */ 132. if(!lowx) lowx++; 133. if(!lowy) lowy++; 134. if(hix >= COLNO-1) hix = COLNO-2; 135. if(hiy >= ROWNO-1) hiy = ROWNO-2; 136. 137. if(lit) { 138. for(x = lowx-1; x <= hix+1; x++) { 139. lev = &levl[x][max(lowy-1,0)]; 140. for(y = lowy-1; y <= hiy+1; y++) 141. lev++->lit = 1; 142. } 143. croom->rlit = 1; 144. } else 145. croom->rlit = 0; 146. 147. croom->lx = lowx; 148. croom->hx = hix; 149. croom->ly = lowy; 150. croom->hy = hiy; 151. croom->rtype = rtype; 152. croom->doorct = 0; 153. /* if we're not making a vault, doorindex will still be 0 154. * if we are, we'll have problems adding niches to the previous room 155. * unless fdoor is at least doorindex 156. */ 157. croom->fdoor = doorindex; 158. croom->irregular = FALSE; 159. 160. croom->nsubrooms = 0; 161. croom->sbrooms[0] = (struct mkroom *) 0; 162. if (!special) { 163. for(x = lowx-1; x <= hix+1; x++) 164. for(y = lowy-1; y <= hiy+1; y += (hiy-lowy+2)) { 165. levl[x][y].typ = HWALL; 166. levl[x][y].horizontal = 1; /* For open/secret doors. */ 167. } 168. for(x = lowx-1; x <= hix+1; x += (hix-lowx+2)) 169. for(y = lowy; y <= hiy; y++) { 170. levl[x][y].typ = VWALL; 171. levl[x][y].horizontal = 0; /* For open/secret doors. */ 172. } 173. for(x = lowx; x <= hix; x++) { 174. lev = &levl[x][lowy]; 175. for(y = lowy; y <= hiy; y++) 176. lev++->typ = ROOM; 177. } 178. if (is_room) { 179. levl[lowx-1][lowy-1].typ = TLCORNER; 180. levl[hix+1][lowy-1].typ = TRCORNER; 181. levl[lowx-1][hiy+1].typ = BLCORNER; 182. levl[hix+1][hiy+1].typ = BRCORNER; 183. } else { /* a subroom */ 184. wallification(lowx-1, lowy-1, hix+1, hiy+1); 185. } 186. } 187. } 188. 189. 190. void 191. add_room(lowx, lowy, hix, hiy, lit, rtype, special) 192. register int lowx, lowy, hix, hiy; 193. boolean lit; 194. schar rtype; 195. boolean special; 196. { 197. register struct mkroom *croom; 198. 199. croom = &rooms[nroom]; 200. do_room_or_subroom(croom, lowx, lowy, hix, hiy, lit, 201. rtype, special, (boolean) TRUE); 202. croom++; 203. croom->hx = -1; 204. nroom++; 205. } 206. 207. void 208. add_subroom(proom, lowx, lowy, hix, hiy, lit, rtype, special) 209. struct mkroom *proom; 210. register int lowx, lowy, hix, hiy; 211. boolean lit; 212. schar rtype; 213. boolean special; 214. { 215. register struct mkroom *croom; 216. 217. croom = &subrooms[nsubroom]; 218. do_room_or_subroom(croom, lowx, lowy, hix, hiy, lit, 219. rtype, special, (boolean) FALSE); 220. proom->sbrooms[proom->nsubrooms++] = croom; 221. croom++; 222. croom->hx = -1; 223. nsubroom++; 224. } 225. 226. STATIC_OVL void 227. makerooms() 228. { 229. boolean tried_vault = FALSE; 230. 231. /* make rooms until satisfied */ 232. /* rnd_rect() will returns 0 if no more rects are available... */ 233. while(nroom < MAXNROFROOMS && rnd_rect()) { 234. if(nroom >= (MAXNROFROOMS/6) && rn2(2) && !tried_vault) { 235. tried_vault = TRUE; 236. if (create_vault()) { 237. vault_x = rooms[nroom].lx; 238. vault_y = rooms[nroom].ly; 239. rooms[nroom].hx = -1; 240. } 241. } else 242. if (!create_room(-1, -1, -1, -1, -1, -1, OROOM, -1)) 243. return; 244. } 245. return; 246. } 247. 248. STATIC_OVL void 249. join(a,b,nxcor) 250. register int a, b; 251. boolean nxcor; 252. { 253. coord cc,tt, org, dest; 254. register xchar tx, ty, xx, yy; 255. register struct mkroom *croom, *troom; 256. register int dx, dy; 257. 258. croom = &rooms[a]; 259. troom = &rooms[b]; 260. 261. /* find positions cc and tt for doors in croom and troom 262. and direction for a corridor between them */ 263. 264. if(troom->hx < 0 || croom->hx < 0 || doorindex >= DOORMAX) return; 265. if(troom->lx > croom->hx) { 266. dx = 1; 267. dy = 0; 268. xx = croom->hx+1; 269. tx = troom->lx-1; 270. finddpos(&cc, xx, croom->ly, xx, croom->hy); 271. finddpos(&tt, tx, troom->ly, tx, troom->hy); 272. } else if(troom->hy < croom->ly) { 273. dy = -1; 274. dx = 0; 275. yy = croom->ly-1; 276. finddpos(&cc, croom->lx, yy, croom->hx, yy); 277. ty = troom->hy+1; 278. finddpos(&tt, troom->lx, ty, troom->hx, ty); 279. } else if(troom->hx < croom->lx) { 280. dx = -1; 281. dy = 0; 282. xx = croom->lx-1; 283. tx = troom->hx+1; 284. finddpos(&cc, xx, croom->ly, xx, croom->hy); 285. finddpos(&tt, tx, troom->ly, tx, troom->hy); 286. } else { 287. dy = 1; 288. dx = 0; 289. yy = croom->hy+1; 290. ty = troom->ly-1; 291. finddpos(&cc, croom->lx, yy, croom->hx, yy); 292. finddpos(&tt, troom->lx, ty, troom->hx, ty); 293. } 294. xx = cc.x; 295. yy = cc.y; 296. tx = tt.x - dx; 297. ty = tt.y - dy; 298. if(nxcor && levl[xx+dx][yy+dy].typ) 299. return; 300. if (okdoor(xx,yy) || !nxcor) 301. dodoor(xx,yy,croom); 302. 303. org.x = xx+dx; org.y = yy+dy; 304. dest.x = tx; dest.y = ty; 305. 306. if (!dig_corridor(&org, &dest, nxcor, 307. level.flags.arboreal ? ROOM : CORR, STONE)) 308. return; 309. 310. /* we succeeded in digging the corridor */ 311. if (okdoor(tt.x, tt.y) || !nxcor) 312. dodoor(tt.x, tt.y, troom); 313. 314. if(smeq[a] < smeq[b]) 315. smeq[b] = smeq[a]; 316. else 317. smeq[a] = smeq[b]; 318. } 319. 320. void 321. makecorridors() 322. { 323. int a, b, i; 324. boolean any = TRUE; 325. 326. for(a = 0; a < nroom-1; a++) { 327. join(a, a+1, FALSE); 328. if(!rn2(50)) break; /* allow some randomness */ 329. } 330. for(a = 0; a < nroom-2; a++) 331. if(smeq[a] != smeq[a+2]) 332. join(a, a+2, FALSE); 333. for(a = 0; any && a < nroom; a++) { 334. any = FALSE; 335. for(b = 0; b < nroom; b++) 336. if(smeq[a] != smeq[b]) { 337. join(a, b, FALSE); 338. any = TRUE; 339. } 340. } 341. if(nroom > 2) 342. for(i = rn2(nroom) + 4; i; i--) { 343. a = rn2(nroom); 344. b = rn2(nroom-2); 345. if(b >= a) b += 2; 346. join(a, b, TRUE); 347. } 348. } 349. 350. void 351. add_door(x,y,aroom) 352. register int x, y; 353. register struct mkroom *aroom; 354. { 355. register struct mkroom *broom; 356. register int tmp; 357. 358. aroom->doorct++; 359. broom = aroom+1; 360. if(broom->hx < 0) 361. tmp = doorindex; 362. else 363. for(tmp = doorindex; tmp > broom->fdoor; tmp--) 364. doors[tmp] = doors[tmp-1]; 365. doorindex++; 366. doors[tmp].x = x; 367. doors[tmp].y = y; 368. for( ; broom->hx >= 0; broom++) broom->fdoor++; 369. } 370. 371. STATIC_OVL void 372. dosdoor(x,y,aroom,type) 373. register xchar x, y; 374. register struct mkroom *aroom; 375. register int type; 376. { 377. boolean shdoor = ((*in_rooms(x, y, SHOPBASE))? TRUE : FALSE); 378. 379. if(!IS_WALL(levl[x][y].typ)) /* avoid SDOORs on already made doors */ 380. type = DOOR; 381. levl[x][y].typ = type; 382. if(type == DOOR) { 383. if(!rn2(3)) { /* is it a locked door, closed, or a doorway? */ 384. if(!rn2(5)) 385. levl[x][y].doormask = D_ISOPEN; 386. else if(!rn2(6)) 387. levl[x][y].doormask = D_LOCKED; 388. else 389. levl[x][y].doormask = D_CLOSED; 390. 391. if (levl[x][y].doormask != D_ISOPEN && !shdoor && 392. level_difficulty() >= 5 && !rn2(25)) 393. levl[x][y].doormask |= D_TRAPPED; 394. } else 395. #ifdef STUPID 396. if (shdoor) 397. levl[x][y].doormask = D_ISOPEN; 398. else 399. levl[x][y].doormask = D_NODOOR; 400. #else 401. levl[x][y].doormask = (shdoor ? D_ISOPEN : D_NODOOR); 402. #endif 403. if(levl[x][y].doormask & D_TRAPPED) { 404. struct monst *mtmp; 405. 406. if (level_difficulty() >= 9 && !rn2(5) && 407. !((mvitals[PM_SMALL_MIMIC].mvflags & G_GONE) && 408. (mvitals[PM_LARGE_MIMIC].mvflags & G_GONE) && 409. (mvitals[PM_GIANT_MIMIC].mvflags & G_GONE))) { 410. /* make a mimic instead */ 411. levl[x][y].doormask = D_NODOOR; 412. mtmp = makemon(mkclass(S_MIMIC,0), x, y, NO_MM_FLAGS); 413. if (mtmp) 414. set_mimic_sym(mtmp); 415. } 416. } 417. /* newsym(x,y); */ 418. } else { /* SDOOR */ 419. if(shdoor || !rn2(5)) levl[x][y].doormask = D_LOCKED; 420. else levl[x][y].doormask = D_CLOSED; 421. 422. if(!shdoor && level_difficulty() >= 4 && !rn2(20)) 423. levl[x][y].doormask |= D_TRAPPED; 424. } 425. 426. add_door(x,y,aroom); 427. } 428. 429. STATIC_OVL boolean 430. place_niche(aroom,dy,xx,yy) 431. register struct mkroom *aroom; 432. int *dy, *xx, *yy; 433. { 434. coord dd; 435. 436. if(rn2(2)) { 437. *dy = 1; 438. finddpos(&dd, aroom->lx, aroom->hy+1, aroom->hx, aroom->hy+1); 439. } else { 440. *dy = -1; 441. finddpos(&dd, aroom->lx, aroom->ly-1, aroom->hx, aroom->ly-1); 442. } 443. *xx = dd.x; 444. *yy = dd.y; 445. return((boolean)((isok(*xx,*yy+*dy) && levl[*xx][*yy+*dy].typ == STONE) 446. && (isok(*xx,*yy-*dy) && !IS_POOL(levl[*xx][*yy-*dy].typ) 447. && !IS_FURNITURE(levl[*xx][*yy-*dy].typ)))); 448. } 449. 450. /* there should be one of these per trap, in the same order as trap.h */ 451. static NEARDATA const char *trap_engravings[TRAPNUM] = { 452. (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 453. (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 454. (char *)0, (char *)0, (char *)0, (char *)0, 455. /* 14..16: trap door, teleport, level-teleport */ 456. "Vlad was here", "ad aerarium", "ad aerarium", 457. (char *)0, (char *)0, (char *)0, (char *)0, (char *)0, 458. (char *)0, 459. }; 460. 461. STATIC_OVL void 462. makeniche(trap_type) 463. int trap_type; 464. { 465. register struct mkroom *aroom; 466. register struct rm *rm; 467. register int vct = 8; 468. int dy, xx, yy; 469. register struct trap *ttmp; 470. 471. if(doorindex < DOORMAX) 472. while(vct--) { 473. aroom = &rooms[rn2(nroom)]; 474. if(aroom->rtype != OROOM) continue; /* not an ordinary room */ 475. if(aroom->doorct == 1 && rn2(5)) continue; 476. if(!place_niche(aroom,&dy,&xx,&yy)) continue; 477. 478. rm = &levl[xx][yy+dy]; 479. if(trap_type || !rn2(4)) { 480. 481. rm->typ = SCORR; 482. if(trap_type) { 483. if((trap_type == HOLE || trap_type == TRAPDOOR) 484. && !Can_fall_thru(&u.uz)) 485. trap_type = ROCKTRAP; 486. ttmp = maketrap(xx, yy+dy, trap_type); 487. if (ttmp) { 488. ttmp->once = 1; 489. if (trap_engravings[trap_type]) { 490. make_engr_at(xx, yy-dy, 491. trap_engravings[trap_type], 0L, DUST); 492. wipe_engr_at(xx, yy-dy, 5); /* age it a little */ 493. } 494. } 495. } 496. dosdoor(xx, yy, aroom, SDOOR); 497. } else { 498. rm->typ = CORR; 499. if(rn2(7)) 500. dosdoor(xx, yy, aroom, rn2(5) ? SDOOR : DOOR); 501. else { 502. if (!level.flags.noteleport) 503. (void) mksobj_at(SCR_TELEPORTATION, 504. xx, yy+dy, TRUE, FALSE); 505. if (!rn2(3)) (void) mkobj_at(0, xx, yy+dy, TRUE); 506. } 507. } 508. return; 509. } 510. } 511. 512. STATIC_OVL void 513. make_niches() 514. { 515. register int ct = rnd((nroom>>1) + 1), dep = depth(&u.uz); 516. 517. boolean ltptr = (!level.flags.noteleport && dep > 15), 518. vamp = (dep > 5 && dep < 25); 519. 520. while(ct--) { 521. if (ltptr && !rn2(6)) { 522. ltptr = FALSE; 523. makeniche(LEVEL_TELEP); 524. } else if (vamp && !rn2(6)) { 525. vamp = FALSE; 526. makeniche(TRAPDOOR); 527. } else makeniche(NO_TRAP); 528. } 529. } 530. 531. STATIC_OVL void 532. makevtele() 533. { 534. makeniche(TELEP_TRAP); 535. } 536. 537. /* clear out various globals that keep information on the current level. 538. * some of this is only necessary for some types of levels (maze, normal, 539. * special) but it's easier to put it all in one place than make sure 540. * each type initializes what it needs to separately. 541. */ 542. STATIC_OVL void 543. clear_level_structures() 544. { 545. static struct rm zerorm = { cmap_to_glyph(S_stone), 546. 0, 0, 0, 0, 0, 0, 0, 0 }; 547. register int x,y; 548. register struct rm *lev; 549. 550. for(x=0; x<COLNO; x++) { 551. lev = &levl[x][0]; 552. for(y=0; y<ROWNO; y++) { 553. *lev++ = zerorm; 554. #ifdef MICROPORT_BUG 555. level.objects[x][y] = (struct obj *)0; 556. level.monsters[x][y] = (struct monst *)0; 557. #endif 558. } 559. } 560. #ifndef MICROPORT_BUG 561. (void) memset((genericptr_t)level.objects, 0, sizeof(level.objects)); 562. (void) memset((genericptr_t)level.monsters, 0, sizeof(level.monsters)); 563. #endif 564. level.objlist = (struct obj *)0; 565. level.buriedobjlist = (struct obj *)0; 566. level.monlist = (struct monst *)0; 567. level.damagelist = (struct damage *)0; 568. 569. level.flags.nfountains = 0; 570. level.flags.nsinks = 0; 571. level.flags.has_shop = 0; 572. level.flags.has_vault = 0; 573. level.flags.has_zoo = 0; 574. level.flags.has_court = 0; 575. level.flags.has_morgue = level.flags.graveyard = 0; 576. level.flags.has_beehive = 0; 577. level.flags.has_barracks = 0; 578. level.flags.has_temple = 0; 579. level.flags.has_swamp = 0; 580. level.flags.noteleport = 0; 581. level.flags.hardfloor = 0; 582. level.flags.nommap = 0; 583. level.flags.hero_memory = 1; 584. level.flags.shortsighted = 0; 585. level.flags.arboreal = 0; 586. level.flags.is_maze_lev = 0; 587. level.flags.is_cavernous_lev = 0; 588. 589. nroom = 0; 590. rooms[0].hx = -1; 591. nsubroom = 0; 592. subrooms[0].hx = -1; 593. doorindex = 0; 594. init_rect(); 595. init_vault(); 596. xdnstair = ydnstair = xupstair = yupstair = 0; 597. sstairs.sx = sstairs.sy = 0; 598. xdnladder = ydnladder = xupladder = yupladder = 0; 599. made_branch = FALSE; 600. clear_regions(); 601. } 602. 603. STATIC_OVL void 604. makelevel() 605. { 606. register struct mkroom *croom, *troom; 607. register int tryct; 608. register int x, y; 609. struct monst *tmonst; /* always put a web with a spider */ 610. branch *branchp; 611. int room_threshold; 612. 613. if(wiz1_level.dlevel == 0) init_dungeons(); 614. oinit(); /* assign level dependent obj probabilities */ 615. clear_level_structures(); 616. 617. { 618. register s_level *slev = Is_special(&u.uz); 619. 620. /* check for special levels */ 621. #ifdef REINCARNATION 622. if (slev && !Is_rogue_level(&u.uz)) 623. #else 624. if (slev) 625. #endif 626. { 627. makemaz(slev->proto); 628. return; 629. } else if (dungeons[u.uz.dnum].proto[0]) { 630. makemaz(""); 631. return; 632. } else if (In_mines(&u.uz)) { 633. makemaz("minefill"); 634. return; 635. } else if (In_quest(&u.uz)) { 636. char fillname[9]; 637. s_level *loc_lev; 638. 639. Sprintf(fillname, "%s-loca", urole.filecode); 640. loc_lev = find_level(fillname); 641. 642. Sprintf(fillname, "%s-fil", urole.filecode); 643. Strcat(fillname, 644. (u.uz.dlevel < loc_lev->dlevel.dlevel) ? "a" : "b"); 645. makemaz(fillname); 646. return; 647. } else if(In_hell(&u.uz) || 648. (rn2(5) && u.uz.dnum == medusa_level.dnum 649. && depth(&u.uz) > depth(&medusa_level))) { 650. makemaz(""); 651. return; 652. } 653. } 654. 655. /* otherwise, fall through - it's a "regular" level. */ 656. 657. #ifdef REINCARNATION 658. if (Is_rogue_level(&u.uz)) { 659. makeroguerooms(); 660. makerogueghost(); 661. } else 662. #endif 663. makerooms(); 664. sort_rooms(); 665. 666. /* construct stairs (up and down in different rooms if possible) */ 667. croom = &rooms[rn2(nroom)]; 668. if (!Is_botlevel(&u.uz)) 669. mkstairs(somex(croom), somey(croom), 0, croom); /* down */ 670. if (nroom > 1) { 671. troom = croom; 672. croom = &rooms[rn2(nroom-1)]; 673. if (croom == troom) croom++; 674. } 675. 676. if (u.uz.dlevel != 1) { 677. xchar sx, sy; 678. do { 679. sx = somex(croom); 680. sy = somey(croom); 681. } while(occupied(sx, sy)); 682. mkstairs(sx, sy, 1, croom); /* up */ 683. } 684. 685. branchp = Is_branchlev(&u.uz); /* possible dungeon branch */ 686. room_threshold = branchp ? 4 : 3; /* minimum number of rooms needed 687. to allow a random special room */ 688. #ifdef REINCARNATION 689. if (Is_rogue_level(&u.uz)) goto skip0; 690. #endif 691. makecorridors(); 692. make_niches(); 693. 694. /* make a secret treasure vault, not connected to the rest */ 695. if(do_vault()) { 696. xchar w,h; 697. #ifdef DEBUG 698. debugpline("trying to make a vault..."); 699. #endif 700. w = 1; 701. h = 1; 702. if (check_room(&vault_x, &w, &vault_y, &h, TRUE)) { 703. fill_vault: 704. add_room(vault_x, vault_y, vault_x+w, 705. vault_y+h, TRUE, VAULT, FALSE); 706. level.flags.has_vault = 1; 707. ++room_threshold; 708. fill_room(&rooms[nroom - 1], FALSE); 709. mk_knox_portal(vault_x+w, vault_y+h); 710. if(!level.flags.noteleport && !rn2(3)) makevtele(); 711. } else if(rnd_rect() && create_vault()) { 712. vault_x = rooms[nroom].lx; 713. vault_y = rooms[nroom].ly; 714. if (check_room(&vault_x, &w, &vault_y, &h, TRUE)) 715. goto fill_vault; 716. else 717. rooms[nroom].hx = -1; 718. } 719. } 720. 721. { 722. register int u_depth = depth(&u.uz); 723. 724. #ifdef WIZARD 725. if(wizard && nh_getenv("SHOPTYPE")) mkroom(SHOPBASE); else 726. #endif 727. if (u_depth > 1 && 728. u_depth < depth(&medusa_level) && 729. nroom >= room_threshold && 730. rn2(u_depth) < 3) mkroom(SHOPBASE); 731. else if (u_depth > 4 && !rn2(6)) mkroom(COURT); 732. else if (u_depth > 5 && !rn2(8) && 733. !(mvitals[PM_LEPRECHAUN].mvflags & G_GONE)) mkroom(LEPREHALL); 734. else if (u_depth > 6 && !rn2(7)) mkroom(ZOO); 735. else if (u_depth > 8 && !rn2(5)) mkroom(TEMPLE); 736. else if (u_depth > 9 && !rn2(5) && 737. !(mvitals[PM_KILLER_BEE].mvflags & G_GONE)) mkroom(BEEHIVE); 738. else if (u_depth > 11 && !rn2(6)) mkroom(MORGUE); 739. else if (u_depth > 12 && !rn2(8)) mkroom(ANTHOLE); 740. else if (u_depth > 14 && !rn2(4) && 741. !(mvitals[PM_SOLDIER].mvflags & G_GONE)) mkroom(BARRACKS); 742. else if (u_depth > 15 && !rn2(6)) mkroom(SWAMP); 743. else if (u_depth > 16 && !rn2(8) && 744. !(mvitals[PM_COCKATRICE].mvflags & G_GONE)) mkroom(COCKNEST); 745. } 746. 747. #ifdef REINCARNATION 748. skip0: 749. #endif 750. /* Place multi-dungeon branch. */ 751. place_branch(branchp, 0, 0); 752. 753. /* for each room: put things inside */ 754. for(croom = rooms; croom->hx > 0; croom++) { 755. if(croom->rtype != OROOM) continue; 756. 757. /* put a sleeping monster inside */ 758. /* Note: monster may be on the stairs. This cannot be 759. avoided: maybe the player fell through a trap door 760. while a monster was on the stairs. Conclusion: 761. we have to check for monsters on the stairs anyway. */ 762. 763. if(u.uhave.amulet || !rn2(3)) { 764. x = somex(croom); y = somey(croom); 765. tmonst = makemon((struct permonst *) 0, x,y,NO_MM_FLAGS); 766. if (tmonst && tmonst->data == &mons[PM_GIANT_SPIDER] && 767. !occupied(x, y)) 768. (void) maketrap(x, y, WEB); 769. } 770. /* put traps and mimics inside */ 771. goldseen = FALSE; 772. x = 8 - (level_difficulty()/6); 773. if (x <= 1) x = 2; 774. while (!rn2(x)) 775. mktrap(0,0,croom,(coord*)0); 776. if (!goldseen && !rn2(3)) 777. (void) mkgold(0L, somex(croom), somey(croom)); 778. #ifdef REINCARNATION 779. if(Is_rogue_level(&u.uz)) goto skip_nonrogue; 780. #endif 781. if(!rn2(10)) mkfount(0,croom); 782. #ifdef SINKS 783. if(!rn2(60)) mksink(croom); 784. #endif 785. if(!rn2(60)) mkaltar(croom); 786. x = 80 - (depth(&u.uz) * 2); 787. if (x < 2) x = 2; 788. if(!rn2(x)) mkgrave(croom); 789. 790. /* put statues inside */ 791. if(!rn2(20)) 792. (void) mkcorpstat(STATUE, (struct monst *)0, 793. (struct permonst *)0, 794. somex(croom), somey(croom), TRUE); 795. /* put box/chest inside; 796. * 40% chance for at least 1 box, regardless of number 797. * of rooms; about 5 - 7.5% for 2 boxes, least likely 798. * when few rooms; chance for 3 or more is neglible. 799. */ 800. if(!rn2(nroom * 5 / 2)) 801. (void) mksobj_at((rn2(3)) ? LARGE_BOX : CHEST, 802. somex(croom), somey(croom), TRUE, FALSE); 803. 804. /* maybe make some graffiti */ 805. if(!rn2(27 + 3 * abs(depth(&u.uz)))) { 806. char buf[BUFSZ]; 807. const char *mesg = random_engraving(buf); 808. if (mesg) { 809. do { 810. x = somex(croom); y = somey(croom); 811. } while(levl[x][y].typ != ROOM && !rn2(40)); 812. if (!(IS_POOL(levl[x][y].typ) || 813. IS_FURNITURE(levl[x][y].typ))) 814. make_engr_at(x, y, mesg, 0L, MARK); 815. } 816. } 817. 818. #ifdef REINCARNATION 819. skip_nonrogue: 820. #endif 821. if(!rn2(3)) { 822. (void) mkobj_at(0, somex(croom), somey(croom), TRUE); 823. tryct = 0; 824. while(!rn2(5)) { 825. if(++tryct > 100) { 826. impossible("tryct overflow4"); 827. break; 828. } 829. (void) mkobj_at(0, somex(croom), somey(croom), TRUE); 830. } 831. } 832. } 833. } 834. 835. /* 836. * Place deposits of minerals (gold and misc gems) in the stone 837. * surrounding the rooms on the map. 838. * Also place kelp in water. 839. */ 840. STATIC_OVL void 841. mineralize() 842. { 843. s_level *sp; 844. struct obj *otmp; 845. int goldprob, gemprob, x, y, cnt; 846. 847. 848. /* Place kelp, except on the plane of water */ 849. if (In_endgame(&u.uz)) return; 850. for (x = 2; x < (COLNO - 2); x++) 851. for (y = 1; y < (ROWNO - 1); y++) 852. if ((levl[x][y].typ == POOL && !rn2(10)) || 853. (levl[x][y].typ == MOAT && !rn2(30))) 854. (void) mksobj_at(KELP_FROND, x, y, TRUE, FALSE); 855. 856. /* determine if it is even allowed; 857. almost all special levels are excluded */ 858. if (In_hell(&u.uz) || In_V_tower(&u.uz) || 859. #ifdef REINCARNATION 860. Is_rogue_level(&u.uz) || 861. #endif 862. level.flags.arboreal || 863. ((sp = Is_special(&u.uz)) != 0 && !Is_oracle_level(&u.uz) 864. && (!In_mines(&u.uz) || sp->flags.town) 865. )) return; 866. 867. /* basic level-related probabilities */ 868. goldprob = 20 + depth(&u.uz) / 3; 869. gemprob = goldprob / 4; 870. 871. /* mines have ***MORE*** goodies - otherwise why mine? */ 872. if (In_mines(&u.uz)) { 873. goldprob *= 2; 874. gemprob *= 3; 875. } else if (In_quest(&u.uz)) { 876. goldprob /= 4; 877. gemprob /= 6; 878. } 879. 880. /* 881. * Seed rock areas with gold and/or gems. 882. * We use fairly low level object handling to avoid unnecessary 883. * overhead from placing things in the floor chain prior to burial. 884. */ 885. for (x = 2; x < (COLNO - 2); x++) 886. for (y = 1; y < (ROWNO - 1); y++) 887. if (levl[x][y+1].typ != STONE) { /* <x,y> spot not eligible */ 888. y += 2; /* next two spots aren't eligible either */ 889. } else if (levl[x][y].typ != STONE) { /* this spot not eligible */ 890. y += 1; /* next spot isn't eligible either */ 891. } else if (!(levl[x][y].wall_info & W_NONDIGGABLE) && 892. levl[x][y-1].typ == STONE && 893. levl[x+1][y-1].typ == STONE && levl[x-1][y-1].typ == STONE && 894. levl[x+1][y].typ == STONE && levl[x-1][y].typ == STONE && 895. levl[x+1][y+1].typ == STONE && levl[x-1][y+1].typ == STONE) { 896. if (rn2(1000) < goldprob) { 897. if ((otmp = mksobj(GOLD_PIECE, FALSE, FALSE)) != 0) { 898. otmp->ox = x, otmp->oy = y; 899. otmp->quan = 1L + rnd(goldprob * 3); 900. otmp->owt = weight(otmp); 901. if (!rn2(3)) add_to_buried(otmp); 902. else place_object(otmp, x, y); 903. } 904. } 905. if (rn2(1000) < gemprob) { 906. for (cnt = rnd(2 + dunlev(&u.uz) / 3); cnt > 0; cnt--) 907. if ((otmp = mkobj(GEM_CLASS, FALSE)) != 0) { 908. if (otmp->otyp == ROCK) { 909. dealloc_obj(otmp); /* discard it */ 910. } else { 911. otmp->ox = x, otmp->oy = y; 912. if (!rn2(3)) add_to_buried(otmp); 913. else place_object(otmp, x, y); 914. } 915. } 916. } 917. } 918. } 919. 920. void 921. mklev() 922. { 923. struct mkroom *croom; 924. 925. if(getbones()) return; 926. in_mklev = TRUE; 927. makelevel(); 928. bound_digging(); 929. mineralize(); 930. in_mklev = FALSE; 931. /* has_morgue gets cleared once morgue is entered; graveyard stays 932. set (graveyard might already be set even when has_morgue is clear 933. [see fixup_special()], so don't update it unconditionally) */ 934. if (level.flags.has_morgue) 935. level.flags.graveyard = 1; 936. if (!level.flags.is_maze_lev) { 937. for (croom = &rooms[0]; croom != &rooms[nroom]; croom++) 938. #ifdef SPECIALIZATION 939. topologize(croom, FALSE); 940. #else 941. topologize(croom); 942. #endif 943. } 944. set_wall_state(); 945. } 946. 947. void 948. #ifdef SPECIALIZATION 949. topologize(croom, do_ordinary) 950. register struct mkroom *croom; 951. boolean do_ordinary; 952. #else 953. topologize(croom) 954. register struct mkroom *croom; 955. #endif 956. { 957. register int x, y, roomno = (croom - rooms) + ROOMOFFSET; 958. register int lowx = croom->lx, lowy = croom->ly; 959. register int hix = croom->hx, hiy = croom->hy; 960. #ifdef SPECIALIZATION 961. register schar rtype = croom->rtype; 962. #endif 963. register int subindex, nsubrooms = croom->nsubrooms; 964. 965. /* skip the room if already done; i.e. a shop handled out of order */ 966. /* also skip if this is non-rectangular (it _must_ be done already) */ 967. if ((int) levl[lowx][lowy].roomno == roomno || croom->irregular) 968. return; 969. #ifdef SPECIALIZATION 970. # ifdef REINCARNATION 971. if (Is_rogue_level(&u.uz)) 972. do_ordinary = TRUE; /* vision routine helper */ 973. # endif 974. if ((rtype != OROOM) || do_ordinary) 975. #endif 976. { 977. /* do innards first */ 978. for(x = lowx; x <= hix; x++) 979. for(y = lowy; y <= hiy; y++) 980. #ifdef SPECIALIZATION 981. if (rtype == OROOM) 982. levl[x][y].roomno = NO_ROOM; 983. else 984. #endif 985. levl[x][y].roomno = roomno; 986. /* top and bottom edges */ 987. for(x = lowx-1; x <= hix+1; x++) 988. for(y = lowy-1; y <= hiy+1; y += (hiy-lowy+2)) { 989. levl[x][y].edge = 1; 990. if (levl[x][y].roomno) 991. levl[x][y].roomno = SHARED; 992. else 993. levl[x][y].roomno = roomno; 994. } 995. /* sides */ 996. for(x = lowx-1; x <= hix+1; x += (hix-lowx+2)) 997. for(y = lowy; y <= hiy; y++) { 998. levl[x][y].edge = 1; 999. if (levl[x][y].roomno) 1000. levl[x][y].roomno = SHARED; 1001. else 1002. levl[x][y].roomno = roomno; 1003. } 1004. } 1005. /* subrooms */ 1006. for (subindex = 0; subindex < nsubrooms; subindex++) 1007. #ifdef SPECIALIZATION 1008. topologize(croom->sbrooms[subindex], (rtype != OROOM)); 1009. #else 1010. topologize(croom->sbrooms[subindex]); 1011. #endif 1012. } 1013. 1014. /* Find an unused room for a branch location. */ 1015. STATIC_OVL struct mkroom * 1016. find_branch_room(mp) 1017. coord *mp; 1018. { 1019. struct mkroom *croom = 0; 1020. 1021. if (nroom == 0) { 1022. mazexy(mp); /* already verifies location */ 1023. } else { 1024. /* not perfect - there may be only one stairway */ 1025. if(nroom > 2) { 1026. int tryct = 0; 1027. 1028. do 1029. croom = &rooms[rn2(nroom)]; 1030. while((croom == dnstairs_room || croom == upstairs_room || 1031. croom->rtype != OROOM) && (++tryct < 100)); 1032. } else 1033. croom = &rooms[rn2(nroom)]; 1034. 1035. do { 1036. if (!somexy(croom, mp)) 1037. impossible("Can't place branch!"); 1038. } while(occupied(mp->x, mp->y) || 1039. (levl[mp->x][mp->y].typ != CORR && levl[mp->x][mp->y].typ != ROOM)); 1040. } 1041. return croom; 1042. } 1043. 1044. /* Find the room for (x,y). Return null if not in a room. */ 1045. STATIC_OVL struct mkroom * 1046. pos_to_room(x, y) 1047. xchar x, y; 1048. { 1049. int i; 1050. struct mkroom *curr; 1051. 1052. for (curr = rooms, i = 0; i < nroom; curr++, i++) 1053. if (inside_room(curr, x, y)) return curr;; 1054. return (struct mkroom *) 0; 1055. } 1056. 1057. 1058. /* If given a branch, randomly place a special stair or portal. */ 1059. void 1060. place_branch(br, x, y) 1061. branch *br; /* branch to place */ 1062. xchar x, y; /* location */ 1063. { 1064. coord m; 1065. d_level *dest; 1066. boolean make_stairs; 1067. struct mkroom *br_room; 1068. 1069. /* 1070. * Return immediately if there is no branch to make or we have 1071. * already made one. This routine can be called twice when 1072. * a special level is loaded that specifies an SSTAIR location 1073. * as a favored spot for a branch. 1074. */ 1075. if (!br || made_branch) return; 1076. 1077. if (!x) { /* find random coordinates for branch */ 1078. br_room = find_branch_room(&m); 1079. x = m.x; 1080. y = m.y; 1081. } else { 1082. br_room = pos_to_room(x, y); 1083. } 1084. 1085. if (on_level(&br->end1, &u.uz)) { 1086. /* we're on end1 */ 1087. make_stairs = br->type != BR_NO_END1; 1088. dest = &br->end2; 1089. } else { 1090. /* we're on end2 */ 1091. make_stairs = br->type != BR_NO_END2; 1092. dest = &br->end1; 1093. } 1094. 1095. if (br->type == BR_PORTAL) { 1096. mkportal(x, y, dest->dnum, dest->dlevel); 1097. } else if (make_stairs) { 1098. sstairs.sx = x; 1099. sstairs.sy = y; 1100. sstairs.up = (char) on_level(&br->end1, &u.uz) ? 1101. br->end1_up : !br->end1_up; 1102. assign_level(&sstairs.tolev, dest); 1103. sstairs_room = br_room; 1104. 1105. levl[x][y].ladder = sstairs.up ? LA_UP : LA_DOWN; 1106. levl[x][y].typ = STAIRS; 1107. } 1108. /* 1109. * Set made_branch to TRUE even if we didn't make a stairwell (i.e. 1110. * make_stairs is false) since there is currently only one branch 1111. * per level, if we failed once, we're going to fail again on the 1112. * next call. 1113. */ 1114. made_branch = TRUE; 1115. } 1116. 1117. STATIC_OVL boolean 1118. bydoor(x, y) 1119. register xchar x, y; 1120. { 1121. register int typ; 1122. 1123. if (isok(x+1, y)) { 1124. typ = levl[x+1][y].typ; 1125. if (IS_DOOR(typ) || typ == SDOOR) return TRUE; 1126. } 1127. if (isok(x-1, y)) { 1128. typ = levl[x-1][y].typ; 1129. if (IS_DOOR(typ) || typ == SDOOR) return TRUE; 1130. } 1131. if (isok(x, y+1)) { 1132. typ = levl[x][y+1].typ; 1133. if (IS_DOOR(typ) || typ == SDOOR) return TRUE; 1134. } 1135. if (isok(x, y-1)) { 1136. typ = levl[x][y-1].typ; 1137. if (IS_DOOR(typ) || typ == SDOOR) return TRUE; 1138. } 1139. return FALSE; 1140. } 1141. 1142. /* see whether it is allowable to create a door at [x,y] */ 1143. int 1144. okdoor(x,y) 1145. register xchar x, y; 1146. { 1147. register boolean near_door = bydoor(x, y); 1148. 1149. return((levl[x][y].typ == HWALL || levl[x][y].typ == VWALL) && 1150. doorindex < DOORMAX && !near_door); 1151. } 1152. 1153. void 1154. dodoor(x,y,aroom) 1155. register int x, y; 1156. register struct mkroom *aroom; 1157. { 1158. if(doorindex >= DOORMAX) { 1159. impossible("DOORMAX exceeded?"); 1160. return; 1161. } 1162. 1163. dosdoor(x,y,aroom,rn2(8) ? DOOR : SDOOR); 1164. } 1165. 1166. boolean 1167. occupied(x, y) 1168. register xchar x, y; 1169. { 1170. return((boolean)(t_at(x, y) 1171. || IS_FURNITURE(levl[x][y].typ) 1172. || is_lava(x,y) 1173. || is_pool(x,y) 1174. || invocation_pos(x,y) 1175. )); 1176. } 1177. 1178. /* make a trap somewhere (in croom if mazeflag = 0 && !tm) */ 1179. /* if tm != null, make trap at that location */ 1180. void 1181. mktrap(num, mazeflag, croom, tm) 1182. register int num, mazeflag; 1183. register struct mkroom *croom; 1184. coord *tm; 1185. { 1186. register int kind; 1187. coord m; 1188. 1189. /* no traps in pools */ 1190. if (tm && is_pool(tm->x,tm->y)) return; 1191. 1192. if (num > 0 && num < TRAPNUM) { 1193. kind = num; 1194. #ifdef REINCARNATION 1195. } else if (Is_rogue_level(&u.uz)) { 1196. switch (rn2(7)) { 1197. default: kind = BEAR_TRAP; break; /* 0 */ 1198. case 1: kind = ARROW_TRAP; break; 1199. case 2: kind = DART_TRAP; break; 1200. case 3: kind = TRAPDOOR; break; 1201. case 4: kind = PIT; break; 1202. case 5: kind = SLP_GAS_TRAP; break; 1203. case 6: kind = RUST_TRAP; break; 1204. } 1205. #endif 1206. } else if (Inhell && !rn2(5)) { 1207. /* bias the frequency of fire traps in Gehennom */ 1208. kind = FIRE_TRAP; 1209. } else { 1210. unsigned lvl = level_difficulty(); 1211. 1212. do { 1213. kind = rnd(TRAPNUM-1); 1214. /* reject "too hard" traps */ 1215. switch (kind) { 1216. case MAGIC_PORTAL: 1217. kind = NO_TRAP; break; 1218. case ROLLING_BOULDER_TRAP: 1219. case SLP_GAS_TRAP: 1220. if (lvl < 2) kind = NO_TRAP; break; 1221. case LEVEL_TELEP: 1222. if (lvl < 5 || level.flags.noteleport) 1223. kind = NO_TRAP; break; 1224. case SPIKED_PIT: 1225. if (lvl < 5) kind = NO_TRAP; break; 1226. case LANDMINE: 1227. if (lvl < 6) kind = NO_TRAP; break; 1228. case WEB: 1229. if (lvl < 7) kind = NO_TRAP; break; 1230. case STATUE_TRAP: 1231. case POLY_TRAP: 1232. if (lvl < 8) kind = NO_TRAP; break; 1233. case FIRE_TRAP: 1234. if (!Inhell) kind = NO_TRAP; break; 1235. case TELEP_TRAP: 1236. if (level.flags.noteleport) kind = NO_TRAP; break; 1237. case HOLE: 1238. /* make these much less often than other traps */ 1239. if (rn2(7)) kind = NO_TRAP; break; 1240. } 1241. } while (kind == NO_TRAP); 1242. } 1243. 1244. if ((kind == TRAPDOOR || kind == HOLE) && !Can_fall_thru(&u.uz)) 1245. kind = ROCKTRAP; 1246. 1247. if (tm) 1248. m = *tm; 1249. else { 1250. register int tryct = 0; 1251. boolean avoid_boulder = (kind == PIT || kind == SPIKED_PIT || 1252. kind == TRAPDOOR || kind == HOLE); 1253. 1254. do { 1255. if (++tryct > 200) 1256. return; 1257. if (mazeflag) 1258. mazexy(&m); 1259. else if (!somexy(croom,&m)) 1260. return; 1261. } while (occupied(m.x, m.y) || 1262. (avoid_boulder && sobj_at(BOULDER, m.x, m.y))); 1263. } 1264. 1265. (void) maketrap(m.x, m.y, kind); 1266. if (kind == WEB) (void) makemon(&mons[PM_GIANT_SPIDER], 1267. m.x, m.y, NO_MM_FLAGS); 1268. } 1269. 1270. void 1271. mkstairs(x, y, up, croom) 1272. xchar x, y; 1273. char up; 1274. struct mkroom *croom; 1275. { 1276. if (!x) { 1277. impossible("mkstairs: bogus stair attempt at <%d,%d>", x, y); 1278. return; 1279. } 1280. 1281. /* 1282. * We can't make a regular stair off an end of the dungeon. This 1283. * attempt can happen when a special level is placed at an end and 1284. * has an up or down stair specified in its description file. 1285. */ 1286. if ((dunlev(&u.uz) == 1 && up) || 1287. (dunlev(&u.uz) == dunlevs_in_dungeon(&u.uz) && !up)) 1288. return; 1289. 1290. if(up) { 1291. xupstair = x; 1292. yupstair = y; 1293. upstairs_room = croom; 1294. } else { 1295. xdnstair = x; 1296. ydnstair = y; 1297. dnstairs_room = croom; 1298. } 1299. 1300. levl[x][y].typ = STAIRS; 1301. levl[x][y].ladder = up ? LA_UP : LA_DOWN; 1302. } 1303. 1304. STATIC_OVL 1305. void 1306. mkfount(mazeflag,croom) 1307. register int mazeflag; 1308. register struct mkroom *croom; 1309. { 1310. coord m; 1311. register int tryct = 0; 1312. 1313. do { 1314. if(++tryct > 200) return; 1315. if(mazeflag) 1316. mazexy(&m); 1317. else 1318. if (!somexy(croom, &m)) 1319. return; 1320. } while(occupied(m.x, m.y) || bydoor(m.x, m.y)); 1321. 1322. /* Put a fountain at m.x, m.y */ 1323. levl[m.x][m.y].typ = FOUNTAIN; 1324. /* Is it a "blessed" fountain? (affects drinking from fountain) */ 1325. if(!rn2(7)) levl[m.x][m.y].blessedftn = 1; 1326. 1327. level.flags.nfountains++; 1328. } 1329. 1330. #ifdef SINKS 1331. STATIC_OVL void 1332. mksink(croom) 1333. register struct mkroom *croom; 1334. { 1335. coord m; 1336. register int tryct = 0; 1337. 1338. do { 1339. if(++tryct > 200) return; 1340. if (!somexy(croom, &m)) 1341. return; 1342. } while(occupied(m.x, m.y) || bydoor(m.x, m.y)); 1343. 1344. /* Put a sink at m.x, m.y */ 1345. levl[m.x][m.y].typ = SINK; 1346. 1347. level.flags.nsinks++; 1348. } 1349. #endif /* SINKS */ 1350. 1351. 1352. STATIC_OVL void 1353. mkaltar(croom) 1354. register struct mkroom *croom; 1355. { 1356. coord m; 1357. register int tryct = 0; 1358. aligntyp al; 1359. 1360. if (croom->rtype != OROOM) return; 1361. 1362. do { 1363. if(++tryct > 200) return; 1364. if (!somexy(croom, &m)) 1365. return; 1366. } while (occupied(m.x, m.y) || bydoor(m.x, m.y)); 1367. 1368. /* Put an altar at m.x, m.y */ 1369. levl[m.x][m.y].typ = ALTAR; 1370. 1371. /* -1 - A_CHAOTIC, 0 - A_NEUTRAL, 1 - A_LAWFUL */ 1372. al = rn2((int)A_LAWFUL+2) - 1; 1373. levl[m.x][m.y].altarmask = Align2amask( al ); 1374. } 1375. 1376. static void 1377. mkgrave(croom) 1378. struct mkroom *croom; 1379. { 1380. coord m; 1381. register int tryct = 0; 1382. register struct obj *otmp; 1383. boolean dobell = !rn2(10); 1384. 1385. 1386. if(croom->rtype != OROOM) return; 1387. 1388. do { 1389. if(++tryct > 200) return; 1390. if (!somexy(croom, &m)) 1391. return; 1392. } while (occupied(m.x, m.y) || bydoor(m.x, m.y)); 1393. 1394. /* Put a grave at m.x, m.y */ 1395. make_grave(m.x, m.y, dobell ? "Saved by the bell!" : (char *) 0); 1396. 1397. /* Possibly fill it with objects */ 1398. if (!rn2(3)) (void) mkgold(0L, m.x, m.y); 1399. for (tryct = rn2(5); tryct; tryct--) { 1400. otmp = mkobj(RANDOM_CLASS, TRUE); 1401. if (!otmp) return; 1402. curse(otmp); 1403. otmp->ox = m.x; 1404. otmp->oy = m.y; 1405. add_to_buried(otmp); 1406. } 1407. 1408. /* Leave a bell, in case we accidentally buried someone alive */ 1409. if (dobell) (void) mksobj_at(BELL, m.x, m.y, TRUE, FALSE); 1410. return; 1411. } 1412. 1413. 1414. /* maze levels have slightly different constraints from normal levels */ 1415. #define x_maze_min 2 1416. #define y_maze_min 2 1417. /* 1418. * Major level transmutation: add a set of stairs (to the Sanctum) after 1419. * an earthquake that leaves behind a a new topology, centered at inv_pos. 1420. * Assumes there are no rooms within the invocation area and that inv_pos 1421. * is not too close to the edge of the map. Also assume the hero can see, 1422. * which is guaranteed for normal play due to the fact that sight is needed 1423. * to read the Book of the Dead. 1424. */ 1425. void 1426. mkinvokearea() 1427. { 1428. int dist; 1429. xchar xmin = inv_pos.x, xmax = inv_pos.x; 1430. xchar ymin = inv_pos.y, ymax = inv_pos.y; 1431. register xchar i; 1432. 1433. pline_The("floor shakes violently under you!"); 1434. pline_The("walls around you begin to bend and crumble!"); 1435. display_nhwindow(WIN_MESSAGE, TRUE); 1436. 1437. mkinvpos(xmin, ymin, 0); /* middle, before placing stairs */ 1438. 1439. for(dist = 1; dist < 7; dist++) { 1440. xmin--; xmax++; 1441. 1442. /* top and bottom */ 1443. if(dist != 3) { /* the area is wider that it is high */ 1444. ymin--; ymax++; 1445. for(i = xmin+1; i < xmax; i++) { 1446. mkinvpos(i, ymin, dist); 1447. mkinvpos(i, ymax, dist); 1448. } 1449. } 1450. 1451. /* left and right */ 1452. for(i = ymin; i <= ymax; i++) { 1453. mkinvpos(xmin, i, dist); 1454. mkinvpos(xmax, i, dist); 1455. } 1456. 1457. flush_screen(1); /* make sure the new glyphs shows up */ 1458. delay_output(); 1459. } 1460. 1461. You("are standing at the top of a stairwell leading down!"); 1462. mkstairs(u.ux, u.uy, 0, (struct mkroom *)0); /* down */ 1463. newsym(u.ux, u.uy); 1464. vision_full_recalc = 1; /* everything changed */ 1465. } 1466. 1467. /* Change level topology. Boulders in the vicinity are eliminated. 1468. * Temporarily overrides vision in the name of a nice effect. 1469. */ 1470. STATIC_OVL void 1471. mkinvpos(x,y,dist) 1472. xchar x,y; 1473. int dist; 1474. { 1475. struct trap *ttmp; 1476. struct obj *otmp; 1477. boolean make_rocks; 1478. register struct rm *lev = &levl[x][y]; 1479. 1480. /* clip at existing map borders if necessary */ 1481. if (!within_bounded_area(x, y, x_maze_min + 1, y_maze_min + 1, 1482. x_maze_max - 1, y_maze_max - 1)) { 1483. /* only outermost 2 columns and/or rows may be truncated due to edge */ 1484. if (dist < (7 - 2)) 1485. panic("mkinvpos: <%d,%d> (%d) off map edge!", x, y, dist); 1486. return; 1487. } 1488. 1489. /* clear traps */ 1490. if ((ttmp = t_at(x,y)) != 0) deltrap(ttmp); 1491. 1492. /* clear boulders; leave some rocks for non-{moat|trap} locations */ 1493. make_rocks = (dist != 1 && dist != 4 && dist != 5) ? TRUE : FALSE; 1494. while ((otmp = sobj_at(BOULDER, x, y)) != 0) { 1495. if (make_rocks) { 1496. fracture_rock(otmp); 1497. make_rocks = FALSE; /* don't bother with more rocks */ 1498. } else { 1499. obj_extract_self(otmp); 1500. obfree(otmp, (struct obj *)0); 1501. } 1502. } 1503. unblock_point(x,y); /* make sure vision knows this location is open */ 1504. 1505. /* fake out saved state */ 1506. lev->seenv = 0; 1507. lev->doormask = 0; 1508. if(dist < 6) lev->lit = TRUE; 1509. lev->waslit = TRUE; 1510. lev->horizontal = FALSE; 1511. viz_array[y][x] = (dist < 6 ) ? 1512. (IN_SIGHT|COULD_SEE) : /* short-circuit vision recalc */ 1513. COULD_SEE; 1514. 1515. switch(dist) { 1516. case 1: /* fire traps */ 1517. if (is_pool(x,y)) break; 1518. lev->typ = ROOM; 1519. ttmp = maketrap(x, y, FIRE_TRAP); 1520. if (ttmp) ttmp->tseen = TRUE; 1521. break; 1522. case 0: /* lit room locations */ 1523. case 2: 1524. case 3: 1525. case 6: /* unlit room locations */ 1526. lev->typ = ROOM; 1527. break; 1528. case 4: /* pools (aka a wide moat) */ 1529. case 5: 1530. lev->typ = MOAT; 1531. /* No kelp! */ 1532. break; 1533. default: 1534. impossible("mkinvpos called with dist %d", dist); 1535. break; 1536. } 1537. 1538. /* display new value of position; could have a monster/object on it */ 1539. newsym(x,y); 1540. } 1541. 1542. /* 1543. * The portal to Ludios is special. The entrance can only occur within a 1544. * vault in the main dungeon at a depth greater than 10. The Ludios branch 1545. * structure reflects this by having a bogus "source" dungeon: the value 1546. * of n_dgns (thus, Is_branchlev() will never find it). 1547. * 1548. * Ludios will remain isolated until the branch is corrected by this function. 1549. */ 1550. STATIC_OVL void 1551. mk_knox_portal(x, y) 1552. xchar x, y; 1553. { 1554. extern int n_dgns; /* from dungeon.c */ 1555. d_level *source; 1556. branch *br; 1557. schar u_depth; 1558. 1559. br = dungeon_branch("Fort Ludios"); 1560. if (on_level(&knox_level, &br->end1)) { 1561. source = &br->end2; 1562. } else { 1563. /* disallow Knox branch on a level with one branch already */ 1564. if(Is_branchlev(&u.uz)) 1565. return; 1566. source = &br->end1; 1567. } 1568. 1569. /* Already set or 2/3 chance of deferring until a later level. */ 1570. if (source->dnum < n_dgns || (rn2(3) 1571. #ifdef WIZARD 1572. && !wizard 1573. #endif 1574. )) return; 1575. 1576. if (! (u.uz.dnum == oracle_level.dnum /* in main dungeon */ 1577. && !at_dgn_entrance("The Quest") /* but not Quest's entry */ 1578. && (u_depth = depth(&u.uz)) > 10 /* beneath 10 */ 1579. && u_depth < depth(&medusa_level))) /* and above Medusa */ 1580. return; 1581. 1582. /* Adjust source to be current level and re-insert branch. */ 1583. *source = u.uz; 1584. insert_branch(br, TRUE); 1585. 1586. #ifdef DEBUG 1587. pline("Made knox portal."); 1588. #endif 1589. place_branch(br, x, y); 1590. } 1591. 1592. /*mklev.c*/